@doccov/cli 0.17.0 → 0.19.0

package/dist/cli.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
 
 // src/config/doccov-config.ts
-import { access, readFile } from "node:fs/promises";
+import { access } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { parse as parseYaml } from "yaml";
 
 // src/config/schema.ts
 import { z } from "zod";
@@ -16,7 +15,6 @@ var docsConfigSchema = z.object({
   include: stringList.optional(),
   exclude: stringList.optional()
 });
-var severitySchema = z.enum(["error", "warn", "off"]);
 var exampleModeSchema = z.enum([
   "presence",
   "typecheck",
@@ -32,16 +30,12 @@ var checkConfigSchema = z.object({
   minCoverage: z.number().min(0).max(100).optional(),
   maxDrift: z.number().min(0).max(100).optional()
 });
-var qualityConfigSchema = z.object({
-  rules: z.record(severitySchema).optional()
-});
 var docCovConfigSchema = z.object({
   include: stringList.optional(),
   exclude: stringList.optional(),
   plugins: z.array(z.unknown()).optional(),
   docs: docsConfigSchema.optional(),
-  check: checkConfigSchema.optional(),
-  quality: qualityConfigSchema.optional()
+  check: checkConfigSchema.optional()
 });
 var normalizeList = (value) => {
   if (!value) {
@@ -73,19 +67,12 @@ var normalizeConfig = (input) => {
       maxDrift: input.check.maxDrift
     };
   }
-  let quality;
-  if (input.quality) {
-    quality = {
-      rules: input.quality.rules
-    };
-  }
   return {
     include,
     exclude,
     plugins: input.plugins,
     docs,
-    check,
-    quality
+    check
   };
 };
 
@@ -93,12 +80,8 @@ var normalizeConfig = (input) => {
 var DOCCOV_CONFIG_FILENAMES = [
   "doccov.config.ts",
   "doccov.config.mts",
-  "doccov.config.cts",
   "doccov.config.js",
-  "doccov.config.mjs",
-  "doccov.config.cjs",
-  "doccov.yml",
-  "doccov.yaml"
+  "doccov.config.mjs"
 ];
 var fileExists = async (filePath) => {
   try {
@@ -125,11 +108,6 @@ var findConfigFile = async (cwd) => {
   }
 };
 var importConfigModule = async (absolutePath) => {
-  const ext = path.extname(absolutePath);
-  if (ext === ".yml" || ext === ".yaml") {
-    const content = await readFile(absolutePath, "utf-8");
-    return parseYaml(content);
-  }
   const fileUrl = pathToFileURL(absolutePath);
   fileUrl.searchParams.set("t", Date.now().toString());
   const module = await import(fileUrl.href);
@@ -168,8 +146,8 @@ ${formatIssues(issues)}`);
 // src/config/index.ts
 var defineConfig = (config) => config;
 // src/cli.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import * as path8 from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import * as path9 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -189,6 +167,7 @@ import {
   NodeFileSystem,
   parseExamplesFlag,
   parseJSDocToPatch,
+  parseMarkdownFiles,
   resolveTarget,
   serializeJSDoc,
   validateExamples
@@ -196,8 +175,76 @@ import {
 import {
   DRIFT_CATEGORIES as DRIFT_CATEGORIES2
 } from "@openpkg-ts/spec";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
+import { glob } from "glob";
 
+// src/reports/changelog-renderer.ts
+function renderChangelog(data, options = {}) {
+  const { diff, categorizedBreaking } = data;
+  const lines = [];
+  const version = options.version ?? data.version ?? "Unreleased";
+  const date = options.date instanceof Date ? options.date.toISOString().split("T")[0] : options.date ?? new Date().toISOString().split("T")[0];
+  lines.push(`## [${version}] - ${date}`);
+  lines.push("");
+  if (diff.breaking.length > 0) {
+    lines.push("### ⚠️ BREAKING CHANGES");
+    lines.push("");
+    if (categorizedBreaking && categorizedBreaking.length > 0) {
+      for (const breaking of categorizedBreaking) {
+        const severity = breaking.severity === "high" ? "**" : "";
+        lines.push(`- ${severity}${breaking.name}${severity}: ${breaking.reason}`);
+      }
+    } else {
+      for (const id of diff.breaking) {
+        lines.push(`- \`${id}\` removed or changed`);
+      }
+    }
+    lines.push("");
+  }
+  if (diff.nonBreaking.length > 0) {
+    lines.push("### Added");
+    lines.push("");
+    for (const id of diff.nonBreaking) {
+      lines.push(`- \`${id}\``);
+    }
+    lines.push("");
+  }
+  if (diff.docsOnly.length > 0) {
+    lines.push("### Documentation");
+    lines.push("");
+    for (const id of diff.docsOnly) {
+      lines.push(`- Updated documentation for \`${id}\``);
+    }
+    lines.push("");
+  }
+  if (diff.coverageDelta !== 0) {
+    lines.push("### Coverage");
+    lines.push("");
+    const arrow = diff.coverageDelta > 0 ? "↑" : "↓";
+    const sign = diff.coverageDelta > 0 ? "+" : "";
+    lines.push(`- Documentation coverage: ${diff.oldCoverage}% → ${diff.newCoverage}% (${arrow} ${sign}${diff.coverageDelta}%)`);
+    lines.push("");
+  }
+  if (diff.driftIntroduced > 0 || diff.driftResolved > 0) {
+    if (!lines.some((l) => l.startsWith("### Coverage"))) {
+      lines.push("### Coverage");
+      lines.push("");
+    }
+    if (diff.driftResolved > 0) {
+      lines.push(`- Fixed ${diff.driftResolved} drift issue${diff.driftResolved === 1 ? "" : "s"}`);
+    }
+    if (diff.driftIntroduced > 0) {
+      lines.push(`- ${diff.driftIntroduced} new drift issue${diff.driftIntroduced === 1 ? "" : "s"} detected`);
+    }
+    lines.push("");
+  }
+  if (options.compareUrl) {
+    lines.push(`**Full Changelog**: ${options.compareUrl}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
 // src/reports/diff-markdown.ts
 import * as path2 from "node:path";
 function bar(pct, width = 10) {
@@ -570,7 +617,8 @@ function renderPRComment(data, opts = {}) {
   const { diff, headSpec } = data;
   const limit = opts.limit ?? 10;
   const lines = [];
-  const hasIssues = diff.newUndocumented.length > 0 || diff.driftIntroduced > 0 || diff.breaking.length > 0 || opts.minCoverage !== undefined && diff.newCoverage < opts.minCoverage;
+  const hasStaleRefs = (opts.staleDocsRefs?.length ?? 0) > 0;
+  const hasIssues = diff.newUndocumented.length > 0 || diff.driftIntroduced > 0 || diff.breaking.length > 0 || hasStaleRefs || opts.minCoverage !== undefined && diff.newCoverage < opts.minCoverage;
   const statusIcon = hasIssues ? diff.coverageDelta < 0 ? "❌" : "⚠️" : "✅";
   lines.push(`## ${statusIcon} DocCov — Documentation Coverage`);
   lines.push("");
@@ -582,6 +630,13 @@ function renderPRComment(data, opts = {}) {
   if (diff.driftIntroduced > 0) {
     lines.push(`**Doc drift issues:** ${diff.driftIntroduced}`);
   }
+  if (opts.staleDocsRefs && opts.staleDocsRefs.length > 0) {
+    lines.push(`**Stale doc references:** ${opts.staleDocsRefs.length}`);
+  }
+  if (opts.semverBump) {
+    const emoji = opts.semverBump.bump === "major" ? "\uD83D\uDD34" : opts.semverBump.bump === "minor" ? "\uD83D\uDFE1" : "\uD83D\uDFE2";
+    lines.push(`**Semver:** ${emoji} ${opts.semverBump.bump.toUpperCase()} (${opts.semverBump.reason})`);
+  }
   if (diff.newUndocumented.length > 0) {
     lines.push("");
     lines.push("### Undocumented exports in this PR");
@@ -594,7 +649,15 @@ function renderPRComment(data, opts = {}) {
     lines.push("");
     renderDriftIssues(lines, diff.newUndocumented, headSpec, opts, limit);
   }
-  const fixGuidance = renderFixGuidance(diff);
+  if (opts.staleDocsRefs && opts.staleDocsRefs.length > 0) {
+    lines.push("");
+    lines.push("### \uD83D\uDCDD Stale documentation references");
+    lines.push("");
+    lines.push("These markdown files reference exports that no longer exist:");
+    lines.push("");
+    renderStaleDocsRefs(lines, opts.staleDocsRefs, opts, limit);
+  }
+  const fixGuidance = renderFixGuidance(diff, opts);
   if (fixGuidance) {
     lines.push("");
     lines.push("### How to fix");
@@ -608,6 +671,16 @@ function renderPRComment(data, opts = {}) {
   renderDetailsTable(lines, diff);
   lines.push("");
   lines.push("</details>");
+  if (opts.includeBadge !== false && opts.repoUrl) {
+    const repoMatch = opts.repoUrl.match(/github\.com\/([^/]+)\/([^/]+)/);
+    if (repoMatch) {
+      const [, owner, repo] = repoMatch;
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+      lines.push(`[![DocCov](https://doccov.dev/badge/${owner}/${repo})](https://doccov.dev/${owner}/${repo})`);
+    }
+  }
   return lines.join(`
 `);
 }
@@ -728,15 +801,47 @@ function getMissingSignals(exp) {
   }
   return missing;
 }
-function renderFixGuidance(diff) {
+function renderStaleDocsRefs(lines, refs, opts, limit) {
+  const byFile = new Map;
+  for (const ref of refs) {
+    const list = byFile.get(ref.file) ?? [];
+    list.push({ line: ref.line, exportName: ref.exportName });
+    byFile.set(ref.file, list);
+  }
+  let count = 0;
+  for (const [file, fileRefs] of byFile) {
+    if (count >= limit)
+      break;
+    const fileLink = buildFileLink(file, opts);
+    lines.push(`\uD83D\uDCC1 ${fileLink}`);
+    for (const ref of fileRefs) {
+      if (count >= limit)
+        break;
+      lines.push(`- Line ${ref.line}: \`${ref.exportName}\` does not exist`);
+      count++;
+    }
+    lines.push("");
+  }
+  if (refs.length > count) {
+    lines.push(`_...and ${refs.length - count} more stale references_`);
+  }
+}
+function renderFixGuidance(diff, opts) {
   const sections = [];
   if (diff.newUndocumented.length > 0) {
     sections.push(`**For undocumented exports:**
 ` + "Add JSDoc/TSDoc blocks with description, `@param`, and `@returns` tags.");
   }
   if (diff.driftIntroduced > 0) {
+    const fixableNote = opts.fixableDriftCount && opts.fixableDriftCount > 0 ? `
+
+**Quick fix:** Run \`npx doccov check --fix\` to auto-fix ${opts.fixableDriftCount} issue(s).` : "";
     sections.push(`**For doc drift:**
-` + "Update the code examples in your markdown files to match current signatures.");
+` + "Update JSDoc to match current code signatures." + fixableNote);
+  }
+  if (opts.staleDocsRefs && opts.staleDocsRefs.length > 0) {
+    sections.push(`**For stale docs:**
+` + "Update or remove code examples that reference deleted exports.");
   }
   if (diff.breaking.length > 0) {
     sections.push(`**For breaking changes:**
@@ -899,76 +1004,59 @@ function writeReports(options) {
   }));
   return results;
 }
-// src/utils/llm-assertion-parser.ts
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createOpenAI } from "@ai-sdk/openai";
-import { generateObject } from "ai";
-import { z as z2 } from "zod";
-var AssertionParseSchema = z2.object({
-  assertions: z2.array(z2.object({
-    lineNumber: z2.number().describe("1-indexed line number where the assertion appears"),
-    expected: z2.string().describe("The expected output value"),
-    originalComment: z2.string().describe("The original comment text"),
-    suggestedSyntax: z2.string().describe("The line rewritten with standard // => value syntax")
-  })).describe("List of assertion-like comments found in the code"),
-  hasAssertions: z2.boolean().describe("Whether any assertion-like comments were found")
-});
-var ASSERTION_PARSE_PROMPT = (code) => `Analyze this TypeScript/JavaScript example code for assertion-like comments.
-
-Look for comments that appear to specify expected output values, such as:
-- "// should be 3"
-- "// returns 5"
-- "// outputs: hello"
-- "// expected: [1, 2, 3]"
-- "// 42" (bare value after console.log)
-- "// result: true"
-
-Do NOT include:
-- Regular code comments that explain what the code does
-- Comments that are instructions or documentation
-- Comments with // => (already using standard syntax)
-
-For each assertion found, extract:
-1. The line number (1-indexed)
-2. The expected value (just the value, not the comment prefix)
-3. The original comment text
-4. A suggested rewrite of the ENTIRE line using "// => value" syntax
-
-Code:
-\`\`\`
-${code}
-\`\`\``;
-function getModel() {
-  const provider = process.env.DOCCOV_LLM_PROVIDER?.toLowerCase();
-  if (provider === "anthropic" || process.env.ANTHROPIC_API_KEY) {
-    const anthropic = createAnthropic();
-    return anthropic("claude-sonnet-4-20250514");
-  }
-  const openai = createOpenAI();
-  return openai("gpt-4o-mini");
-}
-function isLLMAssertionParsingAvailable() {
-  return Boolean(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY);
-}
-async function parseAssertionsWithLLM(code) {
-  if (!isLLMAssertionParsingAvailable()) {
-    return null;
+// src/utils/filter-options.ts
+import { mergeFilters, parseListFlag } from "@doccov/sdk";
+import chalk2 from "chalk";
+var parseVisibilityFlag = (value) => {
+  if (!value)
+    return;
+  const validTags = ["public", "beta", "alpha", "internal"];
+  const parsed = parseListFlag(value);
+  if (!parsed)
+    return;
+  const result = [];
+  for (const tag of parsed) {
+    const lower = tag.toLowerCase();
+    if (validTags.includes(lower)) {
+      result.push(lower);
+    }
   }
-  try {
-    const model = getModel();
-    const { object } = await generateObject({
-      model,
-      schema: AssertionParseSchema,
-      prompt: ASSERTION_PARSE_PROMPT(code)
-    });
-    return object;
-  } catch {
-    return null;
+  return result.length > 0 ? result : undefined;
+};
+var formatList = (label, values) => `${label}: ${values.map((value) => chalk2.cyan(value)).join(", ")}`;
+var mergeFilterOptions = (config, cliOptions) => {
+  const messages = [];
+  if (config?.include) {
+    messages.push(formatList("include filters from config", config.include));
   }
-}
+  if (config?.exclude) {
+    messages.push(formatList("exclude filters from config", config.exclude));
+  }
+  if (cliOptions.include) {
+    messages.push(formatList("apply include filters from CLI", cliOptions.include));
+  }
+  if (cliOptions.exclude) {
+    messages.push(formatList("apply exclude filters from CLI", cliOptions.exclude));
+  }
+  if (cliOptions.visibility) {
+    messages.push(formatList("apply visibility filter from CLI", cliOptions.visibility));
+  }
+  const resolved = mergeFilters(config, cliOptions);
+  if (!resolved.include && !resolved.exclude && !cliOptions.visibility) {
+    return { messages };
+  }
+  const source = resolved.source === "override" ? "cli" : resolved.source;
+  return {
+    include: resolved.include,
+    exclude: resolved.exclude,
+    visibility: cliOptions.visibility,
+    source,
+    messages
+  };
+};
 
 // src/utils/progress.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 class StepProgress {
   steps;
   currentStep = 0;
@@ -996,7 +1084,7 @@ class StepProgress {
     this.completeCurrentStep();
     if (message) {
       const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
-      console.log(`${chalk2.green("✓")} ${message} ${chalk2.dim(`(${elapsed}s)`)}`);
+      console.log(`${chalk3.green("✓")} ${message} ${chalk3.dim(`(${elapsed}s)`)}`);
     }
   }
   render() {
@@ -1004,17 +1092,17 @@ class StepProgress {
     if (!step)
       return;
     const label = step.activeLabel ?? step.label;
-    const prefix = chalk2.dim(`[${this.currentStep + 1}/${this.steps.length}]`);
-    process.stdout.write(`\r${prefix} ${chalk2.cyan(label)}...`);
+    const prefix = chalk3.dim(`[${this.currentStep + 1}/${this.steps.length}]`);
+    process.stdout.write(`\r${prefix} ${chalk3.cyan(label)}...`);
   }
   completeCurrentStep() {
     const step = this.steps[this.currentStep];
     if (!step)
       return;
     const elapsed = ((Date.now() - this.stepStartTime) / 1000).toFixed(1);
-    const prefix = chalk2.dim(`[${this.currentStep + 1}/${this.steps.length}]`);
+    const prefix = chalk3.dim(`[${this.currentStep + 1}/${this.steps.length}]`);
     process.stdout.write(`\r${" ".repeat(80)}\r`);
-    console.log(`${prefix} ${step.label} ${chalk2.green("✓")} ${chalk2.dim(`(${elapsed}s)`)}`);
+    console.log(`${prefix} ${step.label} ${chalk3.green("✓")} ${chalk3.dim(`(${elapsed}s)`)}`);
   }
 }
 
@@ -1058,10 +1146,10 @@ function registerCheckCommand(program, dependencies = {}) {
     ...defaultDependencies,
     ...dependencies
   };
-  program.command("check [entry]").description("Check documentation coverage and output reports").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--min-coverage <percentage>", "Minimum docs coverage percentage (0-100)", (value) => Number(value)).option("--max-drift <percentage>", "Maximum drift percentage allowed (0-100)", (value) => Number(value)).option("--examples [mode]", "Example validation: presence, typecheck, run (comma-separated). Bare flag runs all.").option("--skip-resolve", "Skip external type resolution from node_modules").option("--fix", "Auto-fix drift issues").option("--write", "Alias for --fix").option("--dry-run", "Preview fixes without writing (requires --fix)").option("--format <format>", "Output format: text, json, markdown, html, github", "text").option("-o, --output <file>", "Custom output path (overrides default .doccov/ path)").option("--stdout", "Output to stdout instead of writing to .doccov/").option("--update-snapshot", "Force regenerate .doccov/report.json").option("--limit <n>", "Max exports to show in report tables", "20").option("--max-type-depth <number>", "Maximum depth for type conversion (default: 20)").option("--no-cache", "Bypass spec cache and force regeneration").action(async (entry, options) => {
+  program.command("check [entry]").description("Check documentation coverage and output reports").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--min-coverage <percentage>", "Minimum docs coverage percentage (0-100)", (value) => Number(value)).option("--max-drift <percentage>", "Maximum drift percentage allowed (0-100)", (value) => Number(value)).option("--examples [mode]", "Example validation: presence, typecheck, run (comma-separated). Bare flag runs all.").option("--skip-resolve", "Skip external type resolution from node_modules").option("--docs <glob>", "Glob pattern for markdown docs to check for stale refs", collect, []).option("--fix", "Auto-fix drift issues").option("--write", "Alias for --fix").option("--preview", "Preview fixes with diff output (implies --fix)").option("--dry-run", "Alias for --preview").option("--format <format>", "Output format: text, json, markdown, html, github", "text").option("-o, --output <file>", "Custom output path (overrides default .doccov/ path)").option("--stdout", "Output to stdout instead of writing to .doccov/").option("--update-snapshot", "Force regenerate .doccov/report.json").option("--limit <n>", "Max exports to show in report tables", "20").option("--max-type-depth <number>", "Maximum depth for type conversion (default: 20)").option("--no-cache", "Bypass spec cache and force regeneration").option("--visibility <tags>", "Filter by release stage: public,beta,alpha,internal (comma-separated)").action(async (entry, options) => {
     try {
-      const validations = parseExamplesFlag(options.examples);
-      const hasExamples = validations.length > 0;
+      let validations = parseExamplesFlag(options.examples);
+      let hasExamples = validations.length > 0;
       const stepList = [
         { label: "Resolved target", activeLabel: "Resolving target" },
         { label: "Loaded config", activeLabel: "Loading config" },
@@ -1081,10 +1169,29 @@ function registerCheckCommand(program, dependencies = {}) {
       const { targetDir, entryFile } = resolved;
       steps.next();
       const config = await loadDocCovConfig(targetDir);
-      const minCoverageRaw = options.minCoverage ?? config?.check?.minCoverage;
-      const minCoverage = minCoverageRaw !== undefined ? clampPercentage(minCoverageRaw) : undefined;
+      if (!hasExamples && config?.check?.examples) {
+        const configExamples = config.check.examples;
+        if (Array.isArray(configExamples)) {
+          validations = configExamples;
+        } else if (typeof configExamples === "string") {
+          validations = parseExamplesFlag(configExamples);
+        }
+        hasExamples = validations.length > 0;
+      }
+      const DEFAULT_MIN_COVERAGE = 80;
+      const minCoverageRaw = options.minCoverage ?? config?.check?.minCoverage ?? DEFAULT_MIN_COVERAGE;
+      const minCoverage = clampPercentage(minCoverageRaw);
       const maxDriftRaw = options.maxDrift ?? config?.check?.maxDrift;
       const maxDrift = maxDriftRaw !== undefined ? clampPercentage(maxDriftRaw) : undefined;
+      const cliFilters = {
+        include: undefined,
+        exclude: undefined,
+        visibility: parseVisibilityFlag(options.visibility)
+      };
+      const resolvedFilters = mergeFilterOptions(config, cliFilters);
+      if (resolvedFilters.visibility) {
+        log(chalk4.dim(`Filtering by visibility: ${resolvedFilters.visibility.join(", ")}`));
+      }
       steps.next();
       const resolveExternalTypes = !options.skipResolve;
       let specResult;
@@ -1094,7 +1201,8 @@ function registerCheckCommand(program, dependencies = {}) {
         useCache: options.cache !== false,
         cwd: options.cwd
       });
-      specResult = await doccov.analyzeFileWithDiagnostics(entryFile);
+      const analyzeOptions = resolvedFilters.visibility ? { filters: { visibility: resolvedFilters.visibility } } : {};
+      specResult = await doccov.analyzeFileWithDiagnostics(entryFile, analyzeOptions);
       if (!specResult) {
         throw new Error("Failed to analyze documentation coverage.");
       }
@@ -1104,13 +1212,8 @@ function registerCheckCommand(program, dependencies = {}) {
       steps.next();
       const specWarnings = specResult.diagnostics.filter((d) => d.severity === "warning");
       const specInfos = specResult.diagnostics.filter((d) => d.severity === "info");
-      const shouldFix = options.fix || options.write;
-      const violations = [];
-      for (const exp of spec.exports ?? []) {
-        for (const v of exp.docs?.violations ?? []) {
-          violations.push({ exportName: exp.name, violation: v });
-        }
-      }
+      const isPreview = options.preview || options.dryRun;
+      const shouldFix = options.fix || options.write || isPreview;
       let exampleResult;
       const typecheckErrors = [];
       const runtimeDrifts = [];
@@ -1120,11 +1223,7 @@ function registerCheckCommand(program, dependencies = {}) {
           packagePath: targetDir,
           exportNames: (spec.exports ?? []).map((e) => e.name),
           timeout: 5000,
-          installTimeout: 60000,
-          llmAssertionParser: isLLMAssertionParsingAvailable() ? async (example) => {
-            const result = await parseAssertionsWithLLM(example);
-            return result;
-          } : undefined
+          installTimeout: 60000
         });
         if (exampleResult.typecheck) {
           for (const err of exampleResult.typecheck.errors) {
@@ -1147,6 +1246,41 @@ function registerCheckCommand(program, dependencies = {}) {
         }
         steps.next();
       }
+      const staleRefs = [];
+      let docsPatterns = options.docs;
+      if (docsPatterns.length === 0 && config?.docs?.include) {
+        docsPatterns = config.docs.include;
+      }
+      if (docsPatterns.length > 0) {
+        const markdownFiles = await loadMarkdownFiles(docsPatterns, targetDir);
+        if (markdownFiles.length > 0) {
+          const exportNames = (spec.exports ?? []).map((e) => e.name);
+          const exportSet = new Set(exportNames);
+          for (const mdFile of markdownFiles) {
+            for (const block of mdFile.codeBlocks) {
+              const codeLines = block.code.split(`
+`);
+              for (let i = 0;i < codeLines.length; i++) {
+                const line = codeLines[i];
+                const importMatch = line.match(/import\s*\{([^}]+)\}\s*from\s*['"][^'"]*['"]/);
+                if (importMatch) {
+                  const imports = importMatch[1].split(",").map((s) => s.trim().split(/\s+/)[0]);
+                  for (const imp of imports) {
+                    if (imp && !exportSet.has(imp)) {
+                      staleRefs.push({
+                        file: mdFile.path,
+                        line: block.lineStart + i,
+                        exportName: imp,
+                        context: line.trim()
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       const coverageScore = spec.docs?.coverageScore ?? 0;
       const allDriftExports = [...collectDrift(spec.exports ?? []), ...runtimeDrifts];
       let driftExports = hasExamples ? allDriftExports : allDriftExports.filter((d) => d.category !== "example");
@@ -1156,12 +1290,12 @@ function registerCheckCommand(program, dependencies = {}) {
         if (allDrifts.length > 0) {
           const { fixable, nonFixable } = categorizeDrifts(allDrifts.map((d) => d.drift));
           if (fixable.length === 0) {
-            log(chalk3.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
+            log(chalk4.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
           } else {
             log("");
-            log(chalk3.bold(`Found ${fixable.length} fixable issue(s)`));
+            log(chalk4.bold(`Found ${fixable.length} fixable issue(s)`));
             if (nonFixable.length > 0) {
-              log(chalk3.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
+              log(chalk4.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
             }
             log("");
             const groupedDrifts = groupByExport(allDrifts.filter((d) => fixable.includes(d.drift)));
@@ -1169,22 +1303,22 @@ function registerCheckCommand(program, dependencies = {}) {
             const editsByFile = new Map;
             for (const [exp, drifts] of groupedDrifts) {
               if (!exp.source?.file) {
-                log(chalk3.gray(`  Skipping ${exp.name}: no source location`));
+                log(chalk4.gray(`  Skipping ${exp.name}: no source location`));
                 continue;
               }
               if (exp.source.file.endsWith(".d.ts")) {
-                log(chalk3.gray(`  Skipping ${exp.name}: declaration file`));
+                log(chalk4.gray(`  Skipping ${exp.name}: declaration file`));
                 continue;
               }
               const filePath = path4.resolve(targetDir, exp.source.file);
               if (!fs2.existsSync(filePath)) {
-                log(chalk3.gray(`  Skipping ${exp.name}: file not found`));
+                log(chalk4.gray(`  Skipping ${exp.name}: file not found`));
                 continue;
               }
               const sourceFile = createSourceFile(filePath);
               const location = findJSDocLocation(sourceFile, exp.name, exp.source.line);
               if (!location) {
-                log(chalk3.gray(`  Skipping ${exp.name}: could not find declaration`));
+                log(chalk4.gray(`  Skipping ${exp.name}: could not find declaration`));
                 continue;
               }
               let existingPatch = {};
@@ -1216,34 +1350,61 @@ function registerCheckCommand(program, dependencies = {}) {
               editsByFile.set(filePath, fileEdits);
             }
             if (edits.length > 0) {
-              if (options.dryRun) {
-                log(chalk3.bold("Dry run - changes that would be made:"));
+              if (isPreview) {
+                log(chalk4.bold("Preview - changes that would be made:"));
                 log("");
                 for (const [filePath, fileEdits] of editsByFile) {
                   const relativePath = path4.relative(targetDir, filePath);
-                  log(chalk3.cyan(`  ${relativePath}:`));
                   for (const { export: exp, edit, fixes } of fileEdits) {
-                    const lineInfo = edit.hasExisting ? `lines ${edit.startLine + 1}-${edit.endLine + 1}` : `line ${edit.startLine + 1}`;
-                    log(`    ${chalk3.bold(exp.name)} [${lineInfo}]`);
-                    for (const fix of fixes) {
-                      log(chalk3.green(`      + ${fix.description}`));
+                    log(chalk4.cyan(`${relativePath}:${edit.startLine + 1}`));
+                    log(chalk4.bold(`  ${exp.name}`));
+                    log("");
+                    if (edit.hasExisting && edit.existingJSDoc) {
+                      const oldLines = edit.existingJSDoc.split(`
+`);
+                      const newLines = edit.newJSDoc.split(`
+`);
+                      for (const line of oldLines) {
+                        log(chalk4.red(`  - ${line}`));
+                      }
+                      for (const line of newLines) {
+                        log(chalk4.green(`  + ${line}`));
+                      }
+                    } else {
+                      const newLines = edit.newJSDoc.split(`
+`);
+                      for (const line of newLines) {
+                        log(chalk4.green(`  + ${line}`));
+                      }
                     }
+                    log("");
+                    log(chalk4.dim(`  Fixes: ${fixes.map((f) => f.description).join(", ")}`));
+                    log("");
                   }
-                  log("");
                 }
-                log(chalk3.gray("Run without --dry-run to apply these changes."));
+                const totalFixes = Array.from(editsByFile.values()).reduce((sum, edits2) => sum + edits2.reduce((s, e) => s + e.fixes.length, 0), 0);
+                log(chalk4.yellow(`${totalFixes} fix(es) across ${editsByFile.size} file(s) would be applied.`));
+                log(chalk4.gray("Run with --fix to apply these changes."));
               } else {
                 const applyResult = await applyEdits(edits);
                 if (applyResult.errors.length > 0) {
                   for (const err of applyResult.errors) {
-                    error(chalk3.red(`  ${err.file}: ${err.error}`));
+                    error(chalk4.red(`  ${err.file}: ${err.error}`));
                   }
                 }
+                const totalFixes = Array.from(editsByFile.values()).reduce((sum, edits2) => sum + edits2.reduce((s, e) => s + e.fixes.length, 0), 0);
+                log("");
+                log(chalk4.green(`✓ Applied ${totalFixes} fix(es) to ${applyResult.filesModified} file(s)`));
+                for (const [filePath, fileEdits] of editsByFile) {
+                  const relativePath = path4.relative(targetDir, filePath);
+                  const fixCount = fileEdits.reduce((s, e) => s + e.fixes.length, 0);
+                  log(chalk4.dim(`  ${relativePath} (${fixCount} fixes)`));
+                }
               }
             }
           }
         }
-        if (!options.dryRun) {
+        if (!isPreview) {
           driftExports = driftExports.filter((d) => !fixedDriftKeys.has(`${d.name}:${d.issue}`));
         }
       }
@@ -1267,8 +1428,7 @@ function registerCheckCommand(program, dependencies = {}) {
           case "github":
             formatContent = renderGithubSummary(stats, {
               coverageScore,
-              driftCount: driftExports.length,
-              qualityIssues: violations.length
+              driftCount: driftExports.length
             });
             break;
           default:
@@ -1288,11 +1448,10 @@ function registerCheckCommand(program, dependencies = {}) {
         const totalExportsForDrift2 = spec.exports?.length ?? 0;
         const exportsWithDrift2 = new Set(driftExports.map((d) => d.name)).size;
         const driftScore2 = totalExportsForDrift2 === 0 ? 0 : Math.round(exportsWithDrift2 / totalExportsForDrift2 * 100);
-        const coverageFailed2 = minCoverage !== undefined && coverageScore < minCoverage;
+        const coverageFailed2 = coverageScore < minCoverage;
         const driftFailed2 = maxDrift !== undefined && driftScore2 > maxDrift;
-        const hasQualityErrors2 = violations.filter((v) => v.violation.severity === "error").length > 0;
         const hasTypecheckErrors2 = typecheckErrors.length > 0;
-        if (coverageFailed2 || driftFailed2 || hasQualityErrors2 || hasTypecheckErrors2) {
+        if (coverageFailed2 || driftFailed2 || hasTypecheckErrors2) {
           process.exit(1);
         }
         return;
@@ -1300,48 +1459,41 @@ function registerCheckCommand(program, dependencies = {}) {
       const totalExportsForDrift = spec.exports?.length ?? 0;
       const exportsWithDrift = new Set(driftExports.map((d) => d.name)).size;
       const driftScore = totalExportsForDrift === 0 ? 0 : Math.round(exportsWithDrift / totalExportsForDrift * 100);
-      const coverageFailed = minCoverage !== undefined && coverageScore < minCoverage;
+      const coverageFailed = coverageScore < minCoverage;
       const driftFailed = maxDrift !== undefined && driftScore > maxDrift;
-      const hasQualityErrors = violations.filter((v) => v.violation.severity === "error").length > 0;
       const hasTypecheckErrors = typecheckErrors.length > 0;
       if (specWarnings.length > 0 || specInfos.length > 0) {
         log("");
         for (const diag of specWarnings) {
-          log(chalk3.yellow(`⚠ ${diag.message}`));
+          log(chalk4.yellow(`⚠ ${diag.message}`));
           if (diag.suggestion) {
-            log(chalk3.gray(`  ${diag.suggestion}`));
+            log(chalk4.gray(`  ${diag.suggestion}`));
           }
         }
         for (const diag of specInfos) {
-          log(chalk3.cyan(`ℹ ${diag.message}`));
+          log(chalk4.cyan(`ℹ ${diag.message}`));
           if (diag.suggestion) {
-            log(chalk3.gray(`  ${diag.suggestion}`));
+            log(chalk4.gray(`  ${diag.suggestion}`));
           }
         }
       }
       const pkgName = spec.meta?.name ?? "unknown";
       const pkgVersion = spec.meta?.version ?? "";
       const totalExports = spec.exports?.length ?? 0;
-      const errorCount = violations.filter((v) => v.violation.severity === "error").length;
-      const warnCount = violations.filter((v) => v.violation.severity === "warn").length;
       log("");
-      log(chalk3.bold(`${pkgName}${pkgVersion ? `@${pkgVersion}` : ""}`));
+      log(chalk4.bold(`${pkgName}${pkgVersion ? `@${pkgVersion}` : ""}`));
       log("");
       log(`  Exports:    ${totalExports}`);
-      if (minCoverage !== undefined) {
-        if (coverageFailed) {
-          log(chalk3.red(`  Coverage:   ✗ ${coverageScore}%`) + chalk3.dim(` (min ${minCoverage}%)`));
-        } else {
-          log(chalk3.green(`  Coverage:   ✓ ${coverageScore}%`) + chalk3.dim(` (min ${minCoverage}%)`));
-        }
+      if (coverageFailed) {
+        log(chalk4.red(`  Coverage:   ✗ ${coverageScore}%`) + chalk4.dim(` (min ${minCoverage}%)`));
       } else {
-        log(`  Coverage:   ${coverageScore}%`);
+        log(chalk4.green(`  Coverage:   ✓ ${coverageScore}%`) + chalk4.dim(` (min ${minCoverage}%)`));
       }
       if (maxDrift !== undefined) {
         if (driftFailed) {
-          log(chalk3.red(`  Drift:      ✗ ${driftScore}%`) + chalk3.dim(` (max ${maxDrift}%)`));
+          log(chalk4.red(`  Drift:      ✗ ${driftScore}%`) + chalk4.dim(` (max ${maxDrift}%)`));
         } else {
-          log(chalk3.green(`  Drift:      ✓ ${driftScore}%`) + chalk3.dim(` (max ${maxDrift}%)`));
+          log(chalk4.green(`  Drift:      ✓ ${driftScore}%`) + chalk4.dim(` (max ${maxDrift}%)`));
         }
       } else {
         log(`  Drift:      ${driftScore}%`);
@@ -1349,48 +1501,51 @@ function registerCheckCommand(program, dependencies = {}) {
       if (exampleResult) {
         const typecheckCount = exampleResult.typecheck?.errors.length ?? 0;
         if (typecheckCount > 0) {
-          log(`  Examples:   ${typecheckCount} type errors`);
+          log(chalk4.yellow(`  Examples:   ${typecheckCount} type error(s)`));
+          for (const err of typecheckErrors.slice(0, 5)) {
+            const loc = `example[${err.error.exampleIndex}]:${err.error.line}:${err.error.column}`;
+            log(chalk4.dim(`              ${err.exportName} ${loc}`));
+            log(chalk4.red(`                ${err.error.message}`));
+          }
+          if (typecheckErrors.length > 5) {
+            log(chalk4.dim(`              ... and ${typecheckErrors.length - 5} more`));
+          }
         } else {
-          log(chalk3.green(`  Examples:   ✓ validated`));
+          log(chalk4.green(`  Examples:   ✓ validated`));
         }
       }
-      if (errorCount > 0 || warnCount > 0) {
-        const parts = [];
-        if (errorCount > 0)
-          parts.push(`${errorCount} errors`);
-        if (warnCount > 0)
-          parts.push(`${warnCount} warnings`);
-        log(`  Quality:    ${parts.join(", ")}`);
+      const hasStaleRefs = staleRefs.length > 0;
+      if (hasStaleRefs) {
+        log(chalk4.yellow(`  Docs:       ${staleRefs.length} stale ref(s)`));
+        for (const ref of staleRefs.slice(0, 5)) {
+          log(chalk4.dim(`              ${ref.file}:${ref.line} - "${ref.exportName}"`));
+        }
+        if (staleRefs.length > 5) {
+          log(chalk4.dim(`              ... and ${staleRefs.length - 5} more`));
+        }
       }
       log("");
-      const failed = coverageFailed || driftFailed || hasQualityErrors || hasTypecheckErrors;
+      const failed = coverageFailed || driftFailed || hasTypecheckErrors || hasStaleRefs;
       if (!failed) {
         const thresholdParts = [];
-        if (minCoverage !== undefined) {
-          thresholdParts.push(`coverage ${coverageScore}% ≥ ${minCoverage}%`);
-        }
+        thresholdParts.push(`coverage ${coverageScore}% ≥ ${minCoverage}%`);
         if (maxDrift !== undefined) {
           thresholdParts.push(`drift ${driftScore}% ≤ ${maxDrift}%`);
         }
-        if (thresholdParts.length > 0) {
-          log(chalk3.green(`✓ Check passed (${thresholdParts.join(", ")})`));
-        } else {
-          log(chalk3.green("✓ Check passed"));
-          log(chalk3.dim("  No thresholds configured. Use --min-coverage or --max-drift to enforce."));
-        }
+        log(chalk4.green(`✓ Check passed (${thresholdParts.join(", ")})`));
         return;
       }
-      if (hasQualityErrors) {
-        log(chalk3.red(`✗ ${errorCount} quality errors`));
-      }
       if (hasTypecheckErrors) {
-        log(chalk3.red(`✗ ${typecheckErrors.length} example type errors`));
+        log(chalk4.red(`✗ ${typecheckErrors.length} example type errors`));
+      }
+      if (hasStaleRefs) {
+        log(chalk4.red(`✗ ${staleRefs.length} stale references in docs`));
       }
       log("");
-      log(chalk3.dim("Use --format json or --format markdown for detailed reports"));
+      log(chalk4.dim("Use --format json or --format markdown for detailed reports"));
       process.exit(1);
     } catch (commandError) {
-      error(chalk3.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk4.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
@@ -1414,6 +1569,23 @@ function collectDrift(exportsList) {
   }
   return drifts;
 }
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+async function loadMarkdownFiles(patterns, cwd) {
+  const files = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, { nodir: true, cwd });
+    for (const filePath of matches) {
+      try {
+        const fullPath = path4.resolve(cwd, filePath);
+        const content = fs2.readFileSync(fullPath, "utf-8");
+        files.push({ path: filePath, content });
+      } catch {}
+    }
+  }
+  return parseMarkdownFiles(files);
+}
 
 // src/commands/diff.ts
 import * as fs3 from "node:fs";
@@ -1425,72 +1597,11 @@ import {
   getDocsImpactSummary,
   hasDocsImpact,
   hashString,
-  parseMarkdownFiles
+  parseMarkdownFiles as parseMarkdownFiles2
 } from "@doccov/sdk";
-import chalk4 from "chalk";
-import { glob } from "glob";
-
-// src/utils/docs-impact-ai.ts
-import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
-import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
-import { generateObject as generateObject2, generateText } from "ai";
-import { z as z3 } from "zod";
-var CodeBlockUsageSchema = z3.object({
-  isImpacted: z3.boolean().describe("Whether the code block is affected by the change"),
-  reason: z3.string().describe("Explanation of why/why not the code is impacted"),
-  usageType: z3.enum(["direct-call", "import-only", "indirect", "not-used"]).describe("How the export is used in this code block"),
-  suggestedFix: z3.string().optional().describe("If impacted, the suggested code change"),
-  confidence: z3.enum(["high", "medium", "low"]).describe("Confidence level of the analysis")
-});
-var MultiBlockAnalysisSchema = z3.object({
-  groups: z3.array(z3.object({
-    blockIndices: z3.array(z3.number()).describe("Indices of blocks that should run together"),
-    reason: z3.string().describe("Why these blocks are related")
-  })).describe("Groups of related code blocks"),
-  skippedBlocks: z3.array(z3.number()).describe("Indices of blocks that should be skipped (incomplete/illustrative)")
-});
-function getModel2() {
-  const provider = process.env.DOCCOV_LLM_PROVIDER?.toLowerCase();
-  if (provider === "anthropic" || process.env.ANTHROPIC_API_KEY) {
-    const anthropic = createAnthropic2();
-    return anthropic("claude-sonnet-4-20250514");
-  }
-  const openai = createOpenAI2();
-  return openai("gpt-4o-mini");
-}
-function isAIDocsAnalysisAvailable() {
-  return Boolean(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY);
-}
-async function generateImpactSummary(impacts) {
-  if (!isAIDocsAnalysisAvailable()) {
-    return null;
-  }
-  if (impacts.length === 0) {
-    return "No documentation impacts detected.";
-  }
-  try {
-    const { text } = await generateText({
-      model: getModel2(),
-      prompt: `Summarize these documentation impacts for a GitHub PR comment.
-
-Impacts:
-${impacts.map((i) => `- ${i.file}: ${i.exportName} (${i.changeType})`).join(`
-`)}
-
-Write a brief, actionable summary (2-3 sentences) explaining:
-1. How many files/references are affected
-2. What type of updates are needed
-3. Priority recommendation
-
-Keep it concise and developer-friendly.`
-    });
-    return text.trim();
-  } catch {
-    return null;
-  }
-}
-
-// src/commands/diff.ts
+import { calculateNextVersion, recommendSemverBump } from "@openpkg-ts/spec";
+import chalk5 from "chalk";
+import { glob as glob2 } from "glob";
 var defaultDependencies2 = {
   readFileSync: fs3.readFileSync,
   log: console.log,
@@ -1511,11 +1622,11 @@ function getStrictChecks(preset) {
   return checks;
 }
 function registerDiffCommand(program, dependencies = {}) {
-  const { readFileSync: readFileSync2, log, error } = {
+  const { readFileSync: readFileSync3, log, error } = {
     ...defaultDependencies2,
     ...dependencies
   };
-  program.command("diff [base] [head]").description("Compare two OpenPkg specs and detect breaking changes").option("--base <file>", 'Base spec file (the "before" state)').option("--head <file>", 'Head spec file (the "after" state)').option("--format <format>", "Output format: text, json, markdown, html, github, pr-comment", "text").option("--stdout", "Output to stdout instead of writing to .doccov/").option("-o, --output <file>", "Custom output path").option("--cwd <dir>", "Working directory", process.cwd()).option("--limit <n>", "Max items to show in terminal/reports", "10").option("--repo-url <url>", "GitHub repo URL for file links (pr-comment format)").option("--sha <sha>", "Commit SHA for file links (pr-comment format)").option("--min-coverage <n>", "Minimum coverage % for HEAD spec (0-100)").option("--max-drift <n>", "Maximum drift % for HEAD spec (0-100)").option("--strict <preset>", "Fail on conditions: ci, release, quality").option("--docs <glob>", "Glob pattern for markdown docs to check for impact", collect, []).option("--ai", "Use AI for deeper analysis and fix suggestions").option("--no-cache", "Bypass cache and force regeneration").action(async (baseArg, headArg, options) => {
+  program.command("diff [base] [head]").description("Compare two OpenPkg specs and detect breaking changes").option("--base <file>", 'Base spec file (the "before" state)').option("--head <file>", 'Head spec file (the "after" state)').option("--format <format>", "Output format: text, json, markdown, html, github, pr-comment, changelog", "text").option("--stdout", "Output to stdout instead of writing to .doccov/").option("-o, --output <file>", "Custom output path").option("--cwd <dir>", "Working directory", process.cwd()).option("--limit <n>", "Max items to show in terminal/reports", "10").option("--repo-url <url>", "GitHub repo URL for file links (pr-comment format)").option("--sha <sha>", "Commit SHA for file links (pr-comment format)").option("--min-coverage <n>", "Minimum coverage % for HEAD spec (0-100)").option("--max-drift <n>", "Maximum drift % for HEAD spec (0-100)").option("--strict <preset>", "Fail on conditions: ci, release, quality").option("--docs <glob>", "Glob pattern for markdown docs to check for impact", collect2, []).option("--no-cache", "Bypass cache and force regeneration").option("--recommend-version", "Output recommended semver version bump").action(async (baseArg, headArg, options) => {
     try {
       const baseFile = options.base ?? baseArg;
       const headFile = options.head ?? headArg;
@@ -1524,8 +1635,8 @@ function registerDiffCommand(program, dependencies = {}) {
 ` + `Usage: doccov diff <base> <head>
 ` + "   or: doccov diff --base main.json --head feature.json");
       }
-      const baseSpec = loadSpec(baseFile, readFileSync2);
-      const headSpec = loadSpec(headFile, readFileSync2);
+      const baseSpec = loadSpec(baseFile, readFileSync3);
+      const headSpec = loadSpec(headFile, readFileSync3);
       const config = await loadDocCovConfig(options.cwd);
       const baseHash = hashString(JSON.stringify(baseSpec));
       const headHash = hashString(JSON.stringify(headSpec));
@@ -1546,6 +1657,29 @@ function registerDiffCommand(program, dependencies = {}) {
       }
       const minCoverage = resolveThreshold(options.minCoverage, config?.check?.minCoverage);
       const maxDrift = resolveThreshold(options.maxDrift, config?.check?.maxDrift);
+      if (options.recommendVersion) {
+        const recommendation = recommendSemverBump(diff);
+        const currentVersion = headSpec.meta?.version ?? "0.0.0";
+        const nextVersion = calculateNextVersion(currentVersion, recommendation.bump);
+        if (options.format === "json") {
+          log(JSON.stringify({
+            current: currentVersion,
+            recommended: nextVersion,
+            bump: recommendation.bump,
+            reason: recommendation.reason,
+            breakingCount: recommendation.breakingCount,
+            additionCount: recommendation.additionCount,
+            docsOnlyChanges: recommendation.docsOnlyChanges
+          }, null, 2));
+        } else {
+          log("");
+          log(chalk5.bold("Semver Recommendation"));
+          log(`  Current version:    ${currentVersion}`);
+          log(`  Recommended:        ${chalk5.cyan(nextVersion)} (${chalk5.yellow(recommendation.bump.toUpperCase())})`);
+          log(`  Reason:             ${recommendation.reason}`);
+        }
+        return;
+      }
       const format = options.format ?? "text";
       const limit = parseInt(options.limit, 10) || 10;
       const checks = getStrictChecks(options.strict);
@@ -1559,9 +1693,6 @@ function registerDiffCommand(program, dependencies = {}) {
       switch (format) {
         case "text":
           printSummary(diff, baseName, headName, fromCache, log);
-          if (options.ai && diff.docsImpact && hasDocsImpact(diff)) {
-            await printAISummary(diff, log);
-          }
           if (!options.stdout) {
             const jsonPath = getDiffReportPath(baseHash, headHash, "json");
             if (!fromCache) {
@@ -1573,8 +1704,8 @@ function registerDiffCommand(program, dependencies = {}) {
                 silent: true
               });
             }
-            const cacheNote = fromCache ? chalk4.cyan(" (cached)") : "";
-            log(chalk4.dim(`Report: ${jsonPath}`) + cacheNote);
+            const cacheNote = fromCache ? chalk5.cyan(" (cached)") : "";
+            log(chalk5.dim(`Report: ${jsonPath}`) + cacheNote);
           }
           break;
         case "json": {
@@ -1626,15 +1757,39 @@ function registerDiffCommand(program, dependencies = {}) {
           printGitHubAnnotations(diff, log);
           break;
         case "pr-comment": {
+          const semverRecommendation = recommendSemverBump(diff);
           const content = renderPRComment({ diff, baseName, headName, headSpec }, {
             repoUrl: options.repoUrl,
             sha: options.sha,
             minCoverage,
-            limit
+            limit,
+            semverBump: { bump: semverRecommendation.bump, reason: semverRecommendation.reason }
           });
           log(content);
           break;
         }
+        case "changelog": {
+          const content = renderChangelog({
+            diff,
+            categorizedBreaking: diff.categorizedBreaking,
+            version: headSpec.meta?.version
+          }, {
+            version: headSpec.meta?.version,
+            compareUrl: options.repoUrl ? `${options.repoUrl}/compare/${baseSpec.meta?.version ?? "v0"}...${headSpec.meta?.version ?? "HEAD"}` : undefined
+          });
+          if (options.stdout) {
+            log(content);
+          } else {
+            const outputPath = options.output ?? getDiffReportPath(baseHash, headHash, "md");
+            writeReport({
+              format: "markdown",
+              content,
+              outputPath: outputPath.replace(/\.(json|html)$/, ".changelog.md"),
+              cwd: options.cwd
+            });
+          }
+          break;
+        }
       }
       const failures = validateDiff(diff, headSpec, {
         minCoverage,
@@ -1642,29 +1797,29 @@ function registerDiffCommand(program, dependencies = {}) {
         checks
       });
       if (failures.length > 0) {
-        log(chalk4.red(`
+        log(chalk5.red(`
 ✗ Check failed`));
         for (const f of failures) {
-          log(chalk4.red(`  - ${f}`));
+          log(chalk5.red(`  - ${f}`));
         }
         process.exitCode = 1;
       } else if (options.strict || minCoverage !== undefined || maxDrift !== undefined) {
-        log(chalk4.green(`
+        log(chalk5.green(`
 ✓ All checks passed`));
       }
     } catch (commandError) {
-      error(chalk4.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk5.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     }
   });
 }
-function collect(value, previous) {
+function collect2(value, previous) {
   return previous.concat([value]);
 }
-async function loadMarkdownFiles(patterns) {
+async function loadMarkdownFiles2(patterns) {
   const files = [];
   for (const pattern of patterns) {
-    const matches = await glob(pattern, { nodir: true });
+    const matches = await glob2(pattern, { nodir: true });
     for (const filePath of matches) {
       try {
         const content = fs3.readFileSync(filePath, "utf-8");
@@ -1672,7 +1827,7 @@ async function loadMarkdownFiles(patterns) {
       } catch {}
     }
   }
-  return parseMarkdownFiles(files);
+  return parseMarkdownFiles2(files);
 }
 async function generateDiff(baseSpec, headSpec, options, config, log) {
   let markdownFiles;
@@ -1680,21 +1835,21 @@ async function generateDiff(baseSpec, headSpec, options, config, log) {
   if (!docsPatterns || docsPatterns.length === 0) {
     if (config?.docs?.include) {
       docsPatterns = config.docs.include;
-      log(chalk4.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
+      log(chalk5.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
     }
   }
   if (docsPatterns && docsPatterns.length > 0) {
-    markdownFiles = await loadMarkdownFiles(docsPatterns);
+    markdownFiles = await loadMarkdownFiles2(docsPatterns);
   }
   return diffSpecWithDocs(baseSpec, headSpec, { markdownFiles });
 }
-function loadSpec(filePath, readFileSync2) {
+function loadSpec(filePath, readFileSync3) {
   const resolvedPath = path5.resolve(filePath);
   if (!fs3.existsSync(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   try {
-    const content = readFileSync2(resolvedPath, "utf-8");
+    const content = readFileSync3(resolvedPath, "utf-8");
     const spec = JSON.parse(content);
     return ensureSpecCoverage(spec);
   } catch (parseError) {
@@ -1703,60 +1858,40 @@ function loadSpec(filePath, readFileSync2) {
 }
 function printSummary(diff, baseName, headName, fromCache, log) {
   log("");
-  const cacheIndicator = fromCache ? chalk4.cyan(" (cached)") : "";
-  log(chalk4.bold(`Comparing: ${baseName} → ${headName}`) + cacheIndicator);
+  const cacheIndicator = fromCache ? chalk5.cyan(" (cached)") : "";
+  log(chalk5.bold(`Comparing: ${baseName} → ${headName}`) + cacheIndicator);
   log("─".repeat(40));
   log("");
-  const coverageColor = diff.coverageDelta > 0 ? chalk4.green : diff.coverageDelta < 0 ? chalk4.red : chalk4.gray;
+  const coverageColor = diff.coverageDelta > 0 ? chalk5.green : diff.coverageDelta < 0 ? chalk5.red : chalk5.gray;
   const coverageSign = diff.coverageDelta > 0 ? "+" : "";
   log(`  Coverage:   ${diff.oldCoverage}% → ${diff.newCoverage}% ${coverageColor(`(${coverageSign}${diff.coverageDelta}%)`)}`);
   const breakingCount = diff.breaking.length;
   const highSeverity = diff.categorizedBreaking?.filter((c) => c.severity === "high").length ?? 0;
   if (breakingCount > 0) {
-    const severityNote = highSeverity > 0 ? chalk4.red(` (${highSeverity} high severity)`) : "";
-    log(`  Breaking:   ${chalk4.red(breakingCount)} changes${severityNote}`);
+    const severityNote = highSeverity > 0 ? chalk5.red(` (${highSeverity} high severity)`) : "";
+    log(`  Breaking:   ${chalk5.red(breakingCount)} changes${severityNote}`);
   } else {
-    log(`  Breaking:   ${chalk4.green("0")} changes`);
+    log(`  Breaking:   ${chalk5.green("0")} changes`);
   }
   const newCount = diff.nonBreaking.length;
   const undocCount = diff.newUndocumented.length;
   if (newCount > 0) {
-    const undocNote = undocCount > 0 ? chalk4.yellow(` (${undocCount} undocumented)`) : "";
-    log(`  New:        ${chalk4.green(newCount)} exports${undocNote}`);
+    const undocNote = undocCount > 0 ? chalk5.yellow(` (${undocCount} undocumented)`) : "";
+    log(`  New:        ${chalk5.green(newCount)} exports${undocNote}`);
   }
   if (diff.driftIntroduced > 0 || diff.driftResolved > 0) {
     const parts = [];
     if (diff.driftIntroduced > 0)
-      parts.push(chalk4.red(`+${diff.driftIntroduced}`));
+      parts.push(chalk5.red(`+${diff.driftIntroduced}`));
     if (diff.driftResolved > 0)
-      parts.push(chalk4.green(`-${diff.driftResolved}`));
+      parts.push(chalk5.green(`-${diff.driftResolved}`));
     log(`  Drift:      ${parts.join(", ")}`);
   }
+  const recommendation = recommendSemverBump(diff);
+  const bumpColor = recommendation.bump === "major" ? chalk5.red : recommendation.bump === "minor" ? chalk5.yellow : chalk5.green;
+  log(`  Semver:     ${bumpColor(recommendation.bump.toUpperCase())} (${recommendation.reason})`);
   log("");
 }
-async function printAISummary(diff, log) {
-  if (!isAIDocsAnalysisAvailable()) {
-    log(chalk4.yellow(`
-⚠ AI analysis unavailable (set OPENAI_API_KEY or ANTHROPIC_API_KEY)`));
-    return;
-  }
-  if (!diff.docsImpact)
-    return;
-  log(chalk4.gray(`
-Generating AI summary...`));
-  const impacts = diff.docsImpact.impactedFiles.flatMap((f) => f.references.map((r) => ({
-    file: f.file,
-    exportName: r.exportName,
-    changeType: r.changeType,
-    context: r.context
-  })));
-  const summary = await generateImpactSummary(impacts);
-  if (summary) {
-    log("");
-    log(chalk4.bold("AI Summary"));
-    log(chalk4.cyan(`  ${summary}`));
-  }
-}
 function validateDiff(diff, headSpec, options) {
   const { minCoverage, maxDrift, checks } = options;
   const failures = [];
@@ -1835,7 +1970,7 @@ function printGitHubAnnotations(diff, log) {
 
 // src/commands/info.ts
 import { DocCov as DocCov2, enrichSpec as enrichSpec2, NodeFileSystem as NodeFileSystem2, resolveTarget as resolveTarget2 } from "@doccov/sdk";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 function registerInfoCommand(program) {
   program.command("info [entry]").description("Show brief documentation coverage summary").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--skip-resolve", "Skip external type resolution from node_modules").action(async (entry, options) => {
     try {
@@ -1857,14 +1992,14 @@ function registerInfoCommand(program) {
       const spec = enrichSpec2(specResult.spec);
       const stats = computeStats(spec);
       console.log("");
-      console.log(chalk5.bold(`${stats.packageName}@${stats.version}`));
+      console.log(chalk6.bold(`${stats.packageName}@${stats.version}`));
       console.log("");
-      console.log(`  Exports:    ${chalk5.bold(stats.totalExports.toString())}`);
-      console.log(`  Coverage:   ${chalk5.bold(`${stats.coverageScore}%`)}`);
-      console.log(`  Drift:      ${chalk5.bold(`${stats.driftScore}%`)}`);
+      console.log(`  Exports:    ${chalk6.bold(stats.totalExports.toString())}`);
+      console.log(`  Coverage:   ${chalk6.bold(`${stats.coverageScore}%`)}`);
+      console.log(`  Drift:      ${chalk6.bold(`${stats.driftScore}%`)}`);
       console.log("");
     } catch (err) {
-      console.error(chalk5.red("Error:"), err instanceof Error ? err.message : err);
+      console.error(chalk6.red("Error:"), err instanceof Error ? err.message : err);
       process.exit(1);
     }
   });
@@ -1873,53 +2008,65 @@ function registerInfoCommand(program) {
 // src/commands/init.ts
 import * as fs4 from "node:fs";
 import * as path6 from "node:path";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 var defaultDependencies3 = {
   fileExists: fs4.existsSync,
   writeFileSync: fs4.writeFileSync,
   readFileSync: fs4.readFileSync,
+  mkdirSync: fs4.mkdirSync,
   log: console.log,
   error: console.error
 };
 function registerInitCommand(program, dependencies = {}) {
-  const { fileExists: fileExists2, writeFileSync: writeFileSync3, readFileSync: readFileSync3, log, error } = {
+  const { fileExists: fileExists2, writeFileSync: writeFileSync3, readFileSync: readFileSync4, mkdirSync: mkdirSync3, log, error } = {
     ...defaultDependencies3,
     ...dependencies
   };
-  program.command("init").description("Create a DocCov configuration file").option("--cwd <dir>", "Working directory", process.cwd()).option("--format <format>", "Config format: auto, mjs, js, cjs, yaml", "auto").action((options) => {
+  program.command("init").description("Initialize DocCov: config, GitHub Action, and badge").option("--cwd <dir>", "Working directory", process.cwd()).option("--skip-action", "Skip GitHub Action workflow creation").action((options) => {
     const cwd = path6.resolve(options.cwd);
-    const formatOption = String(options.format ?? "auto").toLowerCase();
-    if (!isValidFormat(formatOption)) {
-      error(chalk6.red(`Invalid format "${formatOption}". Use auto, mjs, js, cjs, or yaml.`));
-      process.exitCode = 1;
-      return;
-    }
     const existing = findExistingConfig(cwd, fileExists2);
     if (existing) {
-      error(chalk6.red(`A DocCov config already exists at ${path6.relative(cwd, existing) || "./doccov.config.*"}.`));
+      error(chalk7.red(`A DocCov config already exists at ${path6.relative(cwd, existing) || "./doccov.config.*"}.`));
       process.exitCode = 1;
       return;
     }
-    const packageType = detectPackageType(cwd, fileExists2, readFileSync3);
-    const targetFormat = resolveFormat(formatOption, packageType);
-    if (targetFormat === "js" && packageType !== "module") {
-      log(chalk6.yellow('Package is not marked as "type": "module"; creating doccov.config.js may require enabling ESM.'));
-    }
-    const fileName = targetFormat === "yaml" ? "doccov.yml" : `doccov.config.${targetFormat}`;
+    const packageType = detectPackageType(cwd, fileExists2, readFileSync4);
+    const targetFormat = packageType === "module" ? "ts" : "mts";
+    const fileName = `doccov.config.${targetFormat}`;
     const outputPath = path6.join(cwd, fileName);
     if (fileExists2(outputPath)) {
-      error(chalk6.red(`Cannot create ${fileName}; file already exists.`));
+      error(chalk7.red(`Cannot create ${fileName}; file already exists.`));
       process.exitCode = 1;
       return;
     }
-    const template = buildTemplate(targetFormat);
+    const template = buildConfigTemplate();
     writeFileSync3(outputPath, template, { encoding: "utf8" });
-    log(chalk6.green(`✓ Created ${path6.relative(process.cwd(), outputPath)}`));
+    log(chalk7.green(`✓ Created ${fileName}`));
+    if (!options.skipAction) {
+      const workflowDir = path6.join(cwd, ".github", "workflows");
+      const workflowPath = path6.join(workflowDir, "doccov.yml");
+      if (!fileExists2(workflowPath)) {
+        mkdirSync3(workflowDir, { recursive: true });
+        writeFileSync3(workflowPath, buildWorkflowTemplate(), { encoding: "utf8" });
+        log(chalk7.green(`✓ Created .github/workflows/doccov.yml`));
+      } else {
+        log(chalk7.yellow(`  Skipped .github/workflows/doccov.yml (already exists)`));
+      }
+    }
+    const repoInfo = detectRepoInfo(cwd, fileExists2, readFileSync4);
+    log("");
+    log(chalk7.bold("Add this badge to your README:"));
+    log("");
+    if (repoInfo) {
+      log(chalk7.cyan(`[![DocCov](https://doccov.dev/badge/${repoInfo.owner}/${repoInfo.repo})](https://doccov.dev/${repoInfo.owner}/${repoInfo.repo})`));
+    } else {
+      log(chalk7.cyan(`[![DocCov](https://doccov.dev/badge/OWNER/REPO)](https://doccov.dev/OWNER/REPO)`));
+      log(chalk7.dim("  Replace OWNER/REPO with your GitHub repo"));
+    }
+    log("");
+    log(chalk7.dim("Run `doccov check` to verify your documentation coverage"));
   });
 }
-var isValidFormat = (value) => {
-  return ["auto", "mjs", "js", "cjs", "yaml"].includes(value);
-};
 var findExistingConfig = (cwd, fileExists2) => {
   let current = path6.resolve(cwd);
   const { root } = path6.parse(current);
@@ -1937,13 +2084,13 @@ var findExistingConfig = (cwd, fileExists2) => {
   }
   return null;
 };
-var detectPackageType = (cwd, fileExists2, readFileSync3) => {
+var detectPackageType = (cwd, fileExists2, readFileSync4) => {
   const packageJsonPath = findNearestPackageJson(cwd, fileExists2);
   if (!packageJsonPath) {
     return;
   }
   try {
-    const raw = readFileSync3(packageJsonPath, "utf8");
+    const raw = readFileSync4(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.type === "module") {
       return "module";
@@ -1969,121 +2116,85 @@ var findNearestPackageJson = (cwd, fileExists2) => {
   }
   return null;
 };
-var resolveFormat = (format, packageType) => {
-  if (format === "yaml")
-    return "yaml";
-  if (format === "auto") {
-    return packageType === "module" ? "js" : "mjs";
-  }
-  return format;
-};
-var buildTemplate = (format) => {
-  if (format === "yaml") {
-    return `# doccov.yml
-# include:
-#   - "MyClass"
-#   - "myFunction"
-# exclude:
-#   - "internal*"
-
-check:
-  # minCoverage: 80
-  # maxDrift: 20
-  # examples: typecheck
+var buildConfigTemplate = () => {
+  return `import { defineConfig } from '@doccov/cli/config';
 
-quality:
-  rules:
-    # has-description: warn
-    # has-params: off
-    # has-returns: off
-`;
-  }
-  const configBody = `{
-  // Filter which exports to analyze
+export default defineConfig({
+  // Filter exports to analyze (optional)
   // include: ['MyClass', 'myFunction'],
   // exclude: ['internal*'],
 
-  // Check command thresholds
   check: {
-    // Minimum documentation coverage percentage (0-100)
-    // minCoverage: 80,
+    // Fail if coverage drops below threshold
+    minCoverage: 80,
 
-    // Maximum drift percentage allowed (0-100)
+    // Fail if drift exceeds threshold
     // maxDrift: 20,
-
-    // Example validation: 'presence' | 'typecheck' | 'run'
-    // examples: 'typecheck',
   },
+});
+`;
+};
+var buildWorkflowTemplate = () => {
+  return `name: DocCov
 
-  // Quality rule severities: 'error' | 'warn' | 'off'
-  quality: {
-    rules: {
-      // 'has-description': 'warn',
-      // 'has-params': 'off',
-      // 'has-returns': 'off',
-      // 'has-examples': 'off',
-      // 'no-empty-returns': 'warn',
-      // 'consistent-param-style': 'off',
-    },
-  },
-}`;
-  if (format === "cjs") {
-    return [
-      "const { defineConfig } = require('@doccov/cli/config');",
-      "",
-      `module.exports = defineConfig(${configBody});`,
-      ""
-    ].join(`
-`);
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  doccov:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: doccov/action@v1
+        with:
+          min-coverage: 80
+          comment-on-pr: true
+`;
+};
+var detectRepoInfo = (cwd, fileExists2, readFileSync4) => {
+  const packageJsonPath = findNearestPackageJson(cwd, fileExists2);
+  if (packageJsonPath) {
+    try {
+      const raw = readFileSync4(packageJsonPath, "utf8");
+      const parsed = JSON.parse(raw);
+      let repoUrl;
+      if (typeof parsed.repository === "string") {
+        repoUrl = parsed.repository;
+      } else if (parsed.repository?.url) {
+        repoUrl = parsed.repository.url;
+      }
+      if (repoUrl) {
+        const match = repoUrl.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+        if (match) {
+          return { owner: match[1], repo: match[2] };
+        }
+      }
+    } catch {}
   }
-  return [
-    "import { defineConfig } from '@doccov/cli/config';",
-    "",
-    `export default defineConfig(${configBody});`,
-    ""
-  ].join(`
-`);
+  const gitConfigPath = path6.join(cwd, ".git", "config");
+  if (fileExists2(gitConfigPath)) {
+    try {
+      const config = readFileSync4(gitConfigPath, "utf8");
+      const match = config.match(/url\s*=\s*.*github\.com[/:]([^/]+)\/([^/.]+)/);
+      if (match) {
+        return { owner: match[1], repo: match[2].replace(/\.git$/, "") };
+      }
+    } catch {}
+  }
+  return null;
 };
 
 // src/commands/spec.ts
 import * as fs5 from "node:fs";
 import * as path7 from "node:path";
-import { DocCov as DocCov3, NodeFileSystem as NodeFileSystem3, resolveTarget as resolveTarget3 } from "@doccov/sdk";
+import { DocCov as DocCov3, NodeFileSystem as NodeFileSystem3, renderApiSurface, resolveTarget as resolveTarget3 } from "@doccov/sdk";
 import { normalize, validateSpec } from "@openpkg-ts/spec";
 import chalk8 from "chalk";
 // package.json
-var version = "0.16.0";
-
-// src/utils/filter-options.ts
-import { mergeFilters, parseListFlag } from "@doccov/sdk";
-import chalk7 from "chalk";
-var formatList = (label, values) => `${label}: ${values.map((value) => chalk7.cyan(value)).join(", ")}`;
-var mergeFilterOptions = (config, cliOptions) => {
-  const messages = [];
-  if (config?.include) {
-    messages.push(formatList("include filters from config", config.include));
-  }
-  if (config?.exclude) {
-    messages.push(formatList("exclude filters from config", config.exclude));
-  }
-  if (cliOptions.include) {
-    messages.push(formatList("apply include filters from CLI", cliOptions.include));
-  }
-  if (cliOptions.exclude) {
-    messages.push(formatList("apply exclude filters from CLI", cliOptions.exclude));
-  }
-  const resolved = mergeFilters(config, cliOptions);
-  if (!resolved.include && !resolved.exclude) {
-    return { messages };
-  }
-  const source = resolved.source === "override" ? "cli" : resolved.source;
-  return {
-    include: resolved.include,
-    exclude: resolved.exclude,
-    source,
-    messages
-  };
-};
+var version = "0.18.0";
 
 // src/commands/spec.ts
 var defaultDependencies4 = {
@@ -2107,7 +2218,7 @@ function registerSpecCommand(program, dependencies = {}) {
     ...defaultDependencies4,
     ...dependencies
   };
-  program.command("spec [entry]").description("Generate OpenPkg specification (JSON)").option("--cwd <dir>", "Working directory", process.cwd()).option("-p, --package <name>", "Target package name (for monorepos)").option("-o, --output <file>", "Output file path", "openpkg.json").option("--include <patterns>", "Include exports matching pattern (comma-separated)").option("--exclude <patterns>", "Exclude exports matching pattern (comma-separated)").option("--skip-resolve", "Skip external type resolution from node_modules").option("--max-type-depth <n>", "Maximum depth for type conversion", "20").option("--no-cache", "Bypass spec cache and force regeneration").option("--show-diagnostics", "Show TypeScript compiler diagnostics").option("--verbose", "Show detailed generation metadata").action(async (entry, options) => {
+  program.command("spec [entry]").description("Generate OpenPkg specification (JSON)").option("--cwd <dir>", "Working directory", process.cwd()).option("-p, --package <name>", "Target package name (for monorepos)").option("-o, --output <file>", "Output file path", "openpkg.json").option("-f, --format <format>", "Output format: json (default) or api-surface", "json").option("--include <patterns>", "Include exports matching pattern (comma-separated)").option("--exclude <patterns>", "Exclude exports matching pattern (comma-separated)").option("--visibility <tags>", "Filter by release stage: public,beta,alpha,internal (comma-separated)").option("--skip-resolve", "Skip external type resolution from node_modules").option("--max-type-depth <n>", "Maximum depth for type conversion", "20").option("--runtime", "Enable Standard Schema runtime extraction (richer output for Zod, Valibot, etc.)").option("--no-cache", "Bypass spec cache and force regeneration").option("--show-diagnostics", "Show TypeScript compiler diagnostics").option("--verbose", "Show detailed generation metadata").action(async (entry, options) => {
     try {
       const steps = new StepProgress([
         { label: "Resolved target", activeLabel: "Resolving target" },
@@ -2135,7 +2246,8 @@ function registerSpecCommand(program, dependencies = {}) {
       steps.next();
       const cliFilters = {
         include: parseListFlag(options.include),
-        exclude: parseListFlag(options.exclude)
+        exclude: parseListFlag(options.exclude),
+        visibility: parseVisibilityFlag(options.visibility)
       };
       const resolvedFilters = mergeFilterOptions(config, cliFilters);
       const resolveExternalTypes = !options.skipResolve;
@@ -2143,7 +2255,8 @@ function registerSpecCommand(program, dependencies = {}) {
         resolveExternalTypes,
         maxDepth: options.maxTypeDepth ? parseInt(options.maxTypeDepth, 10) : undefined,
         useCache: options.cache !== false,
-        cwd: options.cwd
+        cwd: options.cwd,
+        schemaExtraction: options.runtime ? "hybrid" : "static"
       });
       const generationInput = {
         entryPoint: path7.relative(targetDir, entryFile),
@@ -2155,10 +2268,11 @@ function registerSpecCommand(program, dependencies = {}) {
         isMonorepo: resolved.isMonorepo,
         targetPackage: packageInfo?.name
       };
-      const analyzeOptions = resolvedFilters.include || resolvedFilters.exclude ? {
+      const analyzeOptions = resolvedFilters.include || resolvedFilters.exclude || resolvedFilters.visibility ? {
         filters: {
           include: resolvedFilters.include,
-          exclude: resolvedFilters.exclude
+          exclude: resolvedFilters.exclude,
+          visibility: resolvedFilters.visibility
         },
         generationInput
       } : { generationInput };
@@ -2177,9 +2291,16 @@ function registerSpecCommand(program, dependencies = {}) {
         process.exit(1);
       }
       steps.next();
-      const outputPath = path7.resolve(process.cwd(), options.output);
-      writeFileSync4(outputPath, JSON.stringify(normalized, null, 2));
-      steps.complete(`Generated ${options.output}`);
+      const format = options.format ?? "json";
+      const outputPath = path7.resolve(options.cwd, options.output);
+      if (format === "api-surface") {
+        const apiSurface = renderApiSurface(normalized);
+        writeFileSync4(outputPath, apiSurface);
+        steps.complete(`Generated ${options.output} (API surface)`);
+      } else {
+        writeFileSync4(outputPath, JSON.stringify(normalized, null, 2));
+        steps.complete(`Generated ${options.output}`);
+      }
       log(chalk8.gray(`  ${getArrayLength(normalized.exports)} exports`));
       log(chalk8.gray(`  ${getArrayLength(normalized.types)} types`));
       if (options.verbose && normalized.generation) {
@@ -2195,6 +2316,13 @@ function registerSpecCommand(program, dependencies = {}) {
         if (gen.analysis.maxTypeDepth) {
           log(chalk8.gray(`  Max type depth:   ${gen.analysis.maxTypeDepth}`));
         }
+        if (gen.analysis.schemaExtraction) {
+          const se = gen.analysis.schemaExtraction;
+          log(chalk8.gray(`  Schema extraction: ${se.method}`));
+          if (se.runtimeCount) {
+            log(chalk8.gray(`  Runtime schemas:   ${se.runtimeCount} (${se.vendors?.join(", ")})`));
+          }
+        }
         log("");
         log(chalk8.bold("Environment"));
         log(chalk8.gray(`  node_modules:     ${gen.environment.hasNodeModules ? "found" : "not found"}`));
@@ -2234,10 +2362,195 @@ function registerSpecCommand(program, dependencies = {}) {
   });
 }
 
+// src/commands/trends.ts
+import * as fs6 from "node:fs";
+import * as path8 from "node:path";
+import {
+  formatDelta as formatDelta2,
+  getExtendedTrend,
+  getTrend,
+  loadSnapshots,
+  pruneByTier,
+  pruneHistory,
+  renderSparkline,
+  RETENTION_DAYS,
+  saveSnapshot
+} from "@doccov/sdk";
+import chalk9 from "chalk";
+function formatDate(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function getColorForScore(score) {
+  if (score >= 90)
+    return chalk9.green;
+  if (score >= 70)
+    return chalk9.yellow;
+  if (score >= 50)
+    return chalk9.hex("#FFA500");
+  return chalk9.red;
+}
+function formatSnapshot(snapshot) {
+  const color = getColorForScore(snapshot.coverageScore);
+  const date = formatDate(snapshot.timestamp);
+  const version2 = snapshot.version ? ` v${snapshot.version}` : "";
+  const commit = snapshot.commit ? chalk9.gray(` (${snapshot.commit.slice(0, 7)})`) : "";
+  return `${chalk9.gray(date)}  ${color(`${snapshot.coverageScore}%`)}  ${snapshot.documentedExports}/${snapshot.totalExports} exports${version2}${commit}`;
+}
+function formatWeekDate(timestamp) {
+  const date = new Date(timestamp);
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+function formatVelocity(velocity) {
+  if (velocity > 0)
+    return chalk9.green(`+${velocity}%/day`);
+  if (velocity < 0)
+    return chalk9.red(`${velocity}%/day`);
+  return chalk9.gray("0%/day");
+}
+function registerTrendsCommand(program) {
+  program.command("trends").description("Show coverage trends over time").option("--cwd <dir>", "Working directory", process.cwd()).option("-n, --limit <count>", "Number of snapshots to show", "10").option("--prune <count>", "Prune history to keep only N snapshots").option("--record", "Record current coverage to history").option("--json", "Output as JSON").option("--extended", "Show extended trend analysis (velocity, projections)").option("--tier <tier>", "Retention tier: free (7d), team (30d), pro (90d)", "pro").option("--weekly", "Show weekly summary breakdown").action(async (options) => {
+    const cwd = path8.resolve(options.cwd);
+    const tier = options.tier ?? "pro";
+    if (options.prune) {
+      const keepCount = parseInt(options.prune, 10);
+      if (!isNaN(keepCount)) {
+        const deleted = pruneHistory(cwd, keepCount);
+        console.log(chalk9.green(`Pruned ${deleted} old snapshots, kept ${keepCount} most recent`));
+      } else {
+        const deleted = pruneByTier(cwd, tier);
+        console.log(chalk9.green(`Pruned ${deleted} snapshots older than ${RETENTION_DAYS[tier]} days`));
+      }
+      return;
+    }
+    if (options.record) {
+      const specPath = path8.resolve(cwd, "openpkg.json");
+      if (!fs6.existsSync(specPath)) {
+        console.error(chalk9.red("No openpkg.json found. Run `doccov spec` first to generate a spec."));
+        process.exit(1);
+      }
+      try {
+        const specContent = fs6.readFileSync(specPath, "utf-8");
+        const spec = JSON.parse(specContent);
+        const trend = getTrend(spec, cwd);
+        saveSnapshot(trend.current, cwd);
+        console.log(chalk9.green("Recorded coverage snapshot:"));
+        console.log(formatSnapshot(trend.current));
+        if (trend.delta !== undefined) {
+          const deltaStr = formatDelta2(trend.delta);
+          const deltaColor = trend.delta > 0 ? chalk9.green : trend.delta < 0 ? chalk9.red : chalk9.gray;
+          console.log(chalk9.gray("Change from previous:"), deltaColor(deltaStr));
+        }
+        return;
+      } catch (error) {
+        console.error(chalk9.red("Failed to read openpkg.json:"), error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    }
+    const snapshots = loadSnapshots(cwd);
+    const limit = parseInt(options.limit ?? "10", 10);
+    if (snapshots.length === 0) {
+      console.log(chalk9.yellow("No coverage history found."));
+      console.log(chalk9.gray("Run `doccov trends --record` to save the current coverage."));
+      return;
+    }
+    if (options.json) {
+      const output = {
+        current: snapshots[0],
+        history: snapshots.slice(1),
+        delta: snapshots.length > 1 ? snapshots[0].coverageScore - snapshots[1].coverageScore : undefined,
+        sparkline: snapshots.slice(0, 10).map((s) => s.coverageScore).reverse()
+      };
+      console.log(JSON.stringify(output, null, 2));
+      return;
+    }
+    const sparklineData = snapshots.slice(0, 10).map((s) => s.coverageScore).reverse();
+    const sparkline = renderSparkline(sparklineData);
+    console.log(chalk9.bold("Coverage Trends"));
+    console.log(chalk9.gray(`Package: ${snapshots[0].package}`));
+    console.log(chalk9.gray(`Sparkline: ${sparkline}`));
+    console.log("");
+    if (snapshots.length >= 2) {
+      const oldest = snapshots[snapshots.length - 1];
+      const newest = snapshots[0];
+      const overallDelta = newest.coverageScore - oldest.coverageScore;
+      const deltaStr = formatDelta2(overallDelta);
+      const deltaColor = overallDelta > 0 ? chalk9.green : overallDelta < 0 ? chalk9.red : chalk9.gray;
+      console.log(chalk9.gray("Overall trend:"), deltaColor(deltaStr), chalk9.gray(`(${snapshots.length} snapshots)`));
+      console.log("");
+    }
+    if (options.extended) {
+      const specPath = path8.resolve(cwd, "openpkg.json");
+      if (fs6.existsSync(specPath)) {
+        try {
+          const specContent = fs6.readFileSync(specPath, "utf-8");
+          const spec = JSON.parse(specContent);
+          const extended = getExtendedTrend(spec, cwd, { tier });
+          console.log(chalk9.bold("Extended Analysis"));
+          console.log(chalk9.gray(`Tier: ${tier} (${RETENTION_DAYS[tier]}-day retention)`));
+          console.log("");
+          console.log("  Velocity:");
+          console.log(`    7-day:   ${formatVelocity(extended.velocity7d)}`);
+          console.log(`    30-day:  ${formatVelocity(extended.velocity30d)}`);
+          if (extended.velocity90d !== undefined) {
+            console.log(`    90-day:  ${formatVelocity(extended.velocity90d)}`);
+          }
+          console.log("");
+          const projColor = extended.projected30d >= extended.trend.current.coverageScore ? chalk9.green : chalk9.red;
+          console.log(`  Projected (30d): ${projColor(`${extended.projected30d}%`)}`);
+          console.log(`  All-time high:   ${chalk9.green(`${extended.allTimeHigh}%`)}`);
+          console.log(`  All-time low:    ${chalk9.red(`${extended.allTimeLow}%`)}`);
+          if (extended.dataRange) {
+            const startDate = formatWeekDate(extended.dataRange.start);
+            const endDate = formatWeekDate(extended.dataRange.end);
+            console.log(chalk9.gray(`  Data range: ${startDate} - ${endDate}`));
+          }
+          console.log("");
+          if (options.weekly && extended.weeklySummaries.length > 0) {
+            console.log(chalk9.bold("Weekly Summary"));
+            const weekLimit = Math.min(extended.weeklySummaries.length, 8);
+            for (let i = 0;i < weekLimit; i++) {
+              const week = extended.weeklySummaries[i];
+              const weekStart = formatWeekDate(week.weekStart);
+              const weekEnd = formatWeekDate(week.weekEnd);
+              const deltaColor = week.delta > 0 ? chalk9.green : week.delta < 0 ? chalk9.red : chalk9.gray;
+              const deltaStr = week.delta > 0 ? `+${week.delta}%` : `${week.delta}%`;
+              console.log(`  ${weekStart} - ${weekEnd}:  ${week.avgCoverage}% avg  ${deltaColor(deltaStr)}  (${week.snapshotCount} snapshots)`);
+            }
+            if (extended.weeklySummaries.length > weekLimit) {
+              console.log(chalk9.gray(`  ... and ${extended.weeklySummaries.length - weekLimit} more weeks`));
+            }
+            console.log("");
+          }
+        } catch {
+          console.log(chalk9.yellow("Could not load openpkg.json for extended analysis"));
+          console.log("");
+        }
+      }
+    }
+    console.log(chalk9.bold("History"));
+    const displaySnapshots = snapshots.slice(0, limit);
+    for (let i = 0;i < displaySnapshots.length; i++) {
+      const snapshot = displaySnapshots[i];
+      const prefix = i === 0 ? chalk9.cyan("→") : " ";
+      console.log(`${prefix} ${formatSnapshot(snapshot)}`);
+    }
+    if (snapshots.length > limit) {
+      console.log(chalk9.gray(`  ... and ${snapshots.length - limit} more`));
+    }
+  });
+}
+
 // src/cli.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path8.dirname(__filename2);
-var packageJson = JSON.parse(readFileSync3(path8.join(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = path9.dirname(__filename2);
+var packageJson = JSON.parse(readFileSync5(path9.join(__dirname2, "../package.json"), "utf-8"));
 var program = new Command;
 program.name("doccov").description("DocCov - Documentation coverage and drift detection for TypeScript").version(packageJson.version);
 registerCheckCommand(program);
@@ -2245,6 +2558,7 @@ registerInfoCommand(program);
 registerSpecCommand(program);
 registerDiffCommand(program);
 registerInitCommand(program);
+registerTrendsCommand(program);
 program.command("*", { hidden: true }).action(() => {
   program.outputHelp();
 });