@openpkg-ts/cli 0.2.3 → 0.3.1

package/dist/bin/openpkg.js

@@ -0,0 +1,701 @@
+#!/usr/bin/env bun
+import {
+  __require,
+  __toESM
+} from "../shared/chunk-1dqs11h6.js";
+
+// bin/openpkg.ts
+import * as path10 from "node:path";
+import { getExport, listExports } from "@openpkg-ts/sdk";
+import { Command as Command10 } from "commander";
+// package.json
+var package_default = {
+  name: "@openpkg-ts/cli",
+  version: "0.3.0",
+  description: "CLI for OpenPkg TypeScript API extraction and documentation generation",
+  homepage: "https://github.com/ryanwaits/openpkg-ts#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ryanwaits/openpkg-ts.git",
+    directory: "packages/cli"
+  },
+  type: "module",
+  main: "./dist/src/index.js",
+  types: "./dist/src/index.d.ts",
+  bin: {
+    openpkg: "./dist/bin/openpkg.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "bunup",
+    dev: "bunup --watch",
+    test: "bun test"
+  },
+  dependencies: {
+    "@openpkg-ts/adapters": "^0.3.0",
+    "@openpkg-ts/sdk": "^0.31.0",
+    commander: "^14.0.0"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/node": "^20.0.0",
+    bunup: "latest"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/commands/breaking.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  categorizeBreakingChanges,
+  diffSpec
+} from "@openpkg-ts/spec";
+import { Command } from "commander";
+function loadSpec(filePath) {
+  const resolved = path.resolve(filePath);
+  const content = fs.readFileSync(resolved, "utf-8");
+  return JSON.parse(content);
+}
+function createBreakingCommand() {
+  return new Command("breaking").description("Check for breaking changes between two specs").argument("<old>", "Path to old spec file (JSON)").argument("<new>", "Path to new spec file (JSON)").action(async (oldPath, newPath) => {
+    try {
+      const oldSpec = loadSpec(oldPath);
+      const newSpec = loadSpec(newPath);
+      const diff = diffSpec(oldSpec, newSpec);
+      const categorized = categorizeBreakingChanges(diff.breaking, oldSpec, newSpec);
+      const result = {
+        breaking: categorized,
+        count: categorized.length
+      };
+      console.log(JSON.stringify(result, null, 2));
+      if (categorized.length > 0) {
+        process.exit(1);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(JSON.stringify({ error: error.message }, null, 2));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/changelog.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import { Command as Command3 } from "commander";
+
+// src/commands/diff.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import {
+  categorizeBreakingChanges as categorizeBreakingChanges2,
+  diffSpec as diffSpec2,
+  recommendSemverBump
+} from "@openpkg-ts/spec";
+import { Command as Command2 } from "commander";
+function loadSpec2(filePath) {
+  const resolved = path2.resolve(filePath);
+  const content = fs2.readFileSync(resolved, "utf-8");
+  return JSON.parse(content);
+}
+function toExportMap(spec) {
+  const map = new Map;
+  for (const exp of spec.exports) {
+    map.set(exp.id, { name: exp.name, kind: exp.kind });
+  }
+  if (spec.types) {
+    for (const t of spec.types) {
+      map.set(t.id, { name: t.name, kind: t.kind });
+    }
+  }
+  return map;
+}
+function enrichDiff(oldSpec, newSpec) {
+  const rawDiff = diffSpec2(oldSpec, newSpec);
+  const categorized = categorizeBreakingChanges2(rawDiff.breaking, oldSpec, newSpec);
+  const semver = recommendSemverBump(rawDiff);
+  const oldExports = toExportMap(oldSpec);
+  const removed = [];
+  const changed = [];
+  const breaking = [];
+  for (const cat of categorized) {
+    if (cat.reason === "removed") {
+      const info = oldExports.get(cat.id);
+      removed.push({
+        id: cat.id,
+        name: cat.name,
+        kind: info?.kind ?? cat.kind
+      });
+    } else {
+      changed.push({
+        id: cat.id,
+        name: cat.name,
+        kind: cat.kind,
+        description: describeChange(cat)
+      });
+      breaking.push(cat);
+    }
+  }
+  const added = rawDiff.nonBreaking;
+  return {
+    breaking,
+    added,
+    removed,
+    changed,
+    docsOnly: rawDiff.docsOnly,
+    summary: {
+      breakingCount: breaking.length,
+      addedCount: added.length,
+      removedCount: removed.length,
+      changedCount: changed.length,
+      docsOnlyCount: rawDiff.docsOnly.length,
+      semverBump: semver.bump,
+      semverReason: semver.reason
+    }
+  };
+}
+function describeChange(cat) {
+  switch (cat.reason) {
+    case "signature changed":
+      return `Function signature changed`;
+    case "type definition changed":
+      return `Type definition changed`;
+    case "constructor changed":
+      return `Class constructor signature changed`;
+    case "methods removed":
+      return `Class methods removed`;
+    case "methods changed":
+      return `Class methods changed`;
+    case "changed":
+      return `${cat.kind} changed`;
+    default:
+      return cat.reason;
+  }
+}
+function createDiffCommand() {
+  return new Command2("diff").description("Compare two OpenPkg specs and show differences").argument("<old>", "Path to old spec file (JSON)").argument("<new>", "Path to new spec file (JSON)").option("--json", "Output as JSON (default)").option("--summary", "Only show summary").action(async (oldPath, newPath, options) => {
+    try {
+      const oldSpec = loadSpec2(oldPath);
+      const newSpec = loadSpec2(newPath);
+      const result = enrichDiff(oldSpec, newSpec);
+      if (options.summary) {
+        console.log(JSON.stringify(result.summary, null, 2));
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(JSON.stringify({ error: error.message }, null, 2));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/changelog.ts
+function loadSpec3(filePath) {
+  const resolved = path3.resolve(filePath);
+  const content = fs3.readFileSync(resolved, "utf-8");
+  return JSON.parse(content);
+}
+function formatMarkdown(diff) {
+  const lines = [];
+  if (diff.removed.length > 0 || diff.changed.length > 0) {
+    lines.push("## Breaking Changes");
+    lines.push("");
+    for (const r of diff.removed) {
+      lines.push(`- **Removed** \`${r.name}\` (${r.kind})`);
+    }
+    for (const c of diff.changed) {
+      lines.push(`- **${c.name}** (${c.kind}): ${c.description}`);
+    }
+    lines.push("");
+  }
+  if (diff.added.length > 0) {
+    lines.push("## Added");
+    lines.push("");
+    for (const id of diff.added) {
+      lines.push(`- \`${id}\``);
+    }
+    lines.push("");
+  }
+  if (diff.docsOnly.length > 0) {
+    lines.push("## Changed");
+    lines.push("");
+    for (const id of diff.docsOnly) {
+      lines.push(`- \`${id}\` (docs)`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`).trim() || "No changes detected.";
+}
+function createChangelogCommand() {
+  return new Command3("changelog").description("Generate changelog from diff between two specs").argument("<old>", "Path to old spec file (JSON)").argument("<new>", "Path to new spec file (JSON)").option("--format <format>", "Output format: md or json", "md").action(async (oldPath, newPath, options) => {
+    try {
+      const oldSpec = loadSpec3(oldPath);
+      const newSpec = loadSpec3(newPath);
+      const diff = enrichDiff(oldSpec, newSpec);
+      if (options.format === "json") {
+        console.log(JSON.stringify(diff, null, 2));
+      } else {
+        console.log(formatMarkdown(diff));
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(JSON.stringify({ error: error.message }, null, 2));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/diagnostics.ts
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import { analyzeSpec } from "@openpkg-ts/sdk";
+import { Command as Command4 } from "commander";
+function loadJSON(filePath) {
+  const resolved = path4.resolve(filePath);
+  const content = fs4.readFileSync(resolved, "utf-8");
+  return JSON.parse(content);
+}
+function createDiagnosticsCommand() {
+  return new Command4("diagnostics").description("Analyze spec for quality issues (missing docs, deprecated without reason)").argument("<spec>", "Path to spec file (JSON)").action(async (specPath) => {
+    try {
+      const spec = loadJSON(specPath);
+      const diagnostics = analyzeSpec(spec);
+      const result = {
+        summary: {
+          total: diagnostics.missingDescriptions.length + diagnostics.deprecatedNoReason.length + diagnostics.missingParamDocs.length,
+          missingDescriptions: diagnostics.missingDescriptions.length,
+          deprecatedNoReason: diagnostics.deprecatedNoReason.length,
+          missingParamDocs: diagnostics.missingParamDocs.length
+        },
+        diagnostics
+      };
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(0);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.log(JSON.stringify({ error: error.message }, null, 2));
+      process.exit(0);
+    }
+  });
+}
+
+// src/commands/docs.ts
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+import { createDocs, loadSpec as loadSpec4 } from "@openpkg-ts/sdk";
+import { Command as Command5 } from "commander";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function getExtension(format) {
+  switch (format) {
+    case "json":
+      return ".json";
+    case "html":
+      return ".html";
+    default:
+      return ".md";
+  }
+}
+function renderExport(docs, exportId, format) {
+  const exp = docs.getExport(exportId);
+  if (!exp)
+    throw new Error(`Export not found: ${exportId}`);
+  switch (format) {
+    case "json":
+      return JSON.stringify(docs.toJSON({ export: exportId }), null, 2);
+    case "html":
+      return docs.toHTML({ export: exportId });
+    default:
+      return docs.toMarkdown({ export: exportId, frontmatter: true, codeSignatures: true });
+  }
+}
+function renderFull(docs, format) {
+  switch (format) {
+    case "json":
+      return JSON.stringify(docs.toJSON(), null, 2);
+    case "html":
+      return docs.toHTML();
+    default:
+      return docs.toMarkdown({ frontmatter: true, codeSignatures: true });
+  }
+}
+function createDocsCommand() {
+  return new Command5("docs").description("Generate documentation from OpenPkg spec").argument("<spec>", "Path to openpkg.json spec file (use - for stdin)").option("-o, --output <path>", "Output file or directory (default: stdout)").option("-f, --format <format>", "Output format: md, json, html (default: md)", "md").option("--split", "Output one file per export (requires --output as directory)").option("-e, --export <name>", "Generate docs for a single export by name").option("-a, --adapter <name>", "Use adapter for generation (default: raw)").action(async (specPath, options) => {
+    const format = options.format || "md";
+    try {
+      if (options.adapter && options.adapter !== "raw") {
+        let getAdapter;
+        try {
+          const _adapterModule = await import(`@openpkg-ts/adapters/${options.adapter}`);
+          const registryModule = await import("@openpkg-ts/adapters");
+          getAdapter = registryModule.getAdapter;
+        } catch {
+          console.error(JSON.stringify({ error: `Failed to load adapter: ${options.adapter}` }));
+          process.exit(1);
+        }
+        const adapter = getAdapter(options.adapter);
+        if (!adapter) {
+          console.error(JSON.stringify({ error: `Unknown adapter: ${options.adapter}` }));
+          process.exit(1);
+        }
+        if (!options.output) {
+          console.error(JSON.stringify({ error: "--adapter requires --output <directory>" }));
+          process.exit(1);
+        }
+        let spec;
+        if (specPath === "-") {
+          const input = await readStdin();
+          spec = JSON.parse(input);
+        } else {
+          const specFile = path5.resolve(specPath);
+          if (!fs5.existsSync(specFile)) {
+            console.error(JSON.stringify({ error: `Spec file not found: ${specFile}` }));
+            process.exit(1);
+          }
+          spec = JSON.parse(fs5.readFileSync(specFile, "utf-8"));
+        }
+        await adapter.generate(spec, path5.resolve(options.output));
+        console.error(`Generated docs with ${options.adapter} adapter to ${options.output}`);
+        return;
+      }
+      let docs;
+      if (specPath === "-") {
+        const input = await readStdin();
+        const spec = JSON.parse(input);
+        docs = loadSpec4(spec);
+      } else {
+        const specFile = path5.resolve(specPath);
+        if (!fs5.existsSync(specFile)) {
+          console.error(JSON.stringify({ error: `Spec file not found: ${specFile}` }));
+          process.exit(1);
+        }
+        docs = createDocs(specFile);
+      }
+      if (options.export) {
+        const exports = docs.getAllExports();
+        const exp = exports.find((e) => e.name === options.export);
+        if (!exp) {
+          console.error(JSON.stringify({ error: `Export not found: ${options.export}` }));
+          process.exit(1);
+        }
+        const output2 = renderExport(docs, exp.id, format);
+        if (options.output && options.output !== "-") {
+          const outputPath = path5.resolve(options.output);
+          fs5.writeFileSync(outputPath, output2);
+          console.error(`Wrote ${outputPath}`);
+        } else {
+          console.log(output2);
+        }
+        return;
+      }
+      if (options.split) {
+        if (!options.output) {
+          console.error(JSON.stringify({ error: "--split requires --output <directory>" }));
+          process.exit(1);
+        }
+        const outDir = path5.resolve(options.output);
+        if (!fs5.existsSync(outDir)) {
+          fs5.mkdirSync(outDir, { recursive: true });
+        }
+        const exports = docs.getAllExports();
+        for (const exp of exports) {
+          const filename = `${exp.name}${getExtension(format)}`;
+          const filePath = path5.join(outDir, filename);
+          const content = renderExport(docs, exp.id, format);
+          fs5.writeFileSync(filePath, content);
+        }
+        console.error(`Wrote ${exports.length} files to ${outDir}`);
+        return;
+      }
+      const output = renderFull(docs, format);
+      if (options.output && options.output !== "-") {
+        const outputPath = path5.resolve(options.output);
+        fs5.writeFileSync(outputPath, output);
+        console.error(`Wrote ${outputPath}`);
+      } else {
+        console.log(output);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(JSON.stringify({ error: error.message }));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/filter.ts
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+import { filterSpec } from "@openpkg-ts/sdk";
+import { Command as Command6 } from "commander";
+var VALID_KINDS = [
+  "function",
+  "class",
+  "variable",
+  "interface",
+  "type",
+  "enum",
+  "module",
+  "namespace",
+  "reference",
+  "external"
+];
+function loadSpec5(filePath) {
+  const resolved = path6.resolve(filePath);
+  const content = fs6.readFileSync(resolved, "utf-8");
+  return JSON.parse(content);
+}
+function parseList(val) {
+  if (!val)
+    return;
+  return val.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function validateKinds(kinds) {
+  const invalid = kinds.filter((k) => !VALID_KINDS.includes(k));
+  if (invalid.length > 0) {
+    throw new Error(`Invalid kind(s): ${invalid.join(", ")}. Valid kinds: ${VALID_KINDS.join(", ")}`);
+  }
+  return kinds;
+}
+function createFilterCommand() {
+  return new Command6("filter").description("Filter an OpenPkg spec by various criteria").argument("<spec>", "Path to spec file (JSON)").option("--kind <kinds>", "Filter by kinds (comma-separated)").option("--name <names>", "Filter by exact names (comma-separated)").option("--id <ids>", "Filter by IDs (comma-separated)").option("--tag <tags>", "Filter by tags (comma-separated)").option("--deprecated", "Only deprecated exports").option("--no-deprecated", "Exclude deprecated exports").option("--has-description", "Only exports with descriptions").option("--missing-description", "Only exports without descriptions").option("--search <term>", "Search name/description (case-insensitive)").option("--module <path>", "Filter by source file path (contains)").option("-o, --output <file>", "Output file (default: stdout)").option("--summary", "Only output matched/total counts").option("--quiet", "Output raw spec only (no wrapper)").action(async (specPath, options) => {
+    try {
+      const spec = loadSpec5(specPath);
+      const criteria = {};
+      if (options.kind) {
+        const kinds = parseList(options.kind);
+        if (kinds)
+          criteria.kinds = validateKinds(kinds);
+      }
+      if (options.name)
+        criteria.names = parseList(options.name);
+      if (options.id)
+        criteria.ids = parseList(options.id);
+      if (options.tag)
+        criteria.tags = parseList(options.tag);
+      if (options.deprecated !== undefined)
+        criteria.deprecated = options.deprecated;
+      if (options.hasDescription)
+        criteria.hasDescription = true;
+      if (options.missingDescription)
+        criteria.hasDescription = false;
+      if (options.search)
+        criteria.search = options.search;
+      if (options.module)
+        criteria.module = options.module;
+      const result = filterSpec(spec, criteria);
+      let output;
+      if (options.summary) {
+        output = { matched: result.matched, total: result.total };
+      } else if (options.quiet) {
+        output = result.spec;
+      } else {
+        output = { spec: result.spec, matched: result.matched, total: result.total };
+      }
+      const json = JSON.stringify(output, null, 2);
+      if (options.output) {
+        fs6.writeFileSync(path6.resolve(options.output), json);
+      } else {
+        console.log(json);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(JSON.stringify({ error: error.message }, null, 2));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/semver.ts
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
+import { diffSpec as diffSpec3, recommendSemverBump as recommendSemverBump2 } from "@openpkg-ts/spec";
+import { Command as Command7 } from "commander";
+function loadSpec6(filePath) {
+  const resolved = path7.resolve(filePath);
+  const content = fs7.readFileSync(resolved, "utf-8");
+  return JSON.parse(content);
+}
+function createSemverCommand() {
+  return new Command7("semver").description("Recommend semver bump based on spec changes").argument("<old>", "Path to old spec file (JSON)").argument("<new>", "Path to new spec file (JSON)").action(async (oldPath, newPath) => {
+    try {
+      const oldSpec = loadSpec6(oldPath);
+      const newSpec = loadSpec6(newPath);
+      const diff = diffSpec3(oldSpec, newSpec);
+      const recommendation = recommendSemverBump2(diff);
+      const result = {
+        bump: recommendation.bump,
+        reason: recommendation.reason
+      };
+      console.log(JSON.stringify(result, null, 2));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(JSON.stringify({ error: error.message }, null, 2));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/snapshot.ts
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
+import { extractSpec } from "@openpkg-ts/sdk";
+import { Command as Command8 } from "commander";
+function parseFilter(value) {
+  if (!value)
+    return;
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function formatDiagnostics(diagnostics) {
+  return diagnostics.map((d) => ({
+    message: d.message,
+    severity: d.severity,
+    ...d.code && { code: d.code },
+    ...d.suggestion && { suggestion: d.suggestion },
+    ...d.location && { location: d.location }
+  }));
+}
+function createSnapshotCommand() {
+  return new Command8("snapshot").description("Generate full OpenPkg spec from TypeScript entry point").argument("<entry>", "Entry point file path").option("-o, --output <file>", "Output file (default: openpkg.json, use - for stdout)", "openpkg.json").option("--max-depth <n>", "Max type depth (default: 4)", "4").option("--skip-resolve", "Skip external type resolution").option("--runtime", "Enable Standard Schema runtime extraction").option("--only <exports>", "Filter exports (comma-separated, wildcards supported)").option("--ignore <exports>", "Ignore exports (comma-separated, wildcards supported)").option("--verify", "Exit 1 if any exports fail").action(async (entry, options) => {
+    const entryFile = path8.resolve(entry);
+    const extractOptions = {
+      entryFile,
+      maxTypeDepth: parseInt(options.maxDepth ?? "4", 10),
+      resolveExternalTypes: !options.skipResolve,
+      schemaExtraction: options.runtime ? "hybrid" : "static",
+      only: parseFilter(options.only),
+      ignore: parseFilter(options.ignore)
+    };
+    try {
+      const result = await extractSpec(extractOptions);
+      const summary = {
+        exports: result.spec.exports.length,
+        types: result.spec.types?.length ?? 0,
+        diagnostics: result.diagnostics.length,
+        ...result.verification && {
+          verification: {
+            discovered: result.verification.discovered,
+            extracted: result.verification.extracted,
+            skipped: result.verification.skipped,
+            failed: result.verification.failed
+          }
+        },
+        ...result.runtimeSchemas && {
+          runtime: {
+            extracted: result.runtimeSchemas.extracted,
+            merged: result.runtimeSchemas.merged,
+            vendors: result.runtimeSchemas.vendors
+          }
+        }
+      };
+      console.error(JSON.stringify(summary, null, 2));
+      if (options.verify && result.verification && result.verification.failed > 0) {
+        const errorOutput = {
+          error: "Export verification failed",
+          failed: result.verification.details.failed,
+          diagnostics: formatDiagnostics(result.diagnostics)
+        };
+        console.error(JSON.stringify(errorOutput, null, 2));
+        process.exit(1);
+      }
+      const specJson = JSON.stringify(result.spec, null, 2);
+      if (options.output === "-") {
+        console.log(specJson);
+      } else {
+        const outputPath = path8.resolve(options.output ?? "openpkg.json");
+        fs8.writeFileSync(outputPath, specJson);
+        console.error(`Wrote ${outputPath}`);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const errorOutput = {
+        error: error.message,
+        ...error.stack && { stack: error.stack }
+      };
+      console.error(JSON.stringify(errorOutput, null, 2));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/validate.ts
+import * as fs9 from "node:fs";
+import * as path9 from "node:path";
+import { getValidationErrors } from "@openpkg-ts/spec";
+import { Command as Command9 } from "commander";
+function loadJSON2(filePath) {
+  const resolved = path9.resolve(filePath);
+  const content = fs9.readFileSync(resolved, "utf-8");
+  return JSON.parse(content);
+}
+function createValidateCommand() {
+  return new Command9("validate").description("Validate an OpenPkg spec against the schema").argument("<spec>", "Path to spec file (JSON)").option("--version <version>", "Schema version to validate against (default: latest)").action(async (specPath, options) => {
+    try {
+      const spec = loadJSON2(specPath);
+      const version = options.version ?? "latest";
+      const errors = getValidationErrors(spec, version);
+      const result = {
+        valid: errors.length === 0,
+        errors
+      };
+      console.log(JSON.stringify(result, null, 2));
+      if (errors.length > 0) {
+        process.exit(1);
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error(JSON.stringify({ error: error.message }, null, 2));
+      process.exit(1);
+    }
+  });
+}
+
+// bin/openpkg.ts
+var program = new Command10;
+program.name("openpkg").description("OpenPkg CLI - TypeScript API extraction primitives").version(package_default.version);
+program.command("list").description("List exports from a TypeScript entry point").argument("<entry>", "Entry point file path").action(async (entry) => {
+  const entryFile = path10.resolve(entry);
+  const result = await listExports({ entryFile });
+  if (result.errors.length > 0) {
+    console.error(JSON.stringify({ errors: result.errors }, null, 2));
+    process.exit(1);
+  }
+  console.log(JSON.stringify(result.exports, null, 2));
+});
+program.command("get").description("Get detailed spec for a single export").argument("<entry>", "Entry point file path").argument("<name>", "Export name").action(async (entry, name) => {
+  const entryFile = path10.resolve(entry);
+  const result = await getExport({ entryFile, exportName: name });
+  if (!result.export) {
+    const errorMsg = result.errors.length > 0 ? result.errors.join("; ") : `Export '${name}' not found`;
+    console.error(JSON.stringify({ error: errorMsg }, null, 2));
+    process.exit(1);
+  }
+  const output = { export: result.export };
+  if (result.types.length > 0) {
+    output.types = result.types;
+  }
+  console.log(JSON.stringify(output, null, 2));
+});
+program.addCommand(createSnapshotCommand());
+program.addCommand(createDiffCommand());
+program.addCommand(createDocsCommand());
+program.addCommand(createBreakingCommand());
+program.addCommand(createChangelogCommand());
+program.addCommand(createSemverCommand());
+program.addCommand(createValidateCommand());
+program.addCommand(createDiagnosticsCommand());
+program.addCommand(createFilterCommand());
+program.parse();