feat(experimental): init li cli for adding data to li

Author: 06kellyjac

experimental/li-cli/package-lock.json

@@ -0,0 +1,28 @@
+{
+  "name": "@finos/git-proxy-li-cli",
+  "version": "0.0.1",
+  "author": "git-proxy contributors",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "ts-node src/cli.ts",
+    "build": "rimraf dist && tsc --project tsconfig.publish.json && tsc-alias && chmod u+x ./dist/cli.js",
+    "type-check": "tsc --noEmit",
+    "test": "jest --forceExit --detectOpenHandles"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.3.1",
+    "yaml": "^2.7.0",
+    "yargs": "^17.7.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.9",
+    "@types/yargs": "^17.0.33",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.7.3"
+  }
+}

experimental/li-cli/package.json

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import addLicenseCMD from './cmds/add-license';
+import process from 'node:process';
+
+yargs(hideBin(process.argv))
+  // .command(
+  //   'serve [port]',
+  //   'start the server',
+  //   (yargs) => {
+  //     return yargs.positional('port', {
+  //       describe: 'port to bind on',
+  //       default: 5000,
+  //     });
+  //   },
+  //   (argv) => {
+  //     addLicenseCMD();
+  //   },
+  // )
+  .option('li-url', {
+    type: 'string',
+    describe: 'The url of the license inventory instance',
+  })
+  .command(
+    'add-license [SPDXID]',
+    '',
+    (yargs) =>
+      yargs
+        .positional('SPDXID', {
+          type: 'string',
+          describe: 'ID of license',
+        })
+        .option('require-cal', {
+          type: 'boolean',
+          default: false,
+          describe: 'require successful collection of info from Choose A License',
+        })
+        .demandOption('li-url'),
+    async (argv) => {
+      try {
+        await addLicenseCMD(argv['li-url'], {
+          spdxID: argv.SPDXID,
+          requireCal: argv['require-cal'],
+        });
+      } catch (e) {
+        process.exit(1);
+      }
+    },
+  )
+  .option('verbose', {
+    alias: 'v',
+    type: 'boolean',
+    description: 'Run with verbose logging',
+  })
+  .demandCommand()
+  .help()
+  .parse();

experimental/li-cli/src/cli.ts

@@ -0,0 +1,84 @@
+import { setTimeout } from 'node:timers/promises';
+import { search } from '@inquirer/prompts';
+import { getLicenseList, LicensesMap } from '../lib/spdx';
+import { CalInfo, InventoryLicense, pushLicense } from '../lib/inventory';
+import { getCALData } from '../lib/chooseALicense';
+
+// const answer = await input({ message: 'Enter your name' });
+
+type Option = {
+  name: string;
+  value: string;
+};
+
+type AddLicenseCMDOptions = {
+  spdxID?: string;
+  requireCal?: boolean;
+};
+
+async function promptForSPDXID(licenseList: LicensesMap): Promise<string> {
+  const options: Option[] = [];
+  licenseList.forEach(({ licenseId }, k) => {
+    options.push({ name: licenseId, value: k });
+  });
+  const selectedLicenseID = await search({
+    message: 'Select a license',
+    source: async (input, { signal }) => {
+      await setTimeout(300);
+      if (signal.aborted) return options;
+      if (typeof input !== 'string' || input.length < 1) {
+        return options;
+      }
+      // TODO: itterate over itterable rather than convert to array then map
+      // TODO: fuzzy match
+      return options.filter((o) => o.value.toLowerCase().startsWith(input?.toLowerCase()));
+    },
+  });
+  return selectedLicenseID;
+}
+
+async function addLicenseCMD(liURL: string, options?: AddLicenseCMDOptions) {
+  console.info('fetching license list from `spdx.org`');
+  const licenseList = await getLicenseList();
+  console.info('done fetching');
+
+  const selectedLicenseID = options?.spdxID ?? (await promptForSPDXID(licenseList));
+
+  const selectedLicense = licenseList.get(selectedLicenseID);
+  if (typeof selectedLicense !== 'object') {
+    console.error("license doesn't exist in list fetched from `spdx.org`");
+    throw new Error('missing license');
+  }
+
+  console.info(`fetching Choose A License info for license \`${selectedLicense.licenseId}\``);
+
+  let chooseALicenseInfo: CalInfo | undefined = undefined;
+  try {
+    const cal = await getCALData(selectedLicense.licenseId.toLowerCase());
+    chooseALicenseInfo = cal;
+  } catch (e) {
+    console.log('failed to get info from Choose A License');
+    if (options?.requireCal) {
+      throw new Error('forced the need for CAL data');
+    }
+  }
+
+  const licenseData: InventoryLicense = {
+    name: selectedLicense.name,
+    spdxID: selectedLicense.licenseId,
+    chooseALicenseInfo,
+  };
+
+  let licenseID: string;
+  try {
+    const id = await pushLicense(liURL, licenseData);
+    licenseID = id;
+  } catch (e) {
+    console.error('failed to submit license data');
+    throw new Error('failed to submit');
+  }
+
+  console.log(`License \`${selectedLicense.licenseId}\` added to inventory as \`${licenseID}\``);
+}
+
+export default addLicenseCMD;

experimental/li-cli/src/cmds/add-license.ts

@@ -0,0 +1,86 @@
+import YAML from 'yaml';
+import z from 'zod';
+import { CalInfo } from './inventory';
+
+const chooseALicenseSchema = z.object({
+  conditions: z.string().array(),
+  limitations: z.string().array(),
+  permissions: z.string().array(),
+});
+
+type ChooseALicenseData = z.infer<typeof chooseALicenseSchema>;
+
+function extractPreamble(text: string): string {
+  const lines = text.split('\n'); // Split into lines
+  let result: string[] = [];
+  let insideBlock = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim(); // Remove extra spaces
+
+    if (trimmed === '---') {
+      if (insideBlock) break; // Stop at the second `---`
+      insideBlock = true; // Start capturing after first `---`
+      continue;
+    }
+
+    if (insideBlock) {
+      result.push(line); // Collect valid lines
+    }
+  }
+
+  return result.join('\n').trim(); // Join and clean up
+}
+
+export const getCALData = async (spdxID: string): Promise<CalInfo | undefined> => {
+  // TODO: add path customization
+
+  const req = await fetch(
+    `https://raw.githubusercontent.com/github/choosealicense.com/refs/heads/gh-pages/_licenses/${spdxID}.txt`,
+  );
+  const data = await req.text();
+  const preamble = extractPreamble(data);
+
+  const parsedPreamble = YAML.parse(preamble);
+
+  const { data: calData, error } = chooseALicenseSchema.safeParse(parsedPreamble);
+  if (error) {
+    throw new Error("couldn't process data", { cause: error });
+  }
+
+  // TODO: define the keys and children we recognise, raise issues if new ones are added, automatically format test to object keys + booleans
+  const processedData: CalInfo = {
+    ...(calData.permissions.length > 0 && {
+      permissions: {
+        ...(calData.permissions.includes('commercial-use') && { commercialUse: true }),
+        ...(calData.permissions.includes('modifications') && { modifications: true }),
+        ...(calData.permissions.includes('distribution') && { distribution: true }),
+        ...(calData.permissions.includes('private-use') && { privateUse: true }),
+        ...(calData.permissions.includes('patent-use') && { patentUse: true }),
+      },
+    }),
+    ...(calData.conditions.length > 0 && {
+      conditions: {
+        ...(calData.conditions.includes('include-copyright') && { includeCopyright: true }),
+        ...(calData.conditions.includes('include-copyright--source') && {
+          includeCopyrightSource: true,
+        }),
+        ...(calData.conditions.includes('document-changes') && { documentChanges: true }),
+        ...(calData.conditions.includes('disclose-source') && { discloseSource: true }),
+        ...(calData.conditions.includes('network-use-disclose') && { networkUseDisclose: true }),
+        ...(calData.conditions.includes('same-license') && { sameLicense: true }),
+        ...(calData.conditions.includes('same-license--file') && { sameLicenseFile: true }),
+        ...(calData.conditions.includes('same-license--library') && { sameLicenseLibrary: true }),
+      },
+    }),
+    ...(calData.limitations.length > 0 && {
+      limitations: {
+        ...(calData.limitations.includes('trademark-use') && { trademarkUse: true }),
+        ...(calData.limitations.includes('liability') && { liability: true }),
+        ...(calData.limitations.includes('patent-use') && { patentUse: true }),
+        ...(calData.limitations.includes('warranty') && { warranty: true }),
+      },
+    }),
+  };
+  return Object.keys(processedData).length > 0 ? processedData : undefined;
+};

experimental/li-cli/src/lib/chooseALicense.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+
+export type CalInfo = {
+  permissions?: {
+    commercialUse?: boolean;
+    modifications?: boolean;
+    distribution?: boolean;
+    privateUse?: boolean;
+    patentUse?: boolean;
+  };
+  conditions?: {
+    includeCopyright?: boolean;
+    includeCopyrightSource?: boolean;
+    documentChanges?: boolean;
+    discloseSource?: boolean;
+    networkUseDisclose?: boolean;
+    sameLicense?: boolean;
+    sameLicenseFile?: boolean;
+    sameLicenseLibrary?: boolean;
+  };
+  limitations?: {
+    trademarkUse?: boolean;
+    liability?: boolean;
+    patentUse?: boolean;
+    warranty?: boolean;
+  };
+};
+
+export type InventoryLicense = {
+  name: string;
+  spdxID?: string;
+  chooseALicenseInfo?: CalInfo;
+};
+
+const pushLicenseSchema = z.object({
+  id: z.string().uuid(),
+});
+
+export async function pushLicense(liURL: string, data: InventoryLicense): Promise<string> {
+  const path = '/api/v0/licenses/';
+  const res = await fetch(liURL + path, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(data),
+  });
+  if (!res.ok) {
+    throw new Error(await res.text());
+  }
+  const resObj = await res.json();
+  const { data: resData, error } = pushLicenseSchema.safeParse(resObj);
+  if (error) {
+    throw new Error("couldn't process data", { cause: error });
+  }
+  return resData.id;
+}

experimental/li-cli/src/lib/inventory.ts

@@ -0,0 +1,49 @@
+import z from 'zod';
+
+const license = z.object({
+  detailsUrl: z.string().url(),
+  name: z.string(),
+  licenseId: z.string(),
+});
+
+export type License = z.infer<typeof license>;
+export type LicensesMap = Map<string, License>;
+
+const licenses = z.object({
+  licenseListVersion: z.string(),
+  licenses: license.array(),
+});
+
+export const getLicenseList = async () => {
+  // https://spdx.org/licenses/licenses.json
+  const req = await fetch('https://spdx.org/licenses/licenses.json');
+  const data = await req.json();
+  const { data: parsed, error } = licenses.safeParse(data);
+  if (error) {
+    throw new Error("couldn't get license list", { cause: error });
+  }
+
+  const licenseMap = new Map<string, License>();
+  parsed.licenses.forEach((license) => {
+    licenseMap.set(license.licenseId.toLowerCase(), license);
+  });
+
+  return licenseMap;
+};
+
+export const getLicenseData = async (url: string) => {
+  // https://spdx.org/licenses/licenses.json
+  const req = await fetch(url);
+  const data = await req.json();
+  const { data: parsed, error } = licenses.safeParse(data);
+  if (error) {
+    throw new Error("couldn't get license list", { cause: error });
+  }
+
+  const licenseMap = new Map<string, License>();
+  parsed.licenses.forEach((license) => {
+    licenseMap.set(license.licenseId, license);
+  });
+
+  return licenseMap;
+};