@openpkg-ts/cli 0.6.2 → 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.2",
+  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.5",
-    "@openpkg-ts/sdk": "^0.35.0",
+    "@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":
@@ -463,57 +479,15 @@ function createGenerateCommand() {
           console.error(JSON.stringify({ error: "--adapter requires --output <directory>" }));
           process.exit(1);
         }
-        let spec2;
-        if (specPath === "-") {
-          const input = await readStdin();
-          try {
-            spec2 = JSON.parse(input);
-          } catch (err) {
-            const msg = err instanceof SyntaxError ? err.message : String(err);
-            throw new Error(`Invalid JSON in stdin: ${msg}`);
-          }
-        } else {
-          const specFile = path5.resolve(specPath);
-          if (!fs5.existsSync(specFile)) {
-            console.error(JSON.stringify({ error: `Spec file not found: ${specFile}` }));
-            process.exit(1);
-          }
-          try {
-            spec2 = JSON.parse(fs5.readFileSync(specFile, "utf-8"));
-          } catch (err) {
-            const msg = err instanceof SyntaxError ? err.message : String(err);
-            throw new Error(`Invalid JSON in ${specPath}: ${msg}`);
-          }
-        }
+        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();
-        try {
-          spec = JSON.parse(input);
-        } catch (err) {
-          const msg = err instanceof SyntaxError ? err.message : String(err);
-          throw new Error(`Invalid JSON in stdin: ${msg}`);
-        }
-      } else {
-        const specFile = path5.resolve(specPath);
-        if (!fs5.existsSync(specFile)) {
-          console.error(JSON.stringify({ error: `Spec file not found: ${specFile}` }));
-          process.exit(1);
-        }
-        try {
-          spec = JSON.parse(fs5.readFileSync(specFile, "utf-8"));
-        } catch (err) {
-          const msg = err instanceof SyntaxError ? err.message : String(err);
-          throw new Error(`Invalid JSON in ${specPath}: ${msg}`);
-        }
-      }
+      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) {
@@ -522,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"
         });
@@ -542,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);
@@ -555,63 +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(fs6.readFileSync(configPath, "utf-8"));
+    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 = 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);
@@ -623,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:");
@@ -690,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 = {
@@ -712,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,
@@ -731,7 +694,7 @@ 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_KINDS2 = [
   "function",
@@ -745,27 +708,6 @@ var VALID_KINDS2 = [
   "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;
@@ -789,8 +731,8 @@ 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("--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 = path8.resolve(entry);
-    const entryDir = path8.dirname(entryFile);
+    const entryFile = path5.resolve(entry);
+    const entryDir = path5.dirname(entryFile);
     const fileConfig = loadConfig(entryDir);
     const cliConfig = options.externalInclude ? {
       externals: {
@@ -858,37 +800,33 @@ Skipped ${extractionWarnings.length} schema(s) with extraction errors:`);
       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);
@@ -926,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 ?? [];
@@ -977,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));
@@ -996,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.2",
+  "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.5",
-    "@openpkg-ts/sdk": "^0.35.0",
+    "@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 };