@openpkg-ts/cli 0.6.1 → 0.6.3

package/dist/bin/openpkg.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env bun
 import {
-  __require,
-  __toESM
-} from "../shared/chunk-1dqs11h6.js";
+  __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.1",
+  version: "0.6.3",
   description: "CLI for OpenPkg TypeScript API extraction and documentation generation",
   homepage: "https://github.com/ryanwaits/openpkg-ts#readme",
   repository: {
@@ -32,8 +31,8 @@ var package_default = {
     test: "bun test"
   },
   dependencies: {
-    "@openpkg-ts/adapters": "^0.3.4",
-    "@openpkg-ts/sdk": "^0.34.1",
+    "@openpkg-ts/adapters": "^0.3.14",
+    "@openpkg-ts/sdk": "^0.35.1",
     commander: "^14.0.0"
   },
   devDependencies: {
@@ -47,18 +46,66 @@ var package_default = {
 };
 
 // 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 {
-  categorizeBreakingChanges,
-  diffSpec
-} from "@openpkg-ts/spec";
-import { Command } from "commander";
+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);
-  const content = fs.readFileSync(resolved, "utf-8");
-  return JSON.parse(content);
+  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 {
@@ -75,32 +122,21 @@ function createBreakingCommand() {
         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);
+      handleCommandError(err);
     }
   });
 }
 
 // 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) {
@@ -178,8 +214,8 @@ function describeChange(cat) {
 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 oldSpec = loadSpec(oldPath);
+      const newSpec = loadSpec(newPath);
       const result = enrichDiff(oldSpec, newSpec);
       if (options.summary) {
         console.log(JSON.stringify(result.summary, null, 2));
@@ -187,19 +223,12 @@ function createDiffCommand() {
         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);
+      handleCommandError(err);
     }
   });
 }
 
 // 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) {
@@ -235,8 +264,8 @@ function formatMarkdown(diff) {
 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 oldSpec = loadSpec(oldPath);
+      const newSpec = loadSpec(newPath);
       const diff = enrichDiff(oldSpec, newSpec);
       if (options.format === "json") {
         console.log(JSON.stringify(diff, null, 2));
@@ -244,9 +273,7 @@ function createChangelogCommand() {
         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);
+      handleCommandError(err);
     }
   });
 }
@@ -259,13 +286,13 @@ import { spawn } from "node:child_process";
 import { Command as Command4 } from "commander";
 
 // src/commands/docs/utils.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 function detectPackageManager(cwd = process.cwd()) {
-  const pkgJsonPath = path4.join(cwd, "package.json");
-  if (fs4.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path2.join(cwd, "package.json");
+  if (fs2.existsSync(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
       if (pkg.packageManager) {
         if (pkg.packageManager.startsWith("bun"))
           return "bun";
@@ -278,13 +305,13 @@ function detectPackageManager(cwd = process.cwd()) {
       }
     } catch {}
   }
-  if (fs4.existsSync(path4.join(cwd, "bun.lockb")) || fs4.existsSync(path4.join(cwd, "bun.lock"))) {
+  if (fs2.existsSync(path2.join(cwd, "bun.lockb")) || fs2.existsSync(path2.join(cwd, "bun.lock"))) {
     return "bun";
   }
-  if (fs4.existsSync(path4.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs2.existsSync(path2.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs4.existsSync(path4.join(cwd, "yarn.lock"))) {
+  if (fs2.existsSync(path2.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
   return "npm";
@@ -339,21 +366,10 @@ function createAddCommand() {
 }
 
 // src/commands/docs/generate.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
-import { loadSpec as loadSpec4, query, toReact } from "@openpkg-ts/sdk";
+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";
-async function readStdin() {
-  try {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString("utf-8");
-  } catch (err) {
-    throw new Error(`stdin read failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
 function getExtension(format) {
   switch (format) {
     case "json":
@@ -366,14 +382,33 @@ function getExtension(format) {
       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());
+    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());
+    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) {
@@ -418,6 +453,13 @@ 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 {
@@ -437,37 +479,15 @@ function createGenerateCommand() {
           console.error(JSON.stringify({ error: "--adapter requires --output <directory>" }));
           process.exit(1);
         }
-        let spec2;
-        if (specPath === "-") {
-          const input = await readStdin();
-          spec2 = 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);
-          }
-          spec2 = JSON.parse(fs5.readFileSync(specFile, "utf-8"));
-        }
+        let spec2 = await loadSpecInput(specPath);
         spec2 = applyFilters(spec2, options);
-        await adapter.generate(spec2, path5.resolve(options.output));
+        await adapter.generate(spec2, path3.resolve(options.output));
         console.error(`Generated docs with ${options.adapter} adapter to ${options.output}`);
         return;
       }
-      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"));
-      }
+      let spec = await loadSpecInput(specPath);
       spec = applyFilters(spec, options);
-      const docs = loadSpec4(spec);
+      const docs = loadSpec2(spec);
       const collapseUnionThreshold = options.collapseUnions ? parseInt(options.collapseUnions, 10) : undefined;
       if (format === "react") {
         if (!options.output) {
@@ -476,7 +496,7 @@ function createGenerateCommand() {
         }
         const variant = options.variant === "index" ? "index" : "full";
         await toReact(spec, {
-          outDir: path5.resolve(options.output),
+          outDir: path3.resolve(options.output),
           variant,
           componentsPath: options.componentsPath ?? "@/components/api"
         });
@@ -496,8 +516,8 @@ Next: Add components with 'openpkg docs add function-section'`);
         }
         const output2 = renderExport(docs, exp.id, format, collapseUnionThreshold);
         if (options.output && options.output !== "-") {
-          const outputPath = path5.resolve(options.output);
-          fs5.writeFileSync(outputPath, output2);
+          const outputPath = path3.resolve(options.output);
+          fs3.writeFileSync(outputPath, output2);
           console.error(`Wrote ${outputPath}`);
         } else {
           console.log(output2);
@@ -509,59 +529,61 @@ Next: Add components with 'openpkg docs add function-section'`);
           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 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 = path5.basename(`${exp.name}${getExtension(format)}`);
-          const filePath = path5.join(outDir, filename);
-          const resolvedPath = path5.resolve(filePath);
-          const resolvedOutDir = path5.resolve(outDir);
-          if (!resolvedPath.startsWith(resolvedOutDir + path5.sep)) {
+          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);
-          fs5.writeFileSync(filePath, content);
+          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 = path5.resolve(options.output);
-        fs5.writeFileSync(outputPath, output);
+        const outputPath = path3.resolve(options.output);
+        fs3.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);
+      handleCommandError(err);
     }
   });
 }
 
 // src/commands/docs/init.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+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 = path6.resolve(COMPONENTS_JSON);
-  if (!fs6.existsSync(configPath))
+  const configPath = path4.resolve(COMPONENTS_JSON);
+  if (!fs4.existsSync(configPath))
+    return null;
+  try {
+    return JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+  } catch {
     return null;
-  return JSON.parse(fs6.readFileSync(configPath, "utf-8"));
+  }
 }
 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 = path6.resolve(COMPONENTS_JSON);
+    const configPath = path4.resolve(COMPONENTS_JSON);
     const registryUrl = options.registry || REGISTRY_URL;
-    if (!fs6.existsSync(configPath)) {
+    if (!fs4.existsSync(configPath)) {
       console.error(`${COMPONENTS_JSON} not found.`);
       console.error('Run "npx shadcn@latest init" first to initialize shadcn.');
       process.exit(1);
@@ -573,7 +595,7 @@ function createInitCommand() {
     }
     config.registries = config.registries || {};
     config.registries["@openpkg"] = registryUrl;
-    fs6.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    fs4.writeFileSync(configPath, JSON.stringify(config, null, 2));
     console.log(`Added @openpkg registry to ${COMPONENTS_JSON}`);
     console.log("");
     console.log("Usage:");
@@ -640,20 +662,13 @@ function createDocsCommand() {
 }
 
 // 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 Command10 } from "commander";
-function loadSpec5(filePath) {
-  const resolved = path7.resolve(filePath);
-  const content = fs7.readFileSync(resolved, "utf-8");
-  return JSON.parse(content);
-}
 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 = loadSpec5(oldPath);
-      const newSpec = loadSpec5(newPath);
+      const oldSpec = loadSpec(oldPath);
+      const newSpec = loadSpec(newPath);
       const diff = diffSpec3(oldSpec, newSpec);
       const recommendation = recommendSemverBump2(diff);
       const result = {
@@ -662,16 +677,14 @@ function createSemverCommand() {
       };
       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);
+      handleCommandError(err);
     }
   });
 }
 
 // src/commands/spec.ts
-import * as fs8 from "node:fs";
-import * as path8 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 import {
   analyzeSpec,
   extractSpec,
@@ -681,9 +694,9 @@ import {
   loadConfig,
   mergeConfig
 } from "@openpkg-ts/sdk";
-import { getValidationErrors } from "@openpkg-ts/spec";
+import { getValidationErrors as getValidationErrors2 } from "@openpkg-ts/spec";
 import { Command as Command11 } from "commander";
-var VALID_KINDS = [
+var VALID_KINDS2 = [
   "function",
   "class",
   "variable",
@@ -695,36 +708,15 @@ var VALID_KINDS = [
   "reference",
   "external"
 ];
-function loadSpec6(filePath) {
-  const resolved = path8.resolve(filePath);
-  let content;
-  let spec;
-  try {
-    content = fs8.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;
-}
 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));
+  const invalid = kinds.filter((k) => !VALID_KINDS2.includes(k));
   if (invalid.length > 0) {
-    throw new Error(`Invalid kind(s): ${invalid.join(", ")}. Valid kinds: ${VALID_KINDS.join(", ")}`);
+    throw new Error(`Invalid kind(s): ${invalid.join(", ")}. Valid kinds: ${VALID_KINDS2.join(", ")}`);
   }
   return kinds;
 }
@@ -738,9 +730,9 @@ function formatDiagnostics(diagnostics) {
   }));
 }
 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("--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 = path8.resolve(entry);
-    const entryDir = path8.dirname(entryFile);
+  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: {
@@ -781,6 +773,21 @@ function createSnapshotSubcommand() {
         ...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",
@@ -793,37 +800,33 @@ function createSnapshotSubcommand() {
       if (options.output === "-") {
         console.log(specJson);
       } else {
-        const outputPath = path8.resolve(options.output ?? "openpkg.json");
-        fs8.writeFileSync(outputPath, specJson);
+        const outputPath = path5.resolve(options.output ?? "openpkg.json");
+        fs5.writeFileSync(outputPath, specJson);
         console.error(`Wrote ${outputPath}`);
       }
     } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      console.error(JSON.stringify({ error: error.message }, null, 2));
-      process.exit(1);
+      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 = loadSpec6(specPath);
+      const spec = loadSpec(specPath);
       const version = options.version ?? "latest";
-      const errors = getValidationErrors(spec, version);
+      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) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      console.error(JSON.stringify({ error: error.message }, null, 2));
-      process.exit(1);
+      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 = loadSpec6(specPath);
+      const spec = loadSpec(specPath);
       const criteria = {};
       if (options.kind) {
         const kinds = parseList(options.kind);
@@ -861,21 +864,19 @@ function createFilterSubcommand() {
       }
       const json = JSON.stringify(output, null, 2);
       if (options.output) {
-        fs8.writeFileSync(path8.resolve(options.output), json);
+        fs5.writeFileSync(path5.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);
+      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 = loadSpec6(specPath);
+      const spec = loadSpec(specPath);
       const diagnostics = analyzeSpec(spec);
       const generation = spec.generation;
       const skipped = generation?.skipped ?? [];
@@ -912,15 +913,13 @@ function createLintSubcommand() {
       };
       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);
+      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 = path8.resolve(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));
@@ -931,7 +930,7 @@ function createListSubcommand() {
 }
 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 = path8.resolve(entry);
+    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`;

package/dist/shared/chunk-3s189drz.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

package/dist/src/index.d.ts

@@ -1,3 +1,42 @@
 import { getExport, listExports } from "@openpkg-ts/sdk";
+import { CategorizedBreaking } from "@openpkg-ts/spec";
+type BreakingResult = {
+	breaking: CategorizedBreaking[];
+	count: number;
+};
+import { CategorizedBreaking as CategorizedBreaking2, SemverBump, SpecExportKind } from "@openpkg-ts/spec";
+/**
+* A changed with details about what changed
+*/
+interface ChangedExport {
+	id: string;
+	name: string;
+	kind: SpecExportKind;
+	description: string;
+}
+/**
+* Enriched diff result with categorized changes
+*/
+interface DiffResult {
+	breaking: CategorizedBreaking2[];
+	added: string[];
+	removed: RemovedExport[];
+	changed: ChangedExport[];
+	docsOnly: string[];
+	summary: {
+		breakingCount: number;
+		addedCount: number;
+		removedCount: number;
+		changedCount: number;
+		docsOnlyCount: number;
+		semverBump: SemverBump;
+		semverReason: string;
+	};
+}
+interface RemovedExport {
+	id: string;
+	name: string;
+	kind: SpecExportKind;
+}
 import { FilterResult, FilterSummaryResult } from "./commands/filter";
-export { listExports, getExport, FilterSummaryResult, FilterResult };
+export { listExports, getExport, RemovedExport, FilterSummaryResult, FilterResult, DiffResult, ChangedExport, BreakingResult };

package/dist/src/index.js

@@ -1,4 +1,4 @@
-import"../shared/chunk-1dqs11h6.js";
+import"../shared/chunk-3s189drz.js";
 
 // src/index.ts
 import { getExport, listExports } from "@openpkg-ts/sdk";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpkg-ts/cli",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "CLI for OpenPkg TypeScript API extraction and documentation generation",
   "homepage": "https://github.com/ryanwaits/openpkg-ts#readme",
   "repository": {
@@ -23,8 +23,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@openpkg-ts/adapters": "^0.3.4",
-    "@openpkg-ts/sdk": "^0.34.1",
+    "@openpkg-ts/adapters": "^0.3.14",
+    "@openpkg-ts/sdk": "^0.35.1",
     "commander": "^14.0.0"
   },
   "devDependencies": {

package/dist/shared/chunk-1dqs11h6.js

@@ -1,20 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-export { __toESM, __require };