@openpkg-ts/cli 0.6.3 → 0.7.0

package/dist/bin/openpkg.js

@@ -1,990 +0,0 @@
-#!/usr/bin/env bun
-import {
-  __require
-} from "../shared/chunk-3s189drz.js";
-
-// bin/openpkg.ts
-import { Command as Command12 } from "commander";
-// package.json
-var package_default = {
-  name: "@openpkg-ts/cli",
-  version: "0.6.3",
-  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.14",
-    "@openpkg-ts/sdk": "^0.35.1",
-    commander: "^14.0.0"
-  },
-  devDependencies: {
-    "@types/bun": "latest",
-    "@types/node": "^20.0.0",
-    bunup: "^0.16.20"
-  },
-  publishConfig: {
-    access: "public"
-  }
-};
-
-// src/commands/breaking.ts
-import { categorizeBreakingChanges, diffSpec } from "@openpkg-ts/spec";
-import { Command } from "commander";
-
-// src/commands/utils.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getValidationErrors } from "@openpkg-ts/spec";
-function handleCommandError(err) {
-  const error = err instanceof Error ? err : new Error(String(err));
-  console.error(JSON.stringify({ error: error.message }, null, 2));
-  process.exit(1);
-}
-async function loadSpecInput(specPath) {
-  if (specPath === "-") {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    const input = Buffer.concat(chunks).toString("utf-8");
-    try {
-      return JSON.parse(input);
-    } catch (err) {
-      const msg = err instanceof SyntaxError ? err.message : String(err);
-      throw new Error(`Invalid JSON in stdin: ${msg}`);
-    }
-  }
-  const resolved = path.resolve(specPath);
-  if (!fs.existsSync(resolved)) {
-    throw new Error(`Spec file not found: ${resolved}`);
-  }
-  try {
-    return JSON.parse(fs.readFileSync(resolved, "utf-8"));
-  } catch (err) {
-    const msg = err instanceof SyntaxError ? err.message : String(err);
-    throw new Error(`Invalid JSON in ${specPath}: ${msg}`);
-  }
-}
-function loadSpec(filePath) {
-  const resolved = path.resolve(filePath);
-  let content;
-  let spec;
-  try {
-    content = fs.readFileSync(resolved, "utf-8");
-  } catch (err) {
-    throw new Error(`Failed to read spec file: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  try {
-    spec = JSON.parse(content);
-  } catch (err) {
-    throw new Error(`Invalid JSON in spec file: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const errors = getValidationErrors(spec);
-  if (errors.length > 0) {
-    const details = errors.slice(0, 5).map((e) => `${e.instancePath || "/"}: ${e.message}`).join("; ");
-    throw new Error(`Invalid OpenPkg spec: ${details}`);
-  }
-  return spec;
-}
-
-// src/commands/breaking.ts
-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) {
-      handleCommandError(err);
-    }
-  });
-}
-
-// src/commands/changelog.ts
-import { Command as Command3 } from "commander";
-
-// src/commands/diff.ts
-import {
-  categorizeBreakingChanges as categorizeBreakingChanges2,
-  diffSpec as diffSpec2,
-  recommendSemverBump
-} from "@openpkg-ts/spec";
-import { Command as Command2 } from "commander";
-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 = loadSpec(oldPath);
-      const newSpec = loadSpec(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) {
-      handleCommandError(err);
-    }
-  });
-}
-
-// src/commands/changelog.ts
-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 = loadSpec(oldPath);
-      const newSpec = loadSpec(newPath);
-      const diff = enrichDiff(oldSpec, newSpec);
-      if (options.format === "json") {
-        console.log(JSON.stringify(diff, null, 2));
-      } else {
-        console.log(formatMarkdown(diff));
-      }
-    } catch (err) {
-      handleCommandError(err);
-    }
-  });
-}
-
-// src/commands/docs/index.ts
-import { Command as Command9 } from "commander";
-
-// src/commands/docs/add.ts
-import { spawn } from "node:child_process";
-import { Command as Command4 } from "commander";
-
-// src/commands/docs/utils.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-function detectPackageManager(cwd = process.cwd()) {
-  const pkgJsonPath = path2.join(cwd, "package.json");
-  if (fs2.existsSync(pkgJsonPath)) {
-    try {
-      const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
-      if (pkg.packageManager) {
-        if (pkg.packageManager.startsWith("bun"))
-          return "bun";
-        if (pkg.packageManager.startsWith("pnpm"))
-          return "pnpm";
-        if (pkg.packageManager.startsWith("yarn"))
-          return "yarn";
-        if (pkg.packageManager.startsWith("npm"))
-          return "npm";
-      }
-    } catch {}
-  }
-  if (fs2.existsSync(path2.join(cwd, "bun.lockb")) || fs2.existsSync(path2.join(cwd, "bun.lock"))) {
-    return "bun";
-  }
-  if (fs2.existsSync(path2.join(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (fs2.existsSync(path2.join(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  return "npm";
-}
-function getDlxCommand(pkg, pm) {
-  const packageManager = pm || detectPackageManager();
-  switch (packageManager) {
-    case "bun":
-      return { cmd: "bunx", args: [pkg] };
-    case "pnpm":
-      return { cmd: "pnpm", args: ["dlx", pkg] };
-    case "yarn":
-      return { cmd: "yarn", args: ["dlx", pkg] };
-    default:
-      return { cmd: "npx", args: [pkg] };
-  }
-}
-function getShadcnCommand(subcommand, args = []) {
-  const dlx = getDlxCommand("shadcn@latest");
-  return {
-    cmd: dlx.cmd,
-    args: [...dlx.args, subcommand, ...args]
-  };
-}
-
-// src/commands/docs/add.ts
-function createAddCommand() {
-  return new Command4("add").description("Install @openpkg components (wrapper for shadcn add)").argument("<components...>", "Components to install").option("-o, --overwrite", "Overwrite existing files").option("-c, --cwd <path>", "Working directory").option("-y, --yes", "Skip confirmation prompt").option("-s, --silent", "Mute output").action(async (components, options) => {
-    const prefixedComponents = components.map((c) => c.startsWith("@") ? c : `@openpkg/${c}`);
-    const extraArgs = [];
-    if (options.overwrite)
-      extraArgs.push("--overwrite");
-    if (options.cwd)
-      extraArgs.push("--cwd", options.cwd);
-    if (options.yes)
-      extraArgs.push("--yes");
-    if (options.silent)
-      extraArgs.push("--silent");
-    const { cmd, args } = getShadcnCommand("add", [...prefixedComponents, ...extraArgs]);
-    if (!options.silent) {
-      console.log(`Running: ${cmd} ${args.join(" ")}`);
-      console.log("");
-    }
-    const child = spawn(cmd, args, {
-      stdio: "inherit",
-      shell: true
-    });
-    child.on("close", (code) => {
-      process.exit(code || 0);
-    });
-  });
-}
-
-// src/commands/docs/generate.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
-import { loadSpec as loadSpec2, query, toReact } from "@openpkg-ts/sdk";
-import { Command as Command5 } from "commander";
-function getExtension(format) {
-  switch (format) {
-    case "json":
-      return ".json";
-    case "html":
-      return ".html";
-    case "react":
-      return ".tsx";
-    default:
-      return ".md";
-  }
-}
-var VALID_KINDS = [
-  "function",
-  "class",
-  "variable",
-  "interface",
-  "type",
-  "enum",
-  "module",
-  "namespace",
-  "reference",
-  "external"
-];
-function applyFilters(spec, options) {
-  let qb = query(spec);
-  if (options.kind) {
-    const kinds = options.kind.split(",").map((k) => k.trim()).filter(Boolean);
-    const invalid = kinds.filter((k) => !VALID_KINDS.includes(k));
-    if (invalid.length) {
-      throw new Error(`Invalid kind(s): ${invalid.join(", ")}. Valid: ${VALID_KINDS.join(", ")}`);
-    }
-    qb = qb.byKind(...kinds);
-  }
-  if (options.tag) {
-    const tags = options.tag.split(",").map((t) => t.trim()).filter(Boolean);
-    if (tags.length === 0) {
-      throw new Error("--tag requires at least one non-empty tag");
-    }
-    qb = qb.byTag(...tags);
-  }
-  if (options.search) {
-    qb = qb.search(options.search);
-  }
-  if (options.deprecated === true) {
-    qb = qb.deprecated(true);
-  } else if (options.deprecated === false) {
-    qb = qb.deprecated(false);
-  }
-  return qb.toSpec();
-}
-function renderExport(docs, exportId, format, collapseUnionThreshold) {
-  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,
-        collapseUnionThreshold
-      });
-  }
-}
-function renderFull(docs, format, collapseUnionThreshold) {
-  switch (format) {
-    case "json":
-      return JSON.stringify(docs.toJSON(), null, 2);
-    case "html":
-      return docs.toHTML();
-    default:
-      return docs.toMarkdown({ frontmatter: true, codeSignatures: true, collapseUnionThreshold });
-  }
-}
-function createGenerateCommand() {
-  return new Command5("generate").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, react (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)").option("--collapse-unions <n>", "Collapse unions with more than N members").option("-k, --kind <kinds>", "Filter by kind(s), comma-separated").option("-t, --tag <tags>", "Filter by tag(s), comma-separated").option("-s, --search <term>", "Search name and description").option("--deprecated", "Only include deprecated exports").option("--no-deprecated", "Exclude deprecated exports").option("--variant <variant>", "React layout variant: full (single page) or index (links)", "full").option("--components-path <path>", "React components import path", "@/components/api").action(async (specPath, options) => {
-    const format = options.format || "md";
-    try {
-      if (options.collapseUnions) {
-        const n = parseInt(options.collapseUnions, 10);
-        if (Number.isNaN(n) || n < 1) {
-          console.error(JSON.stringify({ error: "--collapse-unions must be a positive integer" }));
-          process.exit(1);
-        }
-      }
-      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 spec2 = await loadSpecInput(specPath);
-        spec2 = applyFilters(spec2, options);
-        await adapter.generate(spec2, path3.resolve(options.output));
-        console.error(`Generated docs with ${options.adapter} adapter to ${options.output}`);
-        return;
-      }
-      let spec = await loadSpecInput(specPath);
-      spec = applyFilters(spec, options);
-      const docs = loadSpec2(spec);
-      const collapseUnionThreshold = options.collapseUnions ? parseInt(options.collapseUnions, 10) : undefined;
-      if (format === "react") {
-        if (!options.output) {
-          console.error(JSON.stringify({ error: "--format react requires --output <directory>" }));
-          process.exit(1);
-        }
-        const variant = options.variant === "index" ? "index" : "full";
-        await toReact(spec, {
-          outDir: path3.resolve(options.output),
-          variant,
-          componentsPath: options.componentsPath ?? "@/components/api"
-        });
-        console.error(`Generated React layout to ${options.output}`);
-        console.error(`  - page.tsx: Layout file`);
-        console.error(`  - openpkg.json: Spec data`);
-        console.error(`
-Next: Add components with 'openpkg docs add function-section'`);
-        return;
-      }
-      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, collapseUnionThreshold);
-        if (options.output && options.output !== "-") {
-          const outputPath = path3.resolve(options.output);
-          fs3.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 = path3.resolve(options.output);
-        if (!fs3.existsSync(outDir)) {
-          fs3.mkdirSync(outDir, { recursive: true });
-        }
-        const exports = docs.getAllExports();
-        for (const exp of exports) {
-          const filename = path3.basename(`${exp.name}${getExtension(format)}`);
-          const filePath = path3.join(outDir, filename);
-          const resolvedPath = path3.resolve(filePath);
-          const resolvedOutDir = path3.resolve(outDir);
-          if (!resolvedPath.startsWith(resolvedOutDir + path3.sep)) {
-            console.error(JSON.stringify({ error: `Path traversal detected: ${exp.name}` }));
-            process.exit(1);
-          }
-          const content = renderExport(docs, exp.id, format, collapseUnionThreshold);
-          fs3.writeFileSync(filePath, content);
-        }
-        console.error(`Wrote ${exports.length} files to ${outDir}`);
-        return;
-      }
-      const output = renderFull(docs, format, collapseUnionThreshold);
-      if (options.output && options.output !== "-") {
-        const outputPath = path3.resolve(options.output);
-        fs3.writeFileSync(outputPath, output);
-        console.error(`Wrote ${outputPath}`);
-      } else {
-        console.log(output);
-      }
-    } catch (err) {
-      handleCommandError(err);
-    }
-  });
-}
-
-// src/commands/docs/init.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
-import { Command as Command6 } from "commander";
-var COMPONENTS_JSON = "components.json";
-var REGISTRY_URL = "https://raw.githubusercontent.com/anthropics/openpkg-ts/main/registry/r/{name}.json";
-function loadComponentsJson() {
-  const configPath = path4.resolve(COMPONENTS_JSON);
-  if (!fs4.existsSync(configPath))
-    return null;
-  try {
-    return JSON.parse(fs4.readFileSync(configPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function createInitCommand() {
-  return new Command6("init").description("Add @openpkg registry to components.json for shadcn CLI").option("--registry <url>", "Custom registry URL", REGISTRY_URL).action(async (options) => {
-    const configPath = path4.resolve(COMPONENTS_JSON);
-    const registryUrl = options.registry || REGISTRY_URL;
-    if (!fs4.existsSync(configPath)) {
-      console.error(`${COMPONENTS_JSON} not found.`);
-      console.error('Run "npx shadcn@latest init" first to initialize shadcn.');
-      process.exit(1);
-    }
-    const config = loadComponentsJson();
-    if (!config) {
-      console.error(`Failed to parse ${COMPONENTS_JSON}`);
-      process.exit(1);
-    }
-    config.registries = config.registries || {};
-    config.registries["@openpkg"] = registryUrl;
-    fs4.writeFileSync(configPath, JSON.stringify(config, null, 2));
-    console.log(`Added @openpkg registry to ${COMPONENTS_JSON}`);
-    console.log("");
-    console.log("Usage:");
-    console.log("  npx shadcn@latest add @openpkg/function-section");
-    console.log("  npx shadcn@latest add @openpkg/export-card");
-    console.log("");
-    console.log("List components:");
-    console.log("  openpkg docs list");
-  });
-}
-
-// src/commands/docs/list.ts
-import { spawn as spawn2 } from "node:child_process";
-import { Command as Command7 } from "commander";
-function createListCommand() {
-  return new Command7("list").description("List @openpkg components (wrapper for shadcn list)").option("-q, --query <query>", "Search query").option("-l, --limit <number>", "Max items to display").option("-c, --cwd <cwd>", "Working directory").action(async (options) => {
-    const extraArgs = ["@openpkg"];
-    if (options.query)
-      extraArgs.push("-q", options.query);
-    if (options.limit)
-      extraArgs.push("-l", options.limit);
-    if (options.cwd)
-      extraArgs.push("-c", options.cwd);
-    const { cmd, args } = getShadcnCommand("list", extraArgs);
-    const child = spawn2(cmd, args, {
-      stdio: "inherit",
-      shell: true
-    });
-    child.on("close", (code) => {
-      process.exit(code || 0);
-    });
-  });
-}
-
-// src/commands/docs/view.ts
-import { spawn as spawn3 } from "node:child_process";
-import { Command as Command8 } from "commander";
-function createViewCommand() {
-  return new Command8("view").description("View @openpkg component before installing (wrapper for shadcn view)").argument("<components...>", "Components to view").option("-c, --cwd <cwd>", "Working directory").action(async (components, options) => {
-    const prefixedComponents = components.map((c) => c.startsWith("@") ? c : `@openpkg/${c}`);
-    const extraArgs = [...prefixedComponents];
-    if (options.cwd)
-      extraArgs.push("-c", options.cwd);
-    const { cmd, args } = getShadcnCommand("view", extraArgs);
-    const child = spawn3(cmd, args, {
-      stdio: "inherit",
-      shell: true
-    });
-    child.on("close", (code) => {
-      process.exit(code || 0);
-    });
-  });
-}
-
-// src/commands/docs/index.ts
-function createDocsCommand() {
-  const docs = new Command9("docs").description("Documentation generation and component registry");
-  docs.addCommand(createGenerateCommand());
-  docs.addCommand(createInitCommand());
-  docs.addCommand(createListCommand());
-  docs.addCommand(createViewCommand());
-  docs.addCommand(createAddCommand());
-  return docs;
-}
-
-// src/commands/semver.ts
-import { diffSpec as diffSpec3, recommendSemverBump as recommendSemverBump2 } from "@openpkg-ts/spec";
-import { Command as Command10 } from "commander";
-function createSemverCommand() {
-  return new Command10("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 = loadSpec(oldPath);
-      const newSpec = loadSpec(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) {
-      handleCommandError(err);
-    }
-  });
-}
-
-// src/commands/spec.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
-import {
-  analyzeSpec,
-  extractSpec,
-  filterSpec,
-  getExport,
-  listExports,
-  loadConfig,
-  mergeConfig
-} from "@openpkg-ts/sdk";
-import { getValidationErrors as getValidationErrors2 } from "@openpkg-ts/spec";
-import { Command as Command11 } from "commander";
-var VALID_KINDS2 = [
-  "function",
-  "class",
-  "variable",
-  "interface",
-  "type",
-  "enum",
-  "module",
-  "namespace",
-  "reference",
-  "external"
-];
-function parseList(val) {
-  if (!val)
-    return;
-  return val.split(",").map((s) => s.trim()).filter(Boolean);
-}
-function validateKinds(kinds) {
-  const invalid = kinds.filter((k) => !VALID_KINDS2.includes(k));
-  if (invalid.length > 0) {
-    throw new Error(`Invalid kind(s): ${invalid.join(", ")}. Valid kinds: ${VALID_KINDS2.join(", ")}`);
-  }
-  return kinds;
-}
-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 createSnapshotSubcommand() {
-  return new Command11("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)", "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)").option("--ignore <exports>", "Ignore exports (comma-separated)").option("--verify", "Exit 1 if any exports fail").option("--verbose", "Show detailed output").option("--quiet", "Suppress extraction warnings").option("--strict", "Exit 1 if any extraction warnings").option("--include-private", "Include private/protected class members").option("--external-include <patterns...>", "Resolve re-exports from these packages").option("--external-exclude <patterns...>", "Never resolve from these packages").option("--external-depth <n>", "Max transitive depth for external resolution", "1").action(async (entry, options) => {
-    const entryFile = path5.resolve(entry);
-    const entryDir = path5.dirname(entryFile);
-    const fileConfig = loadConfig(entryDir);
-    const cliConfig = options.externalInclude ? {
-      externals: {
-        include: options.externalInclude,
-        exclude: options.externalExclude,
-        depth: parseInt(options.externalDepth ?? "1", 10)
-      }
-    } : {};
-    const mergedConfig = mergeConfig(fileConfig, cliConfig);
-    const extractOptions = {
-      entryFile,
-      maxTypeDepth: parseInt(options.maxDepth ?? "4", 10),
-      resolveExternalTypes: !options.skipResolve,
-      schemaExtraction: options.runtime ? "hybrid" : "static",
-      only: parseList(options.only),
-      ignore: parseList(options.ignore),
-      includePrivate: options.includePrivate,
-      ...mergedConfig.externals && { externals: mergedConfig.externals }
-    };
-    try {
-      const result = await extractSpec(extractOptions);
-      const externalExports = result.spec.exports.filter((e) => e.kind === "external");
-      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,
-            ...options.verbose && result.verification.details.skipped.length > 0 && {
-              skippedDetails: result.verification.details.skipped
-            }
-          }
-        },
-        ...externalExports.length > 0 && { external: { count: externalExports.length } }
-      };
-      console.error(JSON.stringify(summary, null, 2));
-      const extractionWarnings = result.runtimeSchemas?.warnings ?? [];
-      if (extractionWarnings.length > 0 && !options.quiet) {
-        console.error(`
-Skipped ${extractionWarnings.length} schema(s) with extraction errors:`);
-        for (const w of extractionWarnings) {
-          console.error(`  - ${w.exportName ?? "unknown"}: ${w.code} - ${w.message}`);
-        }
-      }
-      if (options.strict && extractionWarnings.length > 0) {
-        console.error(JSON.stringify({
-          error: "Extraction warnings present (--strict mode)",
-          warnings: extractionWarnings
-        }, null, 2));
-        process.exit(1);
-      }
-      if (options.verify && result.verification && result.verification.failed > 0) {
-        console.error(JSON.stringify({
-          error: "Export verification failed",
-          failed: result.verification.details.failed,
-          diagnostics: formatDiagnostics(result.diagnostics)
-        }, null, 2));
-        process.exit(1);
-      }
-      const specJson = JSON.stringify(result.spec, null, 2);
-      if (options.output === "-") {
-        console.log(specJson);
-      } else {
-        const outputPath = path5.resolve(options.output ?? "openpkg.json");
-        fs5.writeFileSync(outputPath, specJson);
-        console.error(`Wrote ${outputPath}`);
-      }
-    } catch (err) {
-      handleCommandError(err);
-    }
-  });
-}
-function createValidateSubcommand() {
-  return new Command11("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 = loadSpec(specPath);
-      const version = options.version ?? "latest";
-      const errors = getValidationErrors2(spec, version);
-      console.log(JSON.stringify({ valid: errors.length === 0, errors }, null, 2));
-      if (errors.length > 0)
-        process.exit(1);
-    } catch (err) {
-      handleCommandError(err);
-    }
-  });
-}
-function createFilterSubcommand() {
-  return new Command11("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").option("--search-members", "Also search member names/descriptions").option("--search-docs", "Also search param/return descriptions").option("--module <path>", "Filter by source file path").option("-o, --output <file>", "Output file (default: stdout)").option("--summary", "Only output matched/total counts").option("--quiet", "Output raw spec only").action(async (specPath, options) => {
-    try {
-      const spec = loadSpec(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.searchMembers)
-        criteria.searchMembers = true;
-      if (options.searchDocs)
-        criteria.searchDocs = true;
-      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) {
-        fs5.writeFileSync(path5.resolve(options.output), json);
-      } else {
-        console.log(json);
-      }
-    } catch (err) {
-      handleCommandError(err);
-    }
-  });
-}
-function createLintSubcommand() {
-  return new Command11("lint").description("Analyze spec for quality issues (missing docs, deprecated without reason)").argument("<spec>", "Path to spec file (JSON)").option("--verbose", "Show detailed information").action(async (specPath, options) => {
-    try {
-      const spec = loadSpec(specPath);
-      const diagnostics = analyzeSpec(spec);
-      const generation = spec.generation;
-      const skipped = generation?.skipped ?? [];
-      const externalExports = spec.exports.filter((e) => e.kind === "external");
-      const byReason = {};
-      for (const skip of skipped) {
-        byReason[skip.reason] = (byReason[skip.reason] ?? 0) + 1;
-      }
-      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,
-          ...skipped.length > 0 && { skippedExports: skipped.length },
-          ...externalExports.length > 0 && { externalExports: externalExports.length }
-        },
-        diagnostics,
-        ...skipped.length > 0 && {
-          skippedExports: {
-            total: skipped.length,
-            byReason,
-            ...options.verbose && { details: skipped }
-          }
-        },
-        ...externalExports.length > 0 && {
-          externalExports: {
-            count: externalExports.length,
-            ...options.verbose && {
-              details: externalExports.map((e) => ({ name: e.name, package: e.source?.package }))
-            }
-          }
-        }
-      };
-      console.log(JSON.stringify(result, null, 2));
-    } catch (err) {
-      handleCommandError(err);
-    }
-  });
-}
-function createListSubcommand() {
-  return new Command11("list").description("List exports from a TypeScript entry point").argument("<entry>", "Entry point file path").action(async (entry) => {
-    const entryFile = path5.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));
-  });
-}
-function createGetSubcommand() {
-  return new Command11("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 = path5.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));
-  });
-}
-function createSpecCommand() {
-  const spec = new Command11("spec").description("Spec extraction and manipulation commands");
-  spec.addCommand(createSnapshotSubcommand());
-  spec.addCommand(createValidateSubcommand());
-  spec.addCommand(createFilterSubcommand());
-  spec.addCommand(createLintSubcommand());
-  spec.addCommand(createListSubcommand());
-  spec.addCommand(createGetSubcommand());
-  return spec;
-}
-
-// bin/openpkg.ts
-var program = new Command12;
-program.name("openpkg").description("OpenPkg CLI - TypeScript API extraction primitives").version(package_default.version);
-program.addCommand(createSpecCommand());
-program.addCommand(createDocsCommand());
-program.addCommand(createDiffCommand());
-program.addCommand(createBreakingCommand());
-program.addCommand(createChangelogCommand());
-program.addCommand(createSemverCommand());
-var specCmd = program.commands.find((c) => c.name() === "spec");
-if (!specCmd) {
-  throw new Error("Internal error: spec command not found");
-}
-function getSubcommand(parent, name) {
-  const cmd = parent.commands.find((c) => c.name() === name);
-  if (!cmd) {
-    throw new Error(`Internal error: ${name} subcommand not found`);
-  }
-  return cmd;
-}
-function createAlias(aliasName, targetName, description) {
-  return new Command12(aliasName).description(description).allowUnknownOption().allowExcessArguments().action(async () => {
-    const args = process.argv.slice(3);
-    await getSubcommand(specCmd, targetName).parseAsync(args, { from: "user" });
-  });
-}
-program.addCommand(createAlias("snapshot", "snapshot", "(alias) → openpkg spec snapshot"));
-program.addCommand(createAlias("list", "list", "(alias) → openpkg spec list"));
-program.addCommand(createAlias("get", "get", "(alias) → openpkg spec get"));
-program.addCommand(createAlias("validate", "validate", "(alias) → openpkg spec validate"));
-program.addCommand(createAlias("filter", "filter", "(alias) → openpkg spec filter"));
-program.addCommand(createAlias("diagnostics", "lint", "(alias) → openpkg spec lint"));
-program.parse();