@doccov/cli 0.17.0 → 0.18.0

package/dist/cli.js

@@ -35,13 +35,20 @@ var checkConfigSchema = z.object({
 var qualityConfigSchema = z.object({
   rules: z.record(severitySchema).optional()
 });
+var policyConfigSchema = z.object({
+  path: z.string().min(1),
+  minCoverage: z.number().min(0).max(100).optional(),
+  maxDrift: z.number().min(0).max(100).optional(),
+  requireExamples: z.boolean().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()
+  quality: qualityConfigSchema.optional(),
+  policies: z.array(policyConfigSchema).optional()
 });
 var normalizeList = (value) => {
   if (!value) {
@@ -79,13 +86,15 @@ var normalizeConfig = (input) => {
       rules: input.quality.rules
     };
   }
+  const policies = input.policies;
   return {
     include,
     exclude,
     plugins: input.plugins,
     docs,
     check,
-    quality
+    quality,
+    policies
   };
 };
 
@@ -168,8 +177,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 readFileSync4 } from "node:fs";
+import * as path9 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -177,11 +186,14 @@ import { Command } from "commander";
 import * as fs2 from "node:fs";
 import * as path4 from "node:path";
 import {
+  analyzeSpecContributors,
+  analyzeSpecOwnership,
   applyEdits,
   categorizeDrifts,
   createSourceFile,
   DocCov,
   enrichSpec,
+  evaluatePolicies,
   findJSDocLocation,
   generateFixesForExport,
   generateReport,
@@ -196,8 +208,75 @@ import {
 import {
   DRIFT_CATEGORIES as DRIFT_CATEGORIES2
 } from "@openpkg-ts/spec";
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 
+// 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) {
@@ -899,19 +978,336 @@ function writeReports(options) {
   }));
   return results;
 }
-// src/utils/llm-assertion-parser.ts
+// src/utils/ai-client.ts
+import chalk2 from "chalk";
+
+// src/utils/ai-generate.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")
+var JSDocGenerationSchema = z2.object({
+  description: z2.string().describe("1-2 sentence description of what this does"),
+  params: z2.array(z2.object({
+    name: z2.string(),
+    type: z2.string().optional(),
+    description: z2.string()
+  })).optional().describe("Parameter descriptions for functions"),
+  returns: z2.object({
+    type: z2.string().optional(),
+    description: z2.string()
+  }).optional().describe("Return value description for functions"),
+  example: z2.string().optional().describe("Working code example showing typical usage"),
+  typeParams: z2.array(z2.object({
+    name: z2.string(),
+    description: z2.string()
+  })).optional().describe("Type parameter descriptions for generics")
+});
+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 isAIGenerationAvailable() {
+  return Boolean(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY);
+}
+function buildSignature(exp) {
+  if (exp.signatures && exp.signatures.length > 0) {
+    const sig = exp.signatures[0];
+    const params = sig.parameters?.map((p) => `${p.name}: ${p.type ?? "unknown"}`).join(", ") ?? "";
+    const ret = sig.returnType ?? "void";
+    return `(${params}) => ${ret}`;
+  }
+  if (exp.type) {
+    return typeof exp.type === "string" ? exp.type : JSON.stringify(exp.type);
+  }
+  return exp.kind;
+}
+function buildMembersContext(exp) {
+  if (!exp.members || exp.members.length === 0)
+    return "";
+  const memberLines = exp.members.slice(0, 10).map((m) => {
+    const type = m.type ? `: ${typeof m.type === "string" ? m.type : "object"}` : "";
+    return `  - ${m.name}${type}`;
+  });
+  if (exp.members.length > 10) {
+    memberLines.push(`  - ... and ${exp.members.length - 10} more members`);
+  }
+  return `
+
+Members:
+${memberLines.join(`
+`)}`;
+}
+async function generateJSDocForExport(exp) {
+  if (!isAIGenerationAvailable()) {
+    return null;
+  }
+  const signature = buildSignature(exp);
+  const membersContext = buildMembersContext(exp);
+  const prompt = `Generate JSDoc documentation for this TypeScript export.
+
+Name: ${exp.name}
+Kind: ${exp.kind}
+Signature: ${signature}${membersContext}
+
+Requirements:
+- Description: 1-2 sentences explaining what this does and when to use it
+- For functions: describe each parameter and return value
+- Example: provide a working code snippet showing typical usage
+- Be concise but informative
+
+The documentation should help developers understand the purpose and usage at a glance.`;
+  try {
+    const { object } = await generateObject({
+      model: getModel(),
+      schema: JSDocGenerationSchema,
+      prompt
+    });
+    return object;
+  } catch {
+    return null;
+  }
+}
+function toJSDocPatch(result) {
+  const patch = {};
+  if (result.description) {
+    patch.description = result.description;
+  }
+  if (result.params && result.params.length > 0) {
+    patch.params = result.params.map((p) => ({
+      name: p.name,
+      type: p.type,
+      description: p.description
+    }));
+  }
+  if (result.returns) {
+    patch.returns = {
+      type: result.returns.type,
+      description: result.returns.description
+    };
+  }
+  if (result.example) {
+    patch.examples = [result.example];
+  }
+  if (result.typeParams && result.typeParams.length > 0) {
+    patch.typeParams = result.typeParams.map((tp) => ({
+      name: tp.name,
+      description: tp.description
+    }));
+  }
+  return patch;
+}
+async function batchGenerateJSDocs(exports, options = {}) {
+  const results = [];
+  const { maxConcurrent = 3, onProgress } = options;
+  for (let i = 0;i < exports.length; i += maxConcurrent) {
+    const batch = exports.slice(i, i + maxConcurrent);
+    const promises = batch.map(async (exp) => {
+      const generated = await generateJSDocForExport(exp);
+      if (generated) {
+        onProgress?.(results.length + 1, exports.length, exp.name);
+        return {
+          exportName: exp.name,
+          patch: toJSDocPatch(generated),
+          generated: true
+        };
+      }
+      return {
+        exportName: exp.name,
+        patch: {},
+        generated: false
+      };
+    });
+    const batchResults = await Promise.all(promises);
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// src/utils/ai-client.ts
+var API_BASE = process.env.DOCCOV_API_URL || "https://api.doccov.com";
+function isHostedAPIAvailable() {
+  return Boolean(process.env.DOCCOV_API_KEY);
+}
+async function generateViaHostedAPI(exports, packageName) {
+  const apiKey = process.env.DOCCOV_API_KEY;
+  if (!apiKey) {
+    return { error: "No DOCCOV_API_KEY set" };
+  }
+  try {
+    const response = await fetch(`${API_BASE}/v1/ai/generate`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        exports: exports.map((exp) => ({
+          name: exp.name,
+          kind: exp.kind,
+          signature: buildSignature2(exp),
+          members: exp.members?.slice(0, 10).map((m) => ({
+            name: m.name,
+            type: typeof m.type === "string" ? m.type : undefined
+          }))
+        })),
+        packageName
+      })
+    });
+    if (response.status === 429) {
+      const data = await response.json();
+      return {
+        error: data.error || "Monthly AI limit reached",
+        quotaExceeded: true
+      };
+    }
+    if (!response.ok) {
+      const data = await response.json();
+      return { error: data.error || "API request failed" };
+    }
+    return await response.json();
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : "Network error" };
+  }
+}
+function buildSignature2(exp) {
+  if (exp.signatures && exp.signatures.length > 0) {
+    const sig = exp.signatures[0];
+    const params = sig.parameters?.map((p) => `${p.name}: ${p.type ?? "unknown"}`).join(", ") ?? "";
+    const ret = sig.returnType ?? "void";
+    return `(${params}) => ${ret}`;
+  }
+  if (exp.type) {
+    return typeof exp.type === "string" ? exp.type : JSON.stringify(exp.type);
+  }
+  return exp.kind;
+}
+async function generateWithFallback(exports, options = {}) {
+  const { log = console.log } = options;
+  if (isHostedAPIAvailable()) {
+    log(chalk2.dim("Using DocCov hosted AI..."));
+    const hostedResult = await generateViaHostedAPI(exports, options.packageName);
+    if ("error" in hostedResult) {
+      if (hostedResult.quotaExceeded) {
+        log(chalk2.yellow(`
+⚠ ${hostedResult.error}`));
+        log(chalk2.dim("Falling back to local API keys..."));
+        if (isAIGenerationAvailable()) {
+          return await generateViaBYOK(exports, options);
+        }
+        log(chalk2.red("No local API keys configured."));
+        log(chalk2.dim("Set OPENAI_API_KEY or ANTHROPIC_API_KEY for unlimited generation."));
+        return { results: [], source: "byok" };
+      }
+      log(chalk2.yellow(`
+⚠ Hosted API error: ${hostedResult.error}`));
+      log(chalk2.dim("Falling back to local API keys..."));
+    } else {
+      const results = hostedResult.results.map((r) => ({
+        exportName: r.name,
+        patch: r.patch ?? {},
+        generated: r.patch !== null
+      }));
+      return {
+        results,
+        source: "hosted",
+        quotaRemaining: hostedResult.quota.remaining,
+        quotaResetAt: hostedResult.quota.resetAt
+      };
+    }
+  }
+  if (isAIGenerationAvailable()) {
+    return await generateViaBYOK(exports, options);
+  }
+  log(chalk2.yellow(`
+⚠ No AI configuration available.`));
+  log(chalk2.dim("Options:"));
+  log(chalk2.dim("  1. Set DOCCOV_API_KEY for hosted AI (included with Team/Pro plan)"));
+  log(chalk2.dim("  2. Set OPENAI_API_KEY or ANTHROPIC_API_KEY for direct API access"));
+  return { results: [], source: "byok" };
+}
+async function generateViaBYOK(exports, options) {
+  const { log = console.log } = options;
+  log(chalk2.dim("Using local API keys (BYOK)..."));
+  const results = await batchGenerateJSDocs(exports, {
+    maxConcurrent: options.maxConcurrent ?? 3,
+    onProgress: options.onProgress
+  });
+  return {
+    results,
+    source: "byok"
+  };
+}
+
+// src/utils/filter-options.ts
+import { mergeFilters, parseListFlag } from "@doccov/sdk";
+import chalk3 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);
+    }
+  }
+  return result.length > 0 ? result : undefined;
+};
+var formatList = (label, values) => `${label}: ${values.map((value) => chalk3.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/llm-assertion-parser.ts
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { generateObject as generateObject2 } from "ai";
+import { z as z3 } from "zod";
+var AssertionParseSchema = z3.object({
+  assertions: z3.array(z3.object({
+    lineNumber: z3.number().describe("1-indexed line number where the assertion appears"),
+    expected: z3.string().describe("The expected output value"),
+    originalComment: z3.string().describe("The original comment text"),
+    suggestedSyntax: z3.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")
+  hasAssertions: z3.boolean().describe("Whether any assertion-like comments were found")
 });
 var ASSERTION_PARSE_PROMPT = (code) => `Analyze this TypeScript/JavaScript example code for assertion-like comments.
 
@@ -938,13 +1334,13 @@ Code:
 \`\`\`
 ${code}
 \`\`\``;
-function getModel() {
+function getModel2() {
   const provider = process.env.DOCCOV_LLM_PROVIDER?.toLowerCase();
   if (provider === "anthropic" || process.env.ANTHROPIC_API_KEY) {
-    const anthropic = createAnthropic();
+    const anthropic = createAnthropic2();
     return anthropic("claude-sonnet-4-20250514");
   }
-  const openai = createOpenAI();
+  const openai = createOpenAI2();
   return openai("gpt-4o-mini");
 }
 function isLLMAssertionParsingAvailable() {
@@ -955,8 +1351,8 @@ async function parseAssertionsWithLLM(code) {
     return null;
   }
   try {
-    const model = getModel();
-    const { object } = await generateObject({
+    const model = getModel2();
+    const { object } = await generateObject2({
       model,
       schema: AssertionParseSchema,
       prompt: ASSERTION_PARSE_PROMPT(code)
@@ -968,7 +1364,7 @@ async function parseAssertionsWithLLM(code) {
 }
 
 // src/utils/progress.ts
-import chalk2 from "chalk";
+import chalk4 from "chalk";
 class StepProgress {
   steps;
   currentStep = 0;
@@ -996,7 +1392,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(`${chalk4.green("✓")} ${message} ${chalk4.dim(`(${elapsed}s)`)}`);
     }
   }
   render() {
@@ -1004,17 +1400,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 = chalk4.dim(`[${this.currentStep + 1}/${this.steps.length}]`);
+    process.stdout.write(`\r${prefix} ${chalk4.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 = chalk4.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} ${chalk4.green("✓")} ${chalk4.dim(`(${elapsed}s)`)}`);
   }
 }
 
@@ -1058,7 +1454,7 @@ 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("--fix", "Auto-fix drift issues").option("--write", "Alias for --fix").option("--generate", "AI-generate missing JSDoc (requires --fix and API key)").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").option("--visibility <tags>", "Filter by release stage: public,beta,alpha,internal (comma-separated)").option("--owners", "Show coverage breakdown by CODEOWNERS").option("--contributors", "Show documentation contributors (git blame)").action(async (entry, options) => {
     try {
       const validations = parseExamplesFlag(options.examples);
       const hasExamples = validations.length > 0;
@@ -1085,6 +1481,15 @@ function registerCheckCommand(program, dependencies = {}) {
       const minCoverage = minCoverageRaw !== undefined ? clampPercentage(minCoverageRaw) : undefined;
       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(chalk5.dim(`Filtering by visibility: ${resolvedFilters.visibility.join(", ")}`));
+      }
       steps.next();
       const resolveExternalTypes = !options.skipResolve;
       let specResult;
@@ -1094,7 +1499,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.");
       }
@@ -1111,6 +1517,24 @@ function registerCheckCommand(program, dependencies = {}) {
           violations.push({ exportName: exp.name, violation: v });
         }
       }
+      let policyResult;
+      if (config?.policies && config.policies.length > 0) {
+        policyResult = evaluatePolicies(config.policies, spec, {
+          baseDir: targetDir
+        });
+      }
+      let ownershipResult;
+      if (options.owners) {
+        ownershipResult = analyzeSpecOwnership(spec, {
+          baseDir: targetDir
+        }) ?? undefined;
+      }
+      let contributorResult;
+      if (options.contributors) {
+        contributorResult = analyzeSpecContributors(spec, {
+          baseDir: targetDir
+        }) ?? undefined;
+      }
       let exampleResult;
       const typecheckErrors = [];
       const runtimeDrifts = [];
@@ -1156,12 +1580,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(chalk5.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
           } else {
             log("");
-            log(chalk3.bold(`Found ${fixable.length} fixable issue(s)`));
+            log(chalk5.bold(`Found ${fixable.length} fixable issue(s)`));
             if (nonFixable.length > 0) {
-              log(chalk3.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
+              log(chalk5.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
             }
             log("");
             const groupedDrifts = groupByExport(allDrifts.filter((d) => fixable.includes(d.drift)));
@@ -1169,22 +1593,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(chalk5.gray(`  Skipping ${exp.name}: no source location`));
                 continue;
               }
               if (exp.source.file.endsWith(".d.ts")) {
-                log(chalk3.gray(`  Skipping ${exp.name}: declaration file`));
+                log(chalk5.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(chalk5.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(chalk5.gray(`  Skipping ${exp.name}: could not find declaration`));
                 continue;
               }
               let existingPatch = {};
@@ -1217,26 +1641,26 @@ function registerCheckCommand(program, dependencies = {}) {
             }
             if (edits.length > 0) {
               if (options.dryRun) {
-                log(chalk3.bold("Dry run - changes that would be made:"));
+                log(chalk5.bold("Dry run - changes that would be made:"));
                 log("");
                 for (const [filePath, fileEdits] of editsByFile) {
                   const relativePath = path4.relative(targetDir, filePath);
-                  log(chalk3.cyan(`  ${relativePath}:`));
+                  log(chalk5.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}]`);
+                    log(`    ${chalk5.bold(exp.name)} [${lineInfo}]`);
                     for (const fix of fixes) {
-                      log(chalk3.green(`      + ${fix.description}`));
+                      log(chalk5.green(`      + ${fix.description}`));
                     }
                   }
                   log("");
                 }
-                log(chalk3.gray("Run without --dry-run to apply these changes."));
+                log(chalk5.gray("Run without --dry-run 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(chalk5.red(`  ${err.file}: ${err.error}`));
                   }
                 }
               }
@@ -1247,6 +1671,99 @@ function registerCheckCommand(program, dependencies = {}) {
           driftExports = driftExports.filter((d) => !fixedDriftKeys.has(`${d.name}:${d.issue}`));
         }
       }
+      const generatedExportKeys = new Set;
+      if (shouldFix && options.generate) {
+        const hasAIAccess = isHostedAPIAvailable() || isAIGenerationAvailable();
+        if (!hasAIAccess) {
+          log("");
+          log(chalk5.yellow("⚠ --generate requires AI access. Options:"));
+          log(chalk5.dim("  1. Set DOCCOV_API_KEY for hosted AI (included with Team/Pro plan)"));
+          log(chalk5.dim("  2. Set OPENAI_API_KEY or ANTHROPIC_API_KEY for direct API access"));
+        } else {
+          const undocumented = (spec.exports ?? []).filter((exp) => {
+            if (exp.description)
+              return false;
+            if (exp.source?.file?.endsWith(".d.ts"))
+              return false;
+            if (!exp.source?.file)
+              return false;
+            return true;
+          });
+          if (undocumented.length > 0) {
+            log("");
+            log(chalk5.bold(`Generating JSDoc for ${undocumented.length} undocumented export(s)`));
+            log("");
+            const aiResult = await generateWithFallback(undocumented, {
+              maxConcurrent: 3,
+              onProgress: (completed, total, name) => {
+                log(chalk5.dim(`  [${completed}/${total}] ${name}`));
+              },
+              log,
+              packageName: spec.meta?.name
+            });
+            const generated = aiResult.results;
+            const edits = [];
+            for (const result of generated) {
+              if (!result.generated)
+                continue;
+              const exp = undocumented.find((e) => e.name === result.exportName);
+              if (!exp || !exp.source?.file)
+                continue;
+              const filePath = path4.resolve(targetDir, exp.source.file);
+              if (!fs2.existsSync(filePath))
+                continue;
+              const sourceFile = createSourceFile(filePath);
+              const location = findJSDocLocation(sourceFile, exp.name, exp.source.line);
+              if (!location)
+                continue;
+              let existingPatch = {};
+              if (location.hasExisting && location.existingJSDoc) {
+                existingPatch = parseJSDocToPatch(location.existingJSDoc);
+              }
+              const mergedPatch = { ...existingPatch, ...result.patch };
+              const newJSDoc = serializeJSDoc(mergedPatch, location.indent);
+              edits.push({
+                filePath,
+                symbolName: exp.name,
+                startLine: location.startLine,
+                endLine: location.endLine,
+                hasExisting: location.hasExisting,
+                existingJSDoc: location.existingJSDoc,
+                newJSDoc,
+                indent: location.indent
+              });
+              generatedExportKeys.add(exp.name);
+            }
+            if (edits.length > 0) {
+              if (options.dryRun) {
+                log("");
+                log(chalk5.bold("Dry run - JSDoc that would be generated:"));
+                for (const edit of edits) {
+                  const relativePath = path4.relative(targetDir, edit.filePath);
+                  log(chalk5.cyan(`  ${relativePath}:`));
+                  log(`    ${chalk5.bold(edit.symbolName)} [line ${edit.startLine + 1}]`);
+                  log(chalk5.green("      + description, params, returns, example"));
+                }
+                log("");
+                log(chalk5.gray("Run without --dry-run to apply these changes."));
+              } else {
+                const applyResult = await applyEdits(edits);
+                log("");
+                log(chalk5.green(`✓ Generated JSDoc for ${edits.length} export(s)`));
+                if (aiResult.source === "hosted" && aiResult.quotaRemaining !== undefined) {
+                  const remaining = aiResult.quotaRemaining === "unlimited" ? "unlimited" : aiResult.quotaRemaining.toLocaleString();
+                  log(chalk5.dim(`  AI calls remaining: ${remaining}`));
+                }
+                if (applyResult.errors.length > 0) {
+                  for (const err of applyResult.errors) {
+                    error(chalk5.red(`  ${err.file}: ${err.error}`));
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
       steps.complete("Check complete");
       if (format !== "text") {
         const limit = parseInt(options.limit, 10) || 20;
@@ -1292,7 +1809,8 @@ function registerCheckCommand(program, dependencies = {}) {
         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) {
+        const policiesFailed2 = policyResult && !policyResult.allPassed;
+        if (coverageFailed2 || driftFailed2 || hasQualityErrors2 || hasTypecheckErrors2 || policiesFailed2) {
           process.exit(1);
         }
         return;
@@ -1304,18 +1822,19 @@ function registerCheckCommand(program, dependencies = {}) {
       const driftFailed = maxDrift !== undefined && driftScore > maxDrift;
       const hasQualityErrors = violations.filter((v) => v.violation.severity === "error").length > 0;
       const hasTypecheckErrors = typecheckErrors.length > 0;
+      const policiesFailed = policyResult && !policyResult.allPassed;
       if (specWarnings.length > 0 || specInfos.length > 0) {
         log("");
         for (const diag of specWarnings) {
-          log(chalk3.yellow(`⚠ ${diag.message}`));
+          log(chalk5.yellow(`⚠ ${diag.message}`));
           if (diag.suggestion) {
-            log(chalk3.gray(`  ${diag.suggestion}`));
+            log(chalk5.gray(`  ${diag.suggestion}`));
           }
         }
         for (const diag of specInfos) {
-          log(chalk3.cyan(`ℹ ${diag.message}`));
+          log(chalk5.cyan(`ℹ ${diag.message}`));
           if (diag.suggestion) {
-            log(chalk3.gray(`  ${diag.suggestion}`));
+            log(chalk5.gray(`  ${diag.suggestion}`));
           }
         }
       }
@@ -1325,23 +1844,23 @@ function registerCheckCommand(program, dependencies = {}) {
       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(chalk5.bold(`${pkgName}${pkgVersion ? `@${pkgVersion}` : ""}`));
       log("");
       log(`  Exports:    ${totalExports}`);
       if (minCoverage !== undefined) {
         if (coverageFailed) {
-          log(chalk3.red(`  Coverage:   ✗ ${coverageScore}%`) + chalk3.dim(` (min ${minCoverage}%)`));
+          log(chalk5.red(`  Coverage:   ✗ ${coverageScore}%`) + chalk5.dim(` (min ${minCoverage}%)`));
         } else {
-          log(chalk3.green(`  Coverage:   ✓ ${coverageScore}%`) + chalk3.dim(` (min ${minCoverage}%)`));
+          log(chalk5.green(`  Coverage:   ✓ ${coverageScore}%`) + chalk5.dim(` (min ${minCoverage}%)`));
         }
       } else {
         log(`  Coverage:   ${coverageScore}%`);
       }
       if (maxDrift !== undefined) {
         if (driftFailed) {
-          log(chalk3.red(`  Drift:      ✗ ${driftScore}%`) + chalk3.dim(` (max ${maxDrift}%)`));
+          log(chalk5.red(`  Drift:      ✗ ${driftScore}%`) + chalk5.dim(` (max ${maxDrift}%)`));
         } else {
-          log(chalk3.green(`  Drift:      ✓ ${driftScore}%`) + chalk3.dim(` (max ${maxDrift}%)`));
+          log(chalk5.green(`  Drift:      ✓ ${driftScore}%`) + chalk5.dim(` (max ${maxDrift}%)`));
         }
       } else {
         log(`  Drift:      ${driftScore}%`);
@@ -1351,7 +1870,7 @@ function registerCheckCommand(program, dependencies = {}) {
         if (typecheckCount > 0) {
           log(`  Examples:   ${typecheckCount} type errors`);
         } else {
-          log(chalk3.green(`  Examples:   ✓ validated`));
+          log(chalk5.green(`  Examples:   ✓ validated`));
         }
       }
       if (errorCount > 0 || warnCount > 0) {
@@ -1362,8 +1881,57 @@ function registerCheckCommand(program, dependencies = {}) {
           parts.push(`${warnCount} warnings`);
         log(`  Quality:    ${parts.join(", ")}`);
       }
+      if (policyResult && policyResult.results.length > 0) {
+        log("");
+        log(chalk5.bold("  Policies:"));
+        for (const result of policyResult.results) {
+          const status = result.passed ? chalk5.green("✓") : chalk5.red("✗");
+          const policyPath = result.policy.path;
+          const matchCount = result.matchedExports.length;
+          if (result.passed) {
+            log(`    ${status} ${policyPath} (${matchCount} exports)`);
+          } else {
+            log(`    ${status} ${policyPath} (${matchCount} exports)`);
+            for (const failure of result.failures) {
+              log(chalk5.red(`        ${failure.message}`));
+            }
+          }
+        }
+      }
+      if (ownershipResult) {
+        log("");
+        log(chalk5.bold("  Owners:"));
+        const sortedOwners = [...ownershipResult.byOwner.values()].sort((a, b) => a.coverageScore - b.coverageScore);
+        for (const stats of sortedOwners) {
+          const coverageColor = stats.coverageScore >= 80 ? chalk5.green : stats.coverageScore >= 50 ? chalk5.yellow : chalk5.red;
+          const coverageStr = coverageColor(`${stats.coverageScore}%`);
+          const undocCount = stats.undocumentedExports.length;
+          log(`    ${stats.owner.padEnd(24)} ${coverageStr.padStart(12)} coverage  (${stats.totalExports} exports${undocCount > 0 ? `, ${undocCount} undoc` : ""})`);
+        }
+        if (ownershipResult.unowned.length > 0) {
+          log(chalk5.dim(`    (${ownershipResult.unowned.length} exports have no owner in CODEOWNERS)`));
+        }
+      }
+      if (contributorResult) {
+        log("");
+        log(chalk5.bold("  Contributors:"));
+        const sortedContributors = [...contributorResult.byContributor.values()].sort((a, b) => b.documentedExports - a.documentedExports);
+        const displayLimit = 10;
+        const topContributors = sortedContributors.slice(0, displayLimit);
+        for (const stats of topContributors) {
+          const name = stats.name.length > 20 ? stats.name.slice(0, 17) + "..." : stats.name;
+          const lastDate = stats.lastContribution ? stats.lastContribution.toISOString().split("T")[0] : "unknown";
+          log(`    ${name.padEnd(22)} ${String(stats.documentedExports).padStart(4)} exports  (last: ${lastDate})`);
+        }
+        if (sortedContributors.length > displayLimit) {
+          log(chalk5.dim(`    ... and ${sortedContributors.length - displayLimit} more contributors`));
+        }
+        if (contributorResult.unattributed.length > 0) {
+          log(chalk5.dim(`    (${contributorResult.unattributed.length} exports could not be attributed via git blame)`));
+        }
+      }
       log("");
-      const failed = coverageFailed || driftFailed || hasQualityErrors || hasTypecheckErrors;
+      const failed = coverageFailed || driftFailed || hasQualityErrors || hasTypecheckErrors || policiesFailed;
       if (!failed) {
         const thresholdParts = [];
         if (minCoverage !== undefined) {
@@ -1372,25 +1940,31 @@ function registerCheckCommand(program, dependencies = {}) {
         if (maxDrift !== undefined) {
           thresholdParts.push(`drift ${driftScore}% ≤ ${maxDrift}%`);
         }
+        if (policyResult) {
+          thresholdParts.push(`${policyResult.passedCount}/${policyResult.totalPolicies} policies`);
+        }
         if (thresholdParts.length > 0) {
-          log(chalk3.green(`✓ Check passed (${thresholdParts.join(", ")})`));
+          log(chalk5.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(chalk5.green("✓ Check passed"));
+          log(chalk5.dim("  No thresholds configured. Use --min-coverage or --max-drift to enforce."));
         }
         return;
       }
       if (hasQualityErrors) {
-        log(chalk3.red(`✗ ${errorCount} quality errors`));
+        log(chalk5.red(`✗ ${errorCount} quality errors`));
       }
       if (hasTypecheckErrors) {
-        log(chalk3.red(`✗ ${typecheckErrors.length} example type errors`));
+        log(chalk5.red(`✗ ${typecheckErrors.length} example type errors`));
+      }
+      if (policiesFailed && policyResult) {
+        log(chalk5.red(`✗ ${policyResult.failedCount} policy failures`));
       }
       log("");
-      log(chalk3.dim("Use --format json or --format markdown for detailed reports"));
+      log(chalk5.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(chalk5.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
@@ -1427,35 +2001,36 @@ import {
   hashString,
   parseMarkdownFiles
 } from "@doccov/sdk";
-import chalk4 from "chalk";
+import { calculateNextVersion, recommendSemverBump } from "@openpkg-ts/spec";
+import chalk6 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")
+import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI3 } from "@ai-sdk/openai";
+import { generateObject as generateObject3, generateText } from "ai";
+import { z as z4 } from "zod";
+var CodeBlockUsageSchema = z4.object({
+  isImpacted: z4.boolean().describe("Whether the code block is affected by the change"),
+  reason: z4.string().describe("Explanation of why/why not the code is impacted"),
+  usageType: z4.enum(["direct-call", "import-only", "indirect", "not-used"]).describe("How the export is used in this code block"),
+  suggestedFix: z4.string().optional().describe("If impacted, the suggested code change"),
+  confidence: z4.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")
+var MultiBlockAnalysisSchema = z4.object({
+  groups: z4.array(z4.object({
+    blockIndices: z4.array(z4.number()).describe("Indices of blocks that should run together"),
+    reason: z4.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)")
+  skippedBlocks: z4.array(z4.number()).describe("Indices of blocks that should be skipped (incomplete/illustrative)")
 });
-function getModel2() {
+function getModel3() {
   const provider = process.env.DOCCOV_LLM_PROVIDER?.toLowerCase();
   if (provider === "anthropic" || process.env.ANTHROPIC_API_KEY) {
-    const anthropic = createAnthropic2();
+    const anthropic = createAnthropic3();
     return anthropic("claude-sonnet-4-20250514");
   }
-  const openai = createOpenAI2();
+  const openai = createOpenAI3();
   return openai("gpt-4o-mini");
 }
 function isAIDocsAnalysisAvailable() {
@@ -1470,7 +2045,7 @@ async function generateImpactSummary(impacts) {
   }
   try {
     const { text } = await generateText({
-      model: getModel2(),
+      model: getModel3(),
       prompt: `Summarize these documentation impacts for a GitHub PR comment.
 
 Impacts:
@@ -1515,7 +2090,7 @@ function registerDiffCommand(program, dependencies = {}) {
     ...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", collect, []).option("--ai", "Use AI for deeper analysis and fix suggestions").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;
@@ -1546,6 +2121,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(chalk6.bold("Semver Recommendation"));
+          log(`  Current version:    ${currentVersion}`);
+          log(`  Recommended:        ${chalk6.cyan(nextVersion)} (${chalk6.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);
@@ -1573,8 +2171,8 @@ function registerDiffCommand(program, dependencies = {}) {
                 silent: true
               });
             }
-            const cacheNote = fromCache ? chalk4.cyan(" (cached)") : "";
-            log(chalk4.dim(`Report: ${jsonPath}`) + cacheNote);
+            const cacheNote = fromCache ? chalk6.cyan(" (cached)") : "";
+            log(chalk6.dim(`Report: ${jsonPath}`) + cacheNote);
           }
           break;
         case "json": {
@@ -1635,6 +2233,28 @@ function registerDiffCommand(program, dependencies = {}) {
           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,18 +2262,18 @@ function registerDiffCommand(program, dependencies = {}) {
         checks
       });
       if (failures.length > 0) {
-        log(chalk4.red(`
+        log(chalk6.red(`
 ✗ Check failed`));
         for (const f of failures) {
-          log(chalk4.red(`  - ${f}`));
+          log(chalk6.red(`  - ${f}`));
         }
         process.exitCode = 1;
       } else if (options.strict || minCoverage !== undefined || maxDrift !== undefined) {
-        log(chalk4.green(`
+        log(chalk6.green(`
 ✓ All checks passed`));
       }
     } catch (commandError) {
-      error(chalk4.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk6.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     }
   });
@@ -1680,7 +2300,7 @@ 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(chalk6.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
     }
   }
   if (docsPatterns && docsPatterns.length > 0) {
@@ -1703,46 +2323,46 @@ 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 ? chalk6.cyan(" (cached)") : "";
+  log(chalk6.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 ? chalk6.green : diff.coverageDelta < 0 ? chalk6.red : chalk6.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 ? chalk6.red(` (${highSeverity} high severity)`) : "";
+    log(`  Breaking:   ${chalk6.red(breakingCount)} changes${severityNote}`);
   } else {
-    log(`  Breaking:   ${chalk4.green("0")} changes`);
+    log(`  Breaking:   ${chalk6.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 ? chalk6.yellow(` (${undocCount} undocumented)`) : "";
+    log(`  New:        ${chalk6.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(chalk6.red(`+${diff.driftIntroduced}`));
     if (diff.driftResolved > 0)
-      parts.push(chalk4.green(`-${diff.driftResolved}`));
+      parts.push(chalk6.green(`-${diff.driftResolved}`));
     log(`  Drift:      ${parts.join(", ")}`);
   }
   log("");
 }
 async function printAISummary(diff, log) {
   if (!isAIDocsAnalysisAvailable()) {
-    log(chalk4.yellow(`
+    log(chalk6.yellow(`
 ⚠ AI analysis unavailable (set OPENAI_API_KEY or ANTHROPIC_API_KEY)`));
     return;
   }
   if (!diff.docsImpact)
     return;
-  log(chalk4.gray(`
+  log(chalk6.gray(`
 Generating AI summary...`));
   const impacts = diff.docsImpact.impactedFiles.flatMap((f) => f.references.map((r) => ({
     file: f.file,
@@ -1753,8 +2373,8 @@ Generating AI summary...`));
   const summary = await generateImpactSummary(impacts);
   if (summary) {
     log("");
-    log(chalk4.bold("AI Summary"));
-    log(chalk4.cyan(`  ${summary}`));
+    log(chalk6.bold("AI Summary"));
+    log(chalk6.cyan(`  ${summary}`));
   }
 }
 function validateDiff(diff, headSpec, options) {
@@ -1835,7 +2455,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 chalk7 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 +2477,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(chalk7.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:    ${chalk7.bold(stats.totalExports.toString())}`);
+      console.log(`  Coverage:   ${chalk7.bold(`${stats.coverageScore}%`)}`);
+      console.log(`  Drift:      ${chalk7.bold(`${stats.driftScore}%`)}`);
       console.log("");
     } catch (err) {
-      console.error(chalk5.red("Error:"), err instanceof Error ? err.message : err);
+      console.error(chalk7.red("Error:"), err instanceof Error ? err.message : err);
       process.exit(1);
     }
   });
@@ -1873,7 +2493,7 @@ function registerInfoCommand(program) {
 // src/commands/init.ts
 import * as fs4 from "node:fs";
 import * as path6 from "node:path";
-import chalk6 from "chalk";
+import chalk8 from "chalk";
 var defaultDependencies3 = {
   fileExists: fs4.existsSync,
   writeFileSync: fs4.writeFileSync,
@@ -1890,31 +2510,31 @@ function registerInitCommand(program, dependencies = {}) {
     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.`));
+      error(chalk8.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(chalk8.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.'));
+      log(chalk8.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 outputPath = path6.join(cwd, fileName);
     if (fileExists2(outputPath)) {
-      error(chalk6.red(`Cannot create ${fileName}; file already exists.`));
+      error(chalk8.red(`Cannot create ${fileName}; file already exists.`));
       process.exitCode = 1;
       return;
     }
     const template = buildTemplate(targetFormat);
     writeFileSync3(outputPath, template, { encoding: "utf8" });
-    log(chalk6.green(`✓ Created ${path6.relative(process.cwd(), outputPath)}`));
+    log(chalk8.green(`✓ Created ${path6.relative(process.cwd(), outputPath)}`));
   });
 }
 var isValidFormat = (value) => {
@@ -2048,42 +2668,11 @@ quality:
 // 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";
+import chalk9 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.17.0";
 
 // src/commands/spec.ts
 var defaultDependencies4 = {
@@ -2098,7 +2687,7 @@ function getArrayLength(value) {
 function formatDiagnosticOutput(prefix, diagnostic, baseDir) {
   const location = diagnostic.location;
   const relativePath = location?.file ? path7.relative(baseDir, location.file) || location.file : undefined;
-  const locationText = location && relativePath ? chalk8.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
+  const locationText = location && relativePath ? chalk9.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
   const locationPrefix = locationText ? `${locationText} ` : "";
   return `${prefix} ${locationPrefix}${diagnostic.message}`;
 }
@@ -2107,7 +2696,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("--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" },
@@ -2129,13 +2718,14 @@ function registerSpecCommand(program, dependencies = {}) {
       try {
         config = await loadDocCovConfig(targetDir);
       } catch (configError) {
-        error(chalk8.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
+        error(chalk9.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
         process.exit(1);
       }
       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;
@@ -2155,10 +2745,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 };
@@ -2170,74 +2761,266 @@ function registerSpecCommand(program, dependencies = {}) {
       const normalized = normalize(result.spec);
       const validation = validateSpec(normalized);
       if (!validation.ok) {
-        error(chalk8.red("Spec failed schema validation"));
+        error(chalk9.red("Spec failed schema validation"));
         for (const err of validation.errors) {
-          error(chalk8.red(`schema: ${err.instancePath || "/"} ${err.message}`));
+          error(chalk9.red(`schema: ${err.instancePath || "/"} ${err.message}`));
         }
         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}`);
-      log(chalk8.gray(`  ${getArrayLength(normalized.exports)} exports`));
-      log(chalk8.gray(`  ${getArrayLength(normalized.types)} types`));
+      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(chalk9.gray(`  ${getArrayLength(normalized.exports)} exports`));
+      log(chalk9.gray(`  ${getArrayLength(normalized.types)} types`));
       if (options.verbose && normalized.generation) {
         const gen = normalized.generation;
         log("");
-        log(chalk8.bold("Generation Info"));
-        log(chalk8.gray(`  Timestamp:        ${gen.timestamp}`));
-        log(chalk8.gray(`  Generator:        ${gen.generator.name}@${gen.generator.version}`));
-        log(chalk8.gray(`  Entry point:      ${gen.analysis.entryPoint}`));
-        log(chalk8.gray(`  Detected via:     ${gen.analysis.entryPointSource}`));
-        log(chalk8.gray(`  Declaration only: ${gen.analysis.isDeclarationOnly ? "yes" : "no"}`));
-        log(chalk8.gray(`  External types:   ${gen.analysis.resolvedExternalTypes ? "resolved" : "skipped"}`));
+        log(chalk9.bold("Generation Info"));
+        log(chalk9.gray(`  Timestamp:        ${gen.timestamp}`));
+        log(chalk9.gray(`  Generator:        ${gen.generator.name}@${gen.generator.version}`));
+        log(chalk9.gray(`  Entry point:      ${gen.analysis.entryPoint}`));
+        log(chalk9.gray(`  Detected via:     ${gen.analysis.entryPointSource}`));
+        log(chalk9.gray(`  Declaration only: ${gen.analysis.isDeclarationOnly ? "yes" : "no"}`));
+        log(chalk9.gray(`  External types:   ${gen.analysis.resolvedExternalTypes ? "resolved" : "skipped"}`));
         if (gen.analysis.maxTypeDepth) {
-          log(chalk8.gray(`  Max type depth:   ${gen.analysis.maxTypeDepth}`));
+          log(chalk9.gray(`  Max type depth:   ${gen.analysis.maxTypeDepth}`));
         }
         log("");
-        log(chalk8.bold("Environment"));
-        log(chalk8.gray(`  node_modules:     ${gen.environment.hasNodeModules ? "found" : "not found"}`));
+        log(chalk9.bold("Environment"));
+        log(chalk9.gray(`  node_modules:     ${gen.environment.hasNodeModules ? "found" : "not found"}`));
         if (gen.environment.packageManager) {
-          log(chalk8.gray(`  Package manager:  ${gen.environment.packageManager}`));
+          log(chalk9.gray(`  Package manager:  ${gen.environment.packageManager}`));
         }
         if (gen.environment.isMonorepo) {
-          log(chalk8.gray(`  Monorepo:         yes`));
+          log(chalk9.gray(`  Monorepo:         yes`));
         }
         if (gen.environment.targetPackage) {
-          log(chalk8.gray(`  Target package:   ${gen.environment.targetPackage}`));
+          log(chalk9.gray(`  Target package:   ${gen.environment.targetPackage}`));
         }
         if (gen.issues.length > 0) {
           log("");
-          log(chalk8.bold("Issues"));
+          log(chalk9.bold("Issues"));
           for (const issue of gen.issues) {
-            const prefix = issue.severity === "error" ? chalk8.red(">") : issue.severity === "warning" ? chalk8.yellow(">") : chalk8.cyan(">");
+            const prefix = issue.severity === "error" ? chalk9.red(">") : issue.severity === "warning" ? chalk9.yellow(">") : chalk9.cyan(">");
             log(`${prefix} [${issue.code}] ${issue.message}`);
             if (issue.suggestion) {
-              log(chalk8.gray(`    ${issue.suggestion}`));
+              log(chalk9.gray(`    ${issue.suggestion}`));
             }
           }
         }
       }
       if (options.showDiagnostics && result.diagnostics.length > 0) {
         log("");
-        log(chalk8.bold("Diagnostics"));
+        log(chalk9.bold("Diagnostics"));
         for (const diagnostic of result.diagnostics) {
-          const prefix = diagnostic.severity === "error" ? chalk8.red(">") : diagnostic.severity === "warning" ? chalk8.yellow(">") : chalk8.cyan(">");
+          const prefix = diagnostic.severity === "error" ? chalk9.red(">") : diagnostic.severity === "warning" ? chalk9.yellow(">") : chalk9.cyan(">");
           log(formatDiagnosticOutput(prefix, diagnostic, targetDir));
         }
       }
     } catch (commandError) {
-      error(chalk8.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk9.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
 }
 
+// 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 chalk10 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 chalk10.green;
+  if (score >= 70)
+    return chalk10.yellow;
+  if (score >= 50)
+    return chalk10.hex("#FFA500");
+  return chalk10.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 ? chalk10.gray(` (${snapshot.commit.slice(0, 7)})`) : "";
+  return `${chalk10.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 chalk10.green(`+${velocity}%/day`);
+  if (velocity < 0)
+    return chalk10.red(`${velocity}%/day`);
+  return chalk10.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(chalk10.green(`Pruned ${deleted} old snapshots, kept ${keepCount} most recent`));
+      } else {
+        const deleted = pruneByTier(cwd, tier);
+        console.log(chalk10.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(chalk10.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(chalk10.green("Recorded coverage snapshot:"));
+        console.log(formatSnapshot(trend.current));
+        if (trend.delta !== undefined) {
+          const deltaStr = formatDelta2(trend.delta);
+          const deltaColor = trend.delta > 0 ? chalk10.green : trend.delta < 0 ? chalk10.red : chalk10.gray;
+          console.log(chalk10.gray("Change from previous:"), deltaColor(deltaStr));
+        }
+        return;
+      } catch (error) {
+        console.error(chalk10.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(chalk10.yellow("No coverage history found."));
+      console.log(chalk10.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(chalk10.bold("Coverage Trends"));
+    console.log(chalk10.gray(`Package: ${snapshots[0].package}`));
+    console.log(chalk10.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 ? chalk10.green : overallDelta < 0 ? chalk10.red : chalk10.gray;
+      console.log(chalk10.gray("Overall trend:"), deltaColor(deltaStr), chalk10.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(chalk10.bold("Extended Analysis"));
+          console.log(chalk10.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 ? chalk10.green : chalk10.red;
+          console.log(`  Projected (30d): ${projColor(`${extended.projected30d}%`)}`);
+          console.log(`  All-time high:   ${chalk10.green(`${extended.allTimeHigh}%`)}`);
+          console.log(`  All-time low:    ${chalk10.red(`${extended.allTimeLow}%`)}`);
+          if (extended.dataRange) {
+            const startDate = formatWeekDate(extended.dataRange.start);
+            const endDate = formatWeekDate(extended.dataRange.end);
+            console.log(chalk10.gray(`  Data range: ${startDate} - ${endDate}`));
+          }
+          console.log("");
+          if (options.weekly && extended.weeklySummaries.length > 0) {
+            console.log(chalk10.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 ? chalk10.green : week.delta < 0 ? chalk10.red : chalk10.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(chalk10.gray(`  ... and ${extended.weeklySummaries.length - weekLimit} more weeks`));
+            }
+            console.log("");
+          }
+        } catch {
+          console.log(chalk10.yellow("Could not load openpkg.json for extended analysis"));
+          console.log("");
+        }
+      }
+    }
+    console.log(chalk10.bold("History"));
+    const displaySnapshots = snapshots.slice(0, limit);
+    for (let i = 0;i < displaySnapshots.length; i++) {
+      const snapshot = displaySnapshots[i];
+      const prefix = i === 0 ? chalk10.cyan("→") : " ";
+      console.log(`${prefix} ${formatSnapshot(snapshot)}`);
+    }
+    if (snapshots.length > limit) {
+      console.log(chalk10.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(readFileSync4(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 +3028,7 @@ registerInfoCommand(program);
 registerSpecCommand(program);
 registerDiffCommand(program);
 registerInitCommand(program);
+registerTrendsCommand(program);
 program.command("*", { hidden: true }).action(() => {
   program.outputHelp();
 });