noticg 0.1.0

package/notice-gen

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import fscb from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import process from "node:process";
+
+const LICENSE_FILE_NAMES = [
+  "LICENSE",
+  "LICENSE.md",
+  "LICENSE.txt",
+  "LICENCE",
+  "LICENCE.md",
+  "LICENCE.txt",
+  "COPYING",
+  "COPYING.txt",
+  "NOTICE",
+  "NOTICE.txt",
+];
+
+const DEFAULT_OUT = "NOTICE.md";
+
+function parseArgs(argv) {
+  const args = {
+    out: DEFAULT_OUT,
+    format: "md",
+    root: process.cwd(),
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+
+    if (arg === "--out" && next) {
+      args.out = next;
+      i++;
+      continue;
+    }
+
+    if (arg.startsWith("--out=")) {
+      args.out = arg.slice("--out=".length);
+      continue;
+    }
+
+    if (arg === "--format" && next) {
+      args.format = next;
+      i++;
+      continue;
+    }
+
+    if (arg.startsWith("--format=")) {
+      args.format = arg.slice("--format=".length);
+      continue;
+    }
+
+    if (arg === "--root" && next) {
+      args.root = path.resolve(next);
+      i++;
+      continue;
+    }
+
+    if (arg.startsWith("--root=")) {
+      args.root = path.resolve(arg.slice("--root=".length));
+      continue;
+    }
+  }
+
+  return args;
+}
+
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(filePath) {
+  const raw = await fs.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+
+function normalizeLicenseField(license) {
+  if (!license) return "UNKNOWN";
+  if (typeof license === "string") return license.trim() || "UNKNOWN";
+  if (Array.isArray(license)) {
+    return license
+      .map((item) => {
+        if (typeof item === "string") return item;
+        if (item && typeof item === "object") return item.type || item.name || "";
+        return "";
+      })
+      .filter(Boolean)
+      .join(" OR ") || "UNKNOWN";
+  }
+  if (typeof license === "object") {
+    return license.type || license.name || "UNKNOWN";
+  }
+  return "UNKNOWN";
+}
+
+function escapeMarkdown(text) {
+  return String(text)
+    .replaceAll("\\", "\\\\")
+    .replaceAll("`", "\\`")
+    .replaceAll("*", "\\*")
+    .replaceAll("_", "\\_")
+    .replaceAll("{", "\\{")
+    .replaceAll("}", "\\}")
+    .replaceAll("[", "\\[")
+    .replaceAll("]", "\\]")
+    .replaceAll("(", "\\(")
+    .replaceAll(")", "\\)")
+    .replaceAll("#", "\\#")
+    .replaceAll("+", "\\+")
+    .replaceAll("-", "\\-")
+    .replaceAll("!", "\\!");
+}
+
+async function findLicenseFile(pkgDir) {
+  for (const name of LICENSE_FILE_NAMES) {
+    const candidate = path.join(pkgDir, name);
+    if (await fileExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  // Fallback: scan for a file that starts with LICENSE / COPYING / NOTICE
+  try {
+    const entries = await fs.readdir(pkgDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile()) continue;
+      const upper = entry.name.toUpperCase();
+      if (
+        upper.startsWith("LICENSE") ||
+        upper.startsWith("LICENCE") ||
+        upper.startsWith("COPYING") ||
+        upper.startsWith("NOTICE")
+      ) {
+        return path.join(pkgDir, entry.name);
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  return null;
+}
+
+async function readLicenseText(pkgDir, pkgJson) {
+  const licenseFile = await findLicenseFile(pkgDir);
+  if (licenseFile) {
+    try {
+      const text = await fs.readFile(licenseFile, "utf8");
+      return {
+        source: path.basename(licenseFile),
+        text: text.trim(),
+      };
+    } catch {
+      // ignore and fallback below
+    }
+  }
+
+  const license = normalizeLicenseField(pkgJson.license || pkgJson.licenses);
+  return {
+    source: "package.json",
+    text: `License information not found in a license file.\nDeclared license: ${license}`,
+  };
+}
+
+function isSkippablePackage(meta = {}) {
+  return Boolean(
+    meta.dev ||
+      meta.optional ||
+      meta.peer ||
+      meta.extraneous ||
+      meta.link ||
+      meta.inBundle
+  );
+}
+
+async function collectFromPackageLock(root) {
+  const lockPath = path.join(root, "package-lock.json");
+  if (!(await fileExists(lockPath))) return null;
+
+  const lock = await readJson(lockPath);
+
+  // npm lockfile v2/v3
+  if (lock && lock.packages && typeof lock.packages === "object") {
+    const items = [];
+    const seen = new Set();
+
+    for (const [relPath, meta] of Object.entries(lock.packages)) {
+      if (!relPath) continue; // root package
+
+      if (isSkippablePackage(meta)) continue;
+
+      const pkgDir = path.join(root, relPath);
+      const pkgJsonPath = path.join(pkgDir, "package.json");
+      if (!(await fileExists(pkgJsonPath))) continue;
+
+      const pkgJson = await readJson(pkgJsonPath);
+      const name = pkgJson.name || meta.name || path.basename(pkgDir);
+      const version = pkgJson.version || meta.version || "0.0.0";
+      const key = `${name}@${version}`;
+
+      if (seen.has(key)) continue;
+      seen.add(key);
+
+      const licenseText = await readLicenseText(pkgDir, pkgJson);
+
+      items.push({
+        name,
+        version,
+        license: normalizeLicenseField(pkgJson.license || pkgJson.licenses || meta.license),
+        homepage: pkgJson.homepage || meta.homepage || "",
+        repository:
+          typeof pkgJson.repository === "string"
+            ? pkgJson.repository
+            : pkgJson.repository?.url || "",
+        pkgDir,
+        licenseText,
+      });
+    }
+
+    items.sort((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
+    return items;
+  }
+
+  // npm lockfile v1 fallback
+  if (lock && lock.dependencies && typeof lock.dependencies === "object") {
+    const items = [];
+    const seen = new Set();
+
+    const walk = async (deps) => {
+      for (const [name, meta] of Object.entries(deps)) {
+        if (!meta || isSkippablePackage(meta)) continue;
+
+        const version = meta.version || "0.0.0";
+        const key = `${name}@${version}`;
+        if (!seen.has(key)) {
+          const pkgDir = path.join(root, "node_modules", name);
+          const pkgJsonPath = path.join(pkgDir, "package.json");
+
+          if (await fileExists(pkgJsonPath)) {
+            const pkgJson = await readJson(pkgJsonPath);
+            seen.add(key);
+
+            items.push({
+              name: pkgJson.name || name,
+              version: pkgJson.version || version,
+              license: normalizeLicenseField(pkgJson.license || pkgJson.licenses || meta.license),
+              homepage: pkgJson.homepage || "",
+              repository:
+                typeof pkgJson.repository === "string"
+                  ? pkgJson.repository
+                  : pkgJson.repository?.url || "",
+              pkgDir,
+              licenseText: await readLicenseText(pkgDir, pkgJson),
+            });
+          }
+        }
+
+        if (meta.dependencies && typeof meta.dependencies === "object") {
+          await walk(meta.dependencies);
+        }
+      }
+    };
+
+    await walk(lock.dependencies);
+    items.sort((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
+    return items;
+  }
+
+  return null;
+}
+
+async function collectFromNpmLs(root) {
+  try {
+    const out = execFileSync(
+      "npm",
+      ["ls", "--json", "--all", "--long", "--omit=dev"],
+      {
+        cwd: root,
+        encoding: "utf8",
+        maxBuffer: 50 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"],
+      }
+    );
+
+    const tree = JSON.parse(out);
+    const items = [];
+    const seen = new Set();
+
+    const walk = async (deps) => {
+      if (!deps || typeof deps !== "object") return;
+
+      for (const [name, node] of Object.entries(deps)) {
+        if (!node || isSkippablePackage(node)) continue;
+
+        const version = node.version || "0.0.0";
+        const key = `${name}@${version}`;
+        let pkgDir = node.path || "";
+
+        if (!pkgDir && node._location) {
+          pkgDir = path.join(root, node._location);
+        }
+
+        if (!pkgDir) {
+          pkgDir = path.join(root, "node_modules", name);
+        }
+
+        const pkgJsonPath = path.join(pkgDir, "package.json");
+        if (seen.has(key)) {
+          if (node.dependencies) await walk(node.dependencies);
+          continue;
+        }
+
+        if (!(await fileExists(pkgJsonPath))) {
+          if (node.dependencies) await walk(node.dependencies);
+          continue;
+        }
+
+        const pkgJson = await readJson(pkgJsonPath);
+        seen.add(key);
+
+        items.push({
+          name: pkgJson.name || name,
+          version: pkgJson.version || version,
+          license: normalizeLicenseField(pkgJson.license || pkgJson.licenses || node.license),
+          homepage: pkgJson.homepage || "",
+          repository:
+            typeof pkgJson.repository === "string"
+              ? pkgJson.repository
+              : pkgJson.repository?.url || "",
+          pkgDir,
+          licenseText: await readLicenseText(pkgDir, pkgJson),
+        });
+
+        if (node.dependencies) await walk(node.dependencies);
+      }
+    };
+
+    await walk(tree.dependencies);
+    items.sort((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
+    return items;
+  } catch {
+    return null;
+  }
+}
+
+function formatNoticeMarkdown(items, rootPackageName) {
+  const header = [
+    "# NOTICE",
+    "",
+    `This file lists third-party software used by **${rootPackageName}**.`,
+    "",
+    "---",
+    "",
+  ].join("\n");
+
+  const sections = items.map((item, index) => {
+    const metaLines = [
+      `## ${index + 1}. ${escapeMarkdown(item.name)}`,
+      "",
+      `- Version: \`${escapeMarkdown(item.version)}\``,
+      `- License: \`${escapeMarkdown(item.license)}\``,
+    ];
+
+    if (item.homepage) metaLines.push(`- Homepage: ${escapeMarkdown(item.homepage)}`);
+    if (item.repository) metaLines.push(`- Repository: ${escapeMarkdown(item.repository)}`);
+
+    metaLines.push("");
+    metaLines.push(`### License text (${escapeMarkdown(item.licenseText.source)})`);
+    metaLines.push("");
+    metaLines.push("```text");
+    metaLines.push(item.licenseText.text || "License text not available.");
+    metaLines.push("```");
+    metaLines.push("");
+    metaLines.push("---");
+    metaLines.push("");
+
+    return metaLines.join("\n");
+  });
+
+  return [header, ...sections].join("\n");
+}
+
+async function main() {
+  const { out, root } = parseArgs(process.argv);
+
+  const rootPkgPath = path.join(root, "package.json");
+  if (!(await fileExists(rootPkgPath))) {
+    console.error(`package.json not found in: ${root}`);
+    process.exit(1);
+  }
+
+  const rootPkg = await readJson(rootPkgPath);
+  const rootPackageName = rootPkg.name || path.basename(root);
+
+  let items = await collectFromPackageLock(root);
+  if (!items) {
+    items = await collectFromNpmLs(root);
+  }
+
+  if (!items || items.length === 0) {
+    console.error("No third-party dependencies found, or dependency tree could not be read.");
+    process.exit(1);
+  }
+
+  const notice = formatNoticeMarkdown(items, rootPackageName);
+  const outPath = path.isAbsolute(out) ? out : path.join(root, out);
+
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  await fs.writeFile(outPath, notice, "utf8");
+
+  console.log(`NOTICE written to: ${outPath}`);
+  console.log(`Included packages: ${items.length}`);
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.stack || err.message : String(err));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "noticg",
+  "version": "0.1.0",
+  "description": "NOTICG - A Notice License Generator",
+  "keywords": [
+    "notice-gen",
+    "notice-file",
+    "license",
+    "licensor"
+  ],
+  "homepage": "https://github.com/KhairyK/zetro#readme",
+  "bugs": {
+    "url": "https://github.com/KhairyK/zetro/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KhairyK/zetro.git"
+  },
+  "license": "Apache-2.0",
+  "author": "Sholehuddin Khairy (KhairyK)",
+  "type": "module",
+  "main": "notice-gen",
+  "bin": {
+    "noticg": "./notice-gen"
+  }
+}