@doccov/cli 0.30.6 → 0.31.0

package/README.md

@@ -37,12 +37,42 @@ doccov info src/index.ts
 Analyze documentation coverage against thresholds.
 
 ```bash
-doccov check src/index.ts --min-coverage 80
+doccov check src/index.ts --min-health 80
 doccov check --format json -o report.json
 doccov check --examples typecheck    # Validate @example blocks
 doccov check --fix                   # Auto-fix drift issues
 ```
 
+#### Monorepo / Batch Mode
+
+Analyze multiple packages at once using glob patterns or multiple targets:
+
+```bash
+# Glob pattern - analyze all packages
+doccov check "packages/*/src/index.ts"
+
+# Multiple explicit targets
+doccov check packages/server/src/index.ts packages/client/src/index.ts
+
+# With options
+doccov check "packages/*/src/index.ts" --format markdown --min-health 60
+```
+
+Output shows per-package breakdown with aggregated totals:
+
+```
+Documentation Coverage Report (3 packages)
+
+| Package | Health | Exports | Drift |
+|---------|--------|---------|-------|
+| @pkg/server | 75% | 78 | 4 |
+| @pkg/client | 82% | 45 | 2 |
+| @pkg/core | 90% | 32 | 1 |
+| Total | 81% | 155 | 7 |
+
+✓ Check passed (health 81% >= 80%)
+```
+
 ### spec
 
 Generate specification files.
@@ -87,17 +117,58 @@ doccov trends --extended             # Show velocity/projections
 
 ## Configuration
 
-Create `doccov.config.yaml` or use `doccov init`:
+Create `doccov.config.ts` or use `doccov init`:
+
+```ts
+// doccov.config.ts
+import { defineConfig } from '@doccov/cli';
+
+export default defineConfig({
+  check: {
+    minHealth: 80,
+    examples: ['presence', 'typecheck'],
+
+    // Documentation style presets
+    style: 'minimal',  // 'minimal' | 'verbose' | 'types-only'
+
+    // Fine-grained requirements (override preset)
+    require: {
+      description: true,
+      params: false,
+      returns: false,
+      examples: false,
+    },
+  },
+  docs: {
+    include: ['docs/**/*.md'],
+  },
+});
+```
+
+### Style Presets
+
+Different projects have different documentation standards. Use `style` to choose a preset:
+
+| Preset | description | params | returns | examples |
+|--------|-------------|--------|---------|----------|
+| `minimal` | required | optional | optional | optional |
+| `verbose` | required | required | required | optional |
+| `types-only` | optional | optional | optional | optional |
+
+- **minimal** (default): Only requires description. Good for projects relying on TypeScript types.
+- **verbose**: Requires description, @param, and @returns. For comprehensive API documentation.
+- **types-only**: No requirements. Score is 100% if exports exist. For TypeScript-first projects.
 
-```yaml
-check:
-  minCoverage: 80
-  maxDrift: 10
-  examples: [presence, typecheck]
+Use `require` to override individual rules from the preset:
 
-docs:
-  include:
-    - "docs/**/*.md"
+```ts
+// Start with minimal, but also require examples
+{
+  style: 'minimal',
+  require: {
+    examples: true,
+  }
+}
 ```
 
 ## Output Formats

package/dist/cli.js

@@ -75,19 +75,25 @@ ${formatIssues(issues)}`);
 var defineConfig = (config) => config;
 // src/cli.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
 // src/commands/check/index.ts
+import * as path8 from "node:path";
 import {
+  aggregateResults,
   buildDocCovSpec,
+  createPackageResult,
   DocCov,
+  findEntryPointForFile,
+  IncrementalAnalyzer,
   NodeFileSystem,
   parseExamplesFlag,
   resolveTarget
 } from "@doccov/sdk";
-import chalk6 from "chalk";
+import chalk7 from "chalk";
+import { glob as glob2 } from "glob";
 
 // src/utils/filter-options.ts
 import { mergeFilters, parseListFlag } from "@doccov/sdk";
@@ -1060,6 +1066,37 @@ function renderDiffHtml(data, options = {}) {
 </body>
 </html>`;
 }
+// src/reports/json.ts
+function formatCIJson(report, options = {}) {
+  const minHealth = options.minHealth ?? 0;
+  const health = report.health?.score ?? report.coverage.score;
+  const healthPassed = health >= minHealth;
+  const hasTypecheckErrors = options.hasTypecheckErrors ?? false;
+  const hasRuntimeErrors = options.hasRuntimeErrors ?? false;
+  const hasStaleRefs = options.hasStaleRefs ?? false;
+  const success = healthPassed && !hasTypecheckErrors && !hasRuntimeErrors && !hasStaleRefs;
+  return {
+    success,
+    health,
+    thresholds: {
+      health: {
+        min: minHealth,
+        actual: health,
+        passed: healthPassed
+      }
+    },
+    drift: {
+      total: report.coverage.driftCount,
+      fixable: report.coverage.driftSummary?.fixable ?? 0
+    },
+    exports: {
+      total: report.coverage.totalExports,
+      documented: report.coverage.documentedExports
+    },
+    exitCode: success ? 0 : 1,
+    report
+  };
+}
 // src/reports/markdown.ts
 import { DRIFT_CATEGORY_LABELS } from "@doccov/sdk";
 function bar2(pct, width = 10) {
@@ -1178,18 +1215,18 @@ function renderMarkdown(stats, options = {}) {
         continue;
       lines.push(`### ${DRIFT_CATEGORY_LABELS[category]}`);
       lines.push("");
-      lines.push("| Export | Issue |");
-      lines.push("|--------|-------|");
+      lines.push("| Export | Issue | Expected | Actual |");
+      lines.push("|--------|-------|----------|--------|");
       for (const d of issues.slice(0, Math.min(limit, 10))) {
         const hint = d.suggestion ? ` → ${d.suggestion}` : "";
-        lines.push(`| \`${d.exportName}\` | ${d.issue}${hint} |`);
+        lines.push(`| \`${d.exportName}\` | ${d.issue}${hint} | ${d.expected ?? "-"} | ${d.actual ?? "-"} |`);
       }
       if (issues.length > 10) {
         const moreText = `${issues.length - 10} more ${category} issues`;
         if (reportUrl) {
-          lines.push(`| [${moreText} →](${reportUrl}#drift-${category}) | |`);
+          lines.push(`| [${moreText} →](${reportUrl}#drift-${category}) | | | |`);
         } else {
-          lines.push(`| ... | ${moreText} |`);
+          lines.push(`| ... | ${moreText} | | |`);
         }
       }
       lines.push("");
@@ -1244,6 +1281,38 @@ function renderMarkdown(stats, options = {}) {
   return lines.join(`
 `);
 }
+function renderBatchMarkdown(batchResult, options = {}) {
+  const { packages, aggregate } = batchResult;
+  const lines = [];
+  lines.push("# Documentation Coverage Report");
+  lines.push("");
+  lines.push(`## Summary (${packages.length} packages)`);
+  lines.push("");
+  lines.push("| Package | Health | Exports | Drift |");
+  lines.push("|---------|--------|---------|-------|");
+  for (const pkg of packages) {
+    lines.push(`| ${pkg.name} | ${pkg.health}% | ${pkg.totalExports} | ${pkg.driftCount} |`);
+  }
+  lines.push(`| **Total** | **${aggregate.health}%** | **${aggregate.totalExports}** | **${aggregate.driftCount}** |`);
+  lines.push("");
+  for (const pkg of packages) {
+    lines.push(`## ${pkg.name}`);
+    lines.push("");
+    lines.push(`**Health: ${pkg.health}%** \`${bar2(pkg.health)}\``);
+    lines.push("");
+    lines.push("| Metric | Value |");
+    lines.push("|--------|-------|");
+    lines.push(`| Exports | ${pkg.totalExports} |`);
+    lines.push(`| Documented | ${pkg.documented} |`);
+    lines.push(`| Coverage | ${pkg.coverageScore}% |`);
+    lines.push(`| Drift | ${pkg.driftCount} |`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("*Generated by [DocCov](https://doccov.com)*");
+  return lines.join(`
+`);
+}
 // src/reports/stats.ts
 import { getExportAnalysis, getExportDrift as getExportDrift2, isFixableDrift } from "@doccov/sdk";
 import {
@@ -1291,6 +1360,8 @@ function computeStats(openpkg, doccov, options = {}) {
         exportName: exp.name,
         type: d.type,
         issue: d.issue,
+        expected: d.expected,
+        actual: d.actual,
         suggestion: d.suggestion
       };
       driftIssues.push(item);
@@ -1632,8 +1703,16 @@ function handleNonTextOutput(options, deps) {
   const stats = computeStats(openpkg, doccov, { staleRefs });
   const report = generateReportFromDocCov(openpkg, doccov);
   const extendedReport = staleRefs.length > 0 ? { ...report, staleRefs } : report;
-  const jsonContent = JSON.stringify(extendedReport, null, 2);
-  const healthScore = doccov.summary.health?.score ?? stats.coverageScore;
+  const hasTypecheckErrors = typecheckErrors.length > 0;
+  const hasRuntimeErrors = runtimeErrors > 0;
+  const hasStaleRefs = staleRefs.length > 0;
+  const ciReport = formatCIJson(extendedReport, {
+    minHealth,
+    hasTypecheckErrors,
+    hasRuntimeErrors,
+    hasStaleRefs
+  });
+  const jsonContent = JSON.stringify(ciReport, null, 2);
   let formatContent;
   switch (format) {
     case "json":
@@ -1656,13 +1735,9 @@ function handleNonTextOutput(options, deps) {
       cwd
     });
   }
-  const healthFailed = healthScore < minHealth;
   const apiSurfaceScore = doccov.apiSurface?.completeness ?? 100;
   const apiSurfaceFailed = minApiSurface !== undefined && apiSurfaceScore < minApiSurface;
-  const hasTypecheckErrors = typecheckErrors.length > 0;
-  const hasRuntimeErrors = runtimeErrors > 0;
-  const hasStaleRefs = staleRefs.length > 0;
-  return !(healthFailed || apiSurfaceFailed || hasTypecheckErrors || hasRuntimeErrors || hasStaleRefs);
+  return ciReport.success && !apiSurfaceFailed;
 }
 function displayApiSurfaceOutput(doccov, deps) {
   const { log } = deps;
@@ -1710,6 +1785,100 @@ function displayApiSurfaceOutput(doccov, deps) {
     log(colors.success(`${sym.success} All referenced types are exported`));
   }
 }
+function displayBatchTextOutput(options, deps) {
+  const { batchResult, minHealth, verbose } = options;
+  const { log } = deps;
+  const { packages, aggregate } = batchResult;
+  const sym = getSymbols(supportsUnicode());
+  log("");
+  log(colors.bold(`Documentation Coverage Report (${packages.length} packages)`));
+  log("");
+  log("| Package | Health | Exports | Drift |");
+  log("|---------|--------|---------|-------|");
+  for (const pkg of packages) {
+    const healthColor = pkg.health >= 80 ? colors.success : pkg.health >= 60 ? colors.warning : colors.error;
+    log(`| ${pkg.name} | ${healthColor(`${pkg.health}%`)} | ${pkg.totalExports} | ${pkg.driftCount} |`);
+  }
+  const totalHealthColor = aggregate.health >= 80 ? colors.success : aggregate.health >= 60 ? colors.warning : colors.error;
+  log(`| ${colors.bold("Total")} | ${totalHealthColor(colors.bold(`${aggregate.health}%`))} | ${colors.bold(String(aggregate.totalExports))} | ${colors.bold(String(aggregate.driftCount))} |`);
+  log("");
+  const passed = aggregate.health >= minHealth;
+  if (passed) {
+    log(colors.success(`${sym.success} Check passed (health ${aggregate.health}% >= ${minHealth}%)`));
+  } else {
+    log(colors.error(`${sym.error} Health ${aggregate.health}% below minimum ${minHealth}%`));
+  }
+  if (verbose) {
+    log("");
+    for (const pkg of packages) {
+      const health = pkg.doccov.summary.health;
+      if (health) {
+        log(colors.bold(`${pkg.name}:`));
+        displayHealthVerbose(health, log);
+        log("");
+      }
+    }
+  }
+  return passed;
+}
+function handleBatchNonTextOutput(options, deps) {
+  const { format, batchResult, minHealth, limit, stdout, outputPath, cwd } = options;
+  const { log } = deps;
+  const healthPassed = batchResult.aggregate.health >= minHealth;
+  const ciBatchReport = {
+    success: healthPassed,
+    health: batchResult.aggregate.health,
+    thresholds: {
+      health: {
+        min: minHealth,
+        actual: batchResult.aggregate.health,
+        passed: healthPassed
+      }
+    },
+    drift: {
+      total: batchResult.aggregate.driftCount
+    },
+    exports: {
+      total: batchResult.aggregate.totalExports,
+      documented: batchResult.aggregate.documented
+    },
+    exitCode: healthPassed ? 0 : 1,
+    packages: batchResult.packages.map((p) => ({
+      name: p.name,
+      version: p.version,
+      entryPath: p.entryPath,
+      totalExports: p.totalExports,
+      documented: p.documented,
+      health: p.health,
+      driftCount: p.driftCount,
+      coverageScore: p.coverageScore
+    })),
+    aggregate: batchResult.aggregate
+  };
+  let formatContent;
+  switch (format) {
+    case "json":
+      formatContent = JSON.stringify(ciBatchReport, null, 2);
+      break;
+    case "markdown":
+      formatContent = renderBatchMarkdown(batchResult, { limit });
+      break;
+    default:
+      throw new Error(`Unknown format: ${format}`);
+  }
+  if (stdout) {
+    log(formatContent);
+  } else {
+    writeReports({
+      format,
+      formatContent,
+      jsonContent: JSON.stringify(ciBatchReport, null, 2),
+      outputPath,
+      cwd
+    });
+  }
+  return healthPassed;
+}
 
 // src/commands/check/validation.ts
 import { validateExamples } from "@doccov/sdk";
@@ -3718,6 +3887,48 @@ async function validateMarkdownDocs(options) {
   return staleRefs;
 }
 
+// src/utils/signal-handler.ts
+import chalk6 from "chalk";
+var state = {
+  handlers: [],
+  registered: false
+};
+function registerSignalHandlers() {
+  if (state.registered)
+    return;
+  const handler = (signal) => {
+    console.error(chalk6.yellow(`
+⚠️  Received ${signal}, shutting down...`));
+    if (state.incrementalAnalyzer && state.onPartialResults) {
+      try {
+        const partial = state.incrementalAnalyzer.getPartialResultsSync();
+        if (partial.results.length > 0) {
+          console.error(chalk6.yellow(`
+Partial results available: ${partial.results.length} exports analyzed`));
+          state.onPartialResults(partial);
+        }
+      } catch {}
+    }
+    for (const h of state.handlers) {
+      try {
+        h();
+      } catch {}
+    }
+    process.exit(1);
+  };
+  process.on("SIGINT", () => handler("SIGINT"));
+  process.on("SIGTERM", () => handler("SIGTERM"));
+  state.registered = true;
+}
+function setIncrementalAnalyzer(analyzer, onPartialResults) {
+  state.incrementalAnalyzer = analyzer;
+  state.onPartialResults = onPartialResults;
+}
+function clearIncrementalAnalyzer() {
+  state.incrementalAnalyzer = undefined;
+  state.onPartialResults = undefined;
+}
+
 // src/commands/check/index.ts
 var defaultDependencies = {
   createDocCov: (options) => new DocCov(options),
@@ -3729,16 +3940,24 @@ 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-health <percentage>", "Minimum health score (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("--preview", "Preview fixes with diff output (implies --fix)").option("--format <format>", "Output format: text, json, markdown", "text").option("-o, --output <file>", "Custom output path (overrides default .doccov/ path)").option("--stdout", "Output to stdout instead of writing to .doccov/").option("--limit <n>", "Max exports to show in report tables", "20").option("--max-type-depth <number>", "Maximum depth for type conversion (default: 20)", (value) => {
+  program.command("check [targets...]").description("Check documentation coverage and output reports").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--min-health <percentage>", "Minimum health score (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("--preview", "Preview fixes with diff output (implies --fix)").option("--format <format>", "Output format: text, json, markdown", "text").option("-o, --output <file>", "Custom output path (overrides default .doccov/ path)").option("--stdout", "Output to stdout instead of writing to .doccov/").option("--limit <n>", "Max exports to show in report tables", "20").option("--max-type-depth <number>", "Maximum depth for type conversion (default: 20)", (value) => {
     const n = parseInt(value, 10);
     if (Number.isNaN(n) || n < 1)
       throw new Error("--max-type-depth must be a positive integer");
     return n;
-  }).option("--no-cache", "Bypass spec cache and force regeneration").option("--visibility <tags>", "Filter by release stage: public,beta,alpha,internal (comma-separated)").option("--api-surface", "Show only API surface / forgotten exports info").option("-v, --verbose", "Show detailed output including forgotten exports").action(async (entry, options) => {
+  }).option("--no-cache", "Bypass spec cache and force regeneration").option("--visibility <tags>", "Filter by release stage: public,beta,alpha,internal (comma-separated)").option("--api-surface", "Show only API surface / forgotten exports info").option("-v, --verbose", "Show detailed output including forgotten exports").action(async (targets, options) => {
+    registerSignalHandlers();
     try {
       const spin = spinner("Analyzing...");
+      const resolvedTargets = await expandGlobTargets(targets, options.cwd);
+      const isBatchMode = resolvedTargets.length > 1;
       let validations = parseExamplesFlag(options.examples);
       let hasExamples = validations.length > 0;
+      if (isBatchMode) {
+        await runBatchAnalysis(resolvedTargets, options, { createDocCov, log, error, spin });
+        return;
+      }
+      const entry = resolvedTargets[0];
       const fileSystem = new NodeFileSystem(options.cwd);
       const resolved = await resolveTarget(fileSystem, {
         cwd: options.cwd,
@@ -3771,7 +3990,7 @@ function registerCheckCommand(program, dependencies = {}) {
       };
       const resolvedFilters = mergeFilterOptions(config, cliFilters);
       if (resolvedFilters.visibility) {
-        log(chalk6.dim(`Filtering by visibility: ${resolvedFilters.visibility.join(", ")}`));
+        log(chalk7.dim(`Filtering by visibility: ${resolvedFilters.visibility.join(", ")}`));
       }
       const resolveExternalTypes = !options.skipResolve;
       const analyzer = createDocCov({
@@ -3787,13 +4006,51 @@ function registerCheckCommand(program, dependencies = {}) {
         throw new Error("Failed to analyze documentation coverage.");
       }
       const openpkg = specResult.spec;
-      const doccov = buildDocCovSpec({
+      spin.update("Building coverage spec...");
+      let entryExportNames;
+      const entryResult = await findEntryPointForFile(fileSystem, entryFile);
+      if (entryResult) {
+        const pkgEntryPath = path8.resolve(entryResult.packagePath, entryResult.entryPoint.path);
+        const isSubFile = path8.resolve(entryFile) !== pkgEntryPath;
+        if (isSubFile) {
+          const entryAnalyzer = createDocCov({
+            resolveExternalTypes: false,
+            useCache: options.cache !== false,
+            cwd: entryResult.packagePath
+          });
+          const entrySpec = await entryAnalyzer.analyzeFileWithDiagnostics(pkgEntryPath);
+          if (entrySpec?.spec?.exports) {
+            entryExportNames = entrySpec.spec.exports.map((e) => e.name);
+          }
+        }
+      }
+      const incrementalAnalyzer = new IncrementalAnalyzer;
+      setIncrementalAnalyzer(incrementalAnalyzer, (partial) => {
+        log(chalk7.yellow(`
+⚠️  Partial results (${partial.results.length} exports):`));
+        for (const r of partial.results.slice(-5)) {
+          log(chalk7.dim(`  - ${r.name}: ${r.coverageScore}%`));
+        }
+        if (partial.results.length > 5) {
+          log(chalk7.dim(`  ... and ${partial.results.length - 5} more`));
+        }
+      });
+      const doccov = await buildDocCovSpec({
         openpkg,
         openpkgPath: entryFile,
         packagePath: targetDir,
         forgottenExports: specResult.forgottenExports,
-        apiSurfaceIgnore
+        apiSurfaceIgnore,
+        entryExportNames,
+        onProgress: (current, total, item) => {
+          spin.setDetail(`${current}/${total}: ${item}`);
+        },
+        onExportAnalyzed: async (id, name, analysis) => {
+          await incrementalAnalyzer.writeExportAnalysis(id, name, analysis);
+        }
       });
+      clearIncrementalAnalyzer();
+      await incrementalAnalyzer.cleanup();
       const format = options.format ?? "text";
       const specWarnings = specResult.diagnostics.filter((d) => d.severity === "warning");
       const specInfos = specResult.diagnostics.filter((d) => d.severity === "info" && !d.code?.startsWith("EXTERNAL_TYPE"));
@@ -3879,14 +4136,103 @@ function registerCheckCommand(program, dependencies = {}) {
         process.exit(1);
       }
     } catch (commandError) {
-      error(chalk6.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk7.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
 }
+async function expandGlobTargets(targets, cwd) {
+  if (targets.length === 0) {
+    return [];
+  }
+  const expanded = [];
+  for (const target of targets) {
+    if (target.includes("*")) {
+      const matches = await glob2(target, { cwd, nodir: true });
+      expanded.push(...matches.map((m) => path8.resolve(cwd, m)));
+    } else {
+      expanded.push(path8.resolve(cwd, target));
+    }
+  }
+  return expanded;
+}
+async function runBatchAnalysis(targets, options, deps) {
+  const { createDocCov, log, error, spin } = deps;
+  const fileSystem = new NodeFileSystem(options.cwd);
+  const packageResults = [];
+  for (let i = 0;i < targets.length; i++) {
+    const target = targets[i];
+    spin.update(`Analyzing ${i + 1}/${targets.length}: ${path8.basename(target)}...`);
+    try {
+      const resolved = await resolveTarget(fileSystem, {
+        cwd: options.cwd,
+        entry: target
+      });
+      const { targetDir, entryFile } = resolved;
+      const config2 = await loadDocCovConfig(targetDir);
+      const resolveExternalTypes = !options.skipResolve;
+      const analyzer = createDocCov({
+        resolveExternalTypes,
+        maxDepth: options.maxTypeDepth,
+        useCache: options.cache !== false,
+        cwd: targetDir
+      });
+      const specResult = await analyzer.analyzeFileWithDiagnostics(entryFile);
+      if (!specResult) {
+        log(chalk7.yellow(`  Skipping ${target}: analysis failed`));
+        continue;
+      }
+      const openpkg = specResult.spec;
+      const doccov = await buildDocCovSpec({
+        openpkg,
+        openpkgPath: entryFile,
+        packagePath: targetDir,
+        forgottenExports: specResult.forgottenExports
+      });
+      packageResults.push(createPackageResult(openpkg, doccov, entryFile));
+    } catch (err) {
+      log(chalk7.yellow(`  Skipping ${target}: ${err instanceof Error ? err.message : err}`));
+    }
+  }
+  if (packageResults.length === 0) {
+    spin.fail("No packages analyzed successfully");
+    process.exit(1);
+  }
+  spin.success(`Analyzed ${packageResults.length} package(s)`);
+  const batchResult = aggregateResults(packageResults);
+  const firstTargetDir = path8.dirname(targets[0]);
+  const config = await loadDocCovConfig(firstTargetDir);
+  const DEFAULT_MIN_HEALTH = 80;
+  const minHealthRaw = options.minHealth ?? config?.check?.minHealth ?? DEFAULT_MIN_HEALTH;
+  const minHealth = clampPercentage(minHealthRaw);
+  const format = options.format ?? "text";
+  if (format !== "text") {
+    const passed2 = handleBatchNonTextOutput({
+      format,
+      batchResult,
+      minHealth,
+      limit: parseInt(options.limit, 10) || 20,
+      stdout: options.stdout,
+      outputPath: options.output,
+      cwd: options.cwd
+    }, { log });
+    if (!passed2) {
+      process.exit(1);
+    }
+    return;
+  }
+  const passed = displayBatchTextOutput({
+    batchResult,
+    minHealth,
+    verbose: options.verbose ?? false
+  }, { log });
+  if (!passed) {
+    process.exit(1);
+  }
+}
 // src/commands/diff.ts
 import * as fs5 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import {
   diffSpecWithDocs,
   ensureSpecCoverage,
@@ -3897,8 +4243,8 @@ import {
   parseMarkdownFiles as parseMarkdownFiles2
 } from "@doccov/sdk";
 import { calculateNextVersion, recommendSemverBump } from "@openpkg-ts/spec";
-import chalk7 from "chalk";
-import { glob as glob2 } from "glob";
+import chalk8 from "chalk";
+import { glob as glob3 } from "glob";
 var defaultDependencies2 = {
   readFileSync: fs5.readFileSync,
   log: console.log,
@@ -3939,7 +4285,7 @@ function registerDiffCommand(program, dependencies = {}) {
       const baseHash = hashString(JSON.stringify(baseSpec));
       const headHash = hashString(JSON.stringify(headSpec));
       const cacheEnabled = options.cache !== false;
-      const cachedReportPath = path8.resolve(options.cwd, getDiffReportPath(baseHash, headHash, "json"));
+      const cachedReportPath = path9.resolve(options.cwd, getDiffReportPath(baseHash, headHash, "json"));
       let diff;
       let fromCache = false;
       if (cacheEnabled && fs5.existsSync(cachedReportPath)) {
@@ -3972,9 +4318,9 @@ function registerDiffCommand(program, dependencies = {}) {
           }, null, 2));
         } else {
           log("");
-          log(chalk7.bold("Semver Recommendation"));
+          log(chalk8.bold("Semver Recommendation"));
           log(`  Current version:    ${currentVersion}`);
-          log(`  Recommended:        ${chalk7.cyan(nextVersion)} (${chalk7.yellow(recommendation.bump.toUpperCase())})`);
+          log(`  Recommended:        ${chalk8.cyan(nextVersion)} (${chalk8.yellow(recommendation.bump.toUpperCase())})`);
           log(`  Reason:             ${recommendation.reason}`);
         }
         return;
@@ -3982,8 +4328,8 @@ function registerDiffCommand(program, dependencies = {}) {
       const format = options.format ?? "text";
       const limit = parseInt(options.limit, 10) || 10;
       const checks = getStrictChecks(options.strict);
-      const baseName = path8.basename(baseFile);
-      const headName = path8.basename(headFile);
+      const baseName = path9.basename(baseFile);
+      const headName = path9.basename(headFile);
       const reportData = {
         baseName,
         headName,
@@ -4004,8 +4350,8 @@ function registerDiffCommand(program, dependencies = {}) {
                 silent: true
               });
             }
-            const cacheNote = fromCache ? chalk7.cyan(" (cached)") : "";
-            log(chalk7.dim(`Report: ${jsonPath}`) + cacheNote);
+            const cacheNote = fromCache ? chalk8.cyan(" (cached)") : "";
+            log(chalk8.dim(`Report: ${jsonPath}`) + cacheNote);
           }
           break;
         case "json": {
@@ -4063,18 +4409,18 @@ function registerDiffCommand(program, dependencies = {}) {
         checks
       });
       if (failures.length > 0) {
-        log(chalk7.red(`
+        log(chalk8.red(`
 ✗ Check failed`));
         for (const f of failures) {
-          log(chalk7.red(`  - ${f}`));
+          log(chalk8.red(`  - ${f}`));
         }
         process.exitCode = 1;
       } else if (options.strict || minCoverage !== undefined || maxDrift !== undefined) {
-        log(chalk7.green(`
+        log(chalk8.green(`
 ✓ All checks passed`));
       }
     } catch (commandError) {
-      error(chalk7.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk8.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     }
   });
@@ -4085,7 +4431,7 @@ function collect2(value, previous) {
 async function loadMarkdownFiles2(patterns) {
   const files = [];
   for (const pattern of patterns) {
-    const matches = await glob2(pattern, { nodir: true });
+    const matches = await glob3(pattern, { nodir: true });
     for (const filePath of matches) {
       try {
         const content = fs5.readFileSync(filePath, "utf-8");
@@ -4101,7 +4447,7 @@ async function generateDiff(baseSpec, headSpec, options, config, log) {
   if (!docsPatterns || docsPatterns.length === 0) {
     if (config?.docs?.include) {
       docsPatterns = config.docs.include;
-      log(chalk7.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
+      log(chalk8.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
     }
   }
   if (docsPatterns && docsPatterns.length > 0) {
@@ -4110,7 +4456,7 @@ async function generateDiff(baseSpec, headSpec, options, config, log) {
   return diffSpecWithDocs(baseSpec, headSpec, { markdownFiles });
 }
 function loadSpec(filePath, readFileSync4) {
-  const resolvedPath = path8.resolve(filePath);
+  const resolvedPath = path9.resolve(filePath);
   if (!fs5.existsSync(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
@@ -4124,37 +4470,37 @@ function loadSpec(filePath, readFileSync4) {
 }
 function printSummary(diff, baseName, headName, fromCache, log) {
   log("");
-  const cacheIndicator = fromCache ? chalk7.cyan(" (cached)") : "";
-  log(chalk7.bold(`Comparing: ${baseName} → ${headName}`) + cacheIndicator);
+  const cacheIndicator = fromCache ? chalk8.cyan(" (cached)") : "";
+  log(chalk8.bold(`Comparing: ${baseName} → ${headName}`) + cacheIndicator);
   log("─".repeat(40));
   log("");
-  const coverageColor = diff.coverageDelta > 0 ? chalk7.green : diff.coverageDelta < 0 ? chalk7.red : chalk7.gray;
+  const coverageColor = diff.coverageDelta > 0 ? chalk8.green : diff.coverageDelta < 0 ? chalk8.red : chalk8.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 ? chalk7.red(` (${highSeverity} high severity)`) : "";
-    log(`  Breaking:   ${chalk7.red(breakingCount)} changes${severityNote}`);
+    const severityNote = highSeverity > 0 ? chalk8.red(` (${highSeverity} high severity)`) : "";
+    log(`  Breaking:   ${chalk8.red(breakingCount)} changes${severityNote}`);
   } else {
-    log(`  Breaking:   ${chalk7.green("0")} changes`);
+    log(`  Breaking:   ${chalk8.green("0")} changes`);
   }
   const newCount = diff.nonBreaking.length;
   const undocCount = diff.newUndocumented.length;
   if (newCount > 0) {
-    const undocNote = undocCount > 0 ? chalk7.yellow(` (${undocCount} undocumented)`) : "";
-    log(`  New:        ${chalk7.green(newCount)} exports${undocNote}`);
+    const undocNote = undocCount > 0 ? chalk8.yellow(` (${undocCount} undocumented)`) : "";
+    log(`  New:        ${chalk8.green(newCount)} exports${undocNote}`);
   }
   if (diff.driftIntroduced > 0 || diff.driftResolved > 0) {
     const parts = [];
     if (diff.driftIntroduced > 0)
-      parts.push(chalk7.red(`+${diff.driftIntroduced}`));
+      parts.push(chalk8.red(`+${diff.driftIntroduced}`));
     if (diff.driftResolved > 0)
-      parts.push(chalk7.green(`-${diff.driftResolved}`));
+      parts.push(chalk8.green(`-${diff.driftResolved}`));
     log(`  Drift:      ${parts.join(", ")}`);
   }
   const recommendation = recommendSemverBump(diff);
-  const bumpColor = recommendation.bump === "major" ? chalk7.red : recommendation.bump === "minor" ? chalk7.yellow : chalk7.green;
+  const bumpColor = recommendation.bump === "major" ? chalk8.red : recommendation.bump === "minor" ? chalk8.yellow : chalk8.green;
   log(`  Semver:     ${bumpColor(recommendation.bump.toUpperCase())} (${recommendation.reason})`);
   log("");
 }
@@ -4236,8 +4582,8 @@ function printGitHubAnnotations(diff, log) {
 
 // src/commands/init.ts
 import * as fs6 from "node:fs";
-import * as path9 from "node:path";
-import chalk8 from "chalk";
+import * as path10 from "node:path";
+import chalk9 from "chalk";
 var defaultDependencies3 = {
   fileExists: fs6.existsSync,
   writeFileSync: fs6.writeFileSync,
@@ -4252,19 +4598,19 @@ function registerInitCommand(program, dependencies = {}) {
     ...dependencies
   };
   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 = path9.resolve(options.cwd);
+    const cwd = path10.resolve(options.cwd);
     const existing = findExistingConfig(cwd, fileExists2);
     if (existing) {
-      error(chalk8.red(`A DocCov config already exists at ${path9.relative(cwd, existing) || "./doccov.config.*"}.`));
+      error(chalk9.red(`A DocCov config already exists at ${path10.relative(cwd, existing) || "./doccov.config.*"}.`));
       process.exitCode = 1;
       return;
     }
     const packageType = detectPackageType(cwd, fileExists2, readFileSync5);
     const targetFormat = packageType === "module" ? "ts" : "mts";
     const fileName = `doccov.config.${targetFormat}`;
-    const outputPath = path9.join(cwd, fileName);
+    const outputPath = path10.join(cwd, fileName);
     if (fileExists2(outputPath)) {
-      error(chalk8.red(`Cannot create ${fileName}; file already exists.`));
+      error(chalk9.red(`Cannot create ${fileName}; file already exists.`));
       process.exitCode = 1;
       return;
     }
@@ -4273,8 +4619,8 @@ function registerInitCommand(program, dependencies = {}) {
     writeFileSync4(outputPath, template, { encoding: "utf8" });
     log(colors.success(`${sym.success} Created ${fileName}`));
     if (!options.skipAction) {
-      const workflowDir = path9.join(cwd, ".github", "workflows");
-      const workflowPath = path9.join(workflowDir, "doccov.yml");
+      const workflowDir = path10.join(cwd, ".github", "workflows");
+      const workflowPath = path10.join(workflowDir, "doccov.yml");
       if (!fileExists2(workflowPath)) {
         mkdirSync4(workflowDir, { recursive: true });
         writeFileSync4(workflowPath, buildWorkflowTemplate(), { encoding: "utf8" });
@@ -4285,24 +4631,24 @@ function registerInitCommand(program, dependencies = {}) {
     }
     const repoInfo = detectRepoInfo(cwd, fileExists2, readFileSync5);
     log("");
-    log(chalk8.bold("Add this badge to your README:"));
+    log(chalk9.bold("Add this badge to your README:"));
     log("");
     if (repoInfo) {
-      log(chalk8.cyan(`[![DocCov](https://doccov.dev/badge/${repoInfo.owner}/${repoInfo.repo})](https://doccov.dev/${repoInfo.owner}/${repoInfo.repo})`));
+      log(chalk9.cyan(`[![DocCov](https://doccov.dev/badge/${repoInfo.owner}/${repoInfo.repo})](https://doccov.dev/${repoInfo.owner}/${repoInfo.repo})`));
     } else {
-      log(chalk8.cyan(`[![DocCov](https://doccov.dev/badge/OWNER/REPO)](https://doccov.dev/OWNER/REPO)`));
-      log(chalk8.dim("  Replace OWNER/REPO with your GitHub repo"));
+      log(chalk9.cyan(`[![DocCov](https://doccov.dev/badge/OWNER/REPO)](https://doccov.dev/OWNER/REPO)`));
+      log(chalk9.dim("  Replace OWNER/REPO with your GitHub repo"));
     }
     log("");
-    log(chalk8.dim("Run `doccov check` to verify your documentation coverage"));
+    log(chalk9.dim("Run `doccov check` to verify your documentation coverage"));
   });
 }
 var findExistingConfig = (cwd, fileExists2) => {
-  let current = path9.resolve(cwd);
-  const { root } = path9.parse(current);
+  let current = path10.resolve(cwd);
+  const { root } = path10.parse(current);
   while (true) {
     for (const candidate of DOCCOV_CONFIG_FILENAMES) {
-      const candidatePath = path9.join(current, candidate);
+      const candidatePath = path10.join(current, candidate);
       if (fileExists2(candidatePath)) {
         return candidatePath;
       }
@@ -4310,7 +4656,7 @@ var findExistingConfig = (cwd, fileExists2) => {
     if (current === root) {
       break;
     }
-    current = path9.dirname(current);
+    current = path10.dirname(current);
   }
   return null;
 };
@@ -4332,17 +4678,17 @@ var detectPackageType = (cwd, fileExists2, readFileSync5) => {
   return;
 };
 var findNearestPackageJson = (cwd, fileExists2) => {
-  let current = path9.resolve(cwd);
-  const { root } = path9.parse(current);
+  let current = path10.resolve(cwd);
+  const { root } = path10.parse(current);
   while (true) {
-    const candidate = path9.join(current, "package.json");
+    const candidate = path10.join(current, "package.json");
     if (fileExists2(candidate)) {
       return candidate;
     }
     if (current === root) {
       break;
     }
-    current = path9.dirname(current);
+    current = path10.dirname(current);
   }
   return null;
 };
@@ -4404,7 +4750,7 @@ var detectRepoInfo = (cwd, fileExists2, readFileSync5) => {
       }
     } catch {}
   }
-  const gitConfigPath = path9.join(cwd, ".git", "config");
+  const gitConfigPath = path10.join(cwd, ".git", "config");
   if (fileExists2(gitConfigPath)) {
     try {
       const config = readFileSync5(gitConfigPath, "utf8");
@@ -4419,7 +4765,7 @@ var detectRepoInfo = (cwd, fileExists2, readFileSync5) => {
 
 // src/commands/spec.ts
 import * as fs7 from "node:fs";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 import {
   buildDocCovSpec as buildDocCovSpec2,
   DocCov as DocCov2,
@@ -4434,7 +4780,7 @@ import {
   normalize,
   validateSpec
 } from "@openpkg-ts/spec";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 var defaultDependencies4 = {
   createDocCov: (options) => new DocCov2(options),
   writeFileSync: fs7.writeFileSync,
@@ -4446,8 +4792,8 @@ function getArrayLength(value) {
 }
 function formatDiagnosticOutput(prefix2, diagnostic, baseDir) {
   const location = diagnostic.location;
-  const relativePath = location?.file ? path10.relative(baseDir, location.file) || location.file : undefined;
-  const locationText = location && relativePath ? chalk9.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
+  const relativePath = location?.file ? path11.relative(baseDir, location.file) || location.file : undefined;
+  const locationText = location && relativePath ? chalk10.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
   const locationPrefix = locationText ? `${locationText} ` : "";
   return `${prefix2} ${locationPrefix}${diagnostic.message}`;
 }
@@ -4471,7 +4817,7 @@ function registerSpecCommand(program, dependencies = {}) {
         config = await loadDocCovConfig(targetDir);
       } catch (configError) {
         spin.fail("Failed to load config");
-        error(chalk9.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
+        error(chalk10.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
         process.exit(1);
       }
       const cliFilters = {
@@ -4504,26 +4850,30 @@ function registerSpecCommand(program, dependencies = {}) {
       const validation = validateSpec(normalized);
       if (!validation.ok) {
         spin.fail("Validation failed");
-        error(chalk9.red("Spec failed schema validation"));
+        error(chalk10.red("Spec failed schema validation"));
         for (const err of validation.errors) {
-          error(chalk9.red(`schema: ${err.instancePath || "/"} ${err.message}`));
+          error(chalk10.red(`schema: ${err.instancePath || "/"} ${err.message}`));
         }
         process.exit(1);
       }
       let doccovSpec = null;
       if (!options.openpkgOnly) {
-        doccovSpec = buildDocCovSpec2({
+        spin.update("Building coverage spec...");
+        doccovSpec = await buildDocCovSpec2({
           openpkgPath: "openpkg.json",
           openpkg: normalized,
           packagePath: targetDir,
-          forgottenExports: result.forgottenExports
+          forgottenExports: result.forgottenExports,
+          onProgress: (current, total, item) => {
+            spin.setDetail(`${current}/${total}: ${item}`);
+          }
         });
         const doccovValidation = validateDocCovSpec(doccovSpec);
         if (!doccovValidation.ok) {
           spin.fail("DocCov validation failed");
-          error(chalk9.red("DocCov spec failed schema validation"));
+          error(chalk10.red("DocCov spec failed schema validation"));
           for (const err of doccovValidation.errors) {
-            error(chalk9.red(`doccov: ${err.instancePath || "/"} ${err.message}`));
+            error(chalk10.red(`doccov: ${err.instancePath || "/"} ${err.message}`));
           }
           process.exit(1);
         }
@@ -4533,7 +4883,7 @@ function registerSpecCommand(program, dependencies = {}) {
       if (resolved.packageInfo) {
         packageName = resolved.packageInfo.name;
       } else {
-        const pkgJsonPath = path10.join(targetDir, "package.json");
+        const pkgJsonPath = path11.join(targetDir, "package.json");
         try {
           const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
           packageName = pkgJson.name ?? "unknown";
@@ -4541,28 +4891,28 @@ function registerSpecCommand(program, dependencies = {}) {
           packageName = "unknown";
         }
       }
-      const baseOutputDir = options.output === ".doccov" ? getDoccovDir3(options.cwd) : path10.resolve(options.cwd, options.output);
-      const outputDir = path10.join(baseOutputDir, packageName);
+      const baseOutputDir = options.output === ".doccov" ? getDoccovDir3(options.cwd) : path11.resolve(options.cwd, options.output);
+      const outputDir = path11.join(baseOutputDir, packageName);
       fs7.mkdirSync(outputDir, { recursive: true });
       const displayPath = `${options.output}/${packageName}`;
       if (format === "api-surface") {
         const apiSurface = renderApiSurface(normalized);
-        const apiSurfacePath = path10.join(outputDir, "api-surface.txt");
+        const apiSurfacePath = path11.join(outputDir, "api-surface.txt");
         writeFileSync5(apiSurfacePath, apiSurface);
         spin.success(`Generated ${displayPath}/ (API surface)`);
       } else {
-        const openpkgPath = path10.join(outputDir, "openpkg.json");
+        const openpkgPath = path11.join(outputDir, "openpkg.json");
         writeFileSync5(openpkgPath, JSON.stringify(normalized, null, 2));
         if (doccovSpec) {
-          const doccovPath = path10.join(outputDir, "doccov.json");
+          const doccovPath = path11.join(outputDir, "doccov.json");
           writeFileSync5(doccovPath, JSON.stringify(doccovSpec, null, 2));
           spin.success(`Generated ${displayPath}/`);
-          log(chalk9.gray(`  openpkg.json: ${getArrayLength(normalized.exports)} exports`));
-          log(chalk9.gray(`  doccov.json:  ${doccovSpec.summary.score}% coverage, ${doccovSpec.summary.drift.total} drift issues`));
+          log(chalk10.gray(`  openpkg.json: ${getArrayLength(normalized.exports)} exports`));
+          log(chalk10.gray(`  doccov.json:  ${doccovSpec.summary.score}% coverage, ${doccovSpec.summary.drift.total} drift issues`));
         } else {
           spin.success(`Generated ${displayPath}/openpkg.json`);
-          log(chalk9.gray(`  ${getArrayLength(normalized.exports)} exports`));
-          log(chalk9.gray(`  ${getArrayLength(normalized.types)} types`));
+          log(chalk10.gray(`  ${getArrayLength(normalized.exports)} exports`));
+          log(chalk10.gray(`  ${getArrayLength(normalized.types)} types`));
         }
       }
       const isFullGenerationInfo = (gen) => {
@@ -4574,62 +4924,62 @@ function registerSpecCommand(program, dependencies = {}) {
         const pm = await detectPackageManager(fileSystem);
         const buildCmd = pm.name === "npm" ? "npm run build" : `${pm.name} run build`;
         log("");
-        log(chalk9.yellow("⚠ Runtime extraction requested but no schemas extracted."));
-        log(chalk9.yellow(`  Ensure project is built (${buildCmd}) and dist/ exists.`));
+        log(chalk10.yellow("⚠ Runtime extraction requested but no schemas extracted."));
+        log(chalk10.yellow(`  Ensure project is built (${buildCmd}) and dist/ exists.`));
       }
       if (options.verbose && fullGen) {
         log("");
-        log(chalk9.bold("Generation Info"));
-        log(chalk9.gray(`  Timestamp:        ${fullGen.timestamp}`));
-        log(chalk9.gray(`  Generator:        ${fullGen.generator.name}@${fullGen.generator.version}`));
-        log(chalk9.gray(`  Entry point:      ${fullGen.analysis.entryPoint}`));
-        log(chalk9.gray(`  Detected via:     ${fullGen.analysis.entryPointSource}`));
-        log(chalk9.gray(`  Declaration only: ${fullGen.analysis.isDeclarationOnly ? "yes" : "no"}`));
-        log(chalk9.gray(`  External types:   ${fullGen.analysis.resolvedExternalTypes ? "resolved" : "skipped"}`));
+        log(chalk10.bold("Generation Info"));
+        log(chalk10.gray(`  Timestamp:        ${fullGen.timestamp}`));
+        log(chalk10.gray(`  Generator:        ${fullGen.generator.name}@${fullGen.generator.version}`));
+        log(chalk10.gray(`  Entry point:      ${fullGen.analysis.entryPoint}`));
+        log(chalk10.gray(`  Detected via:     ${fullGen.analysis.entryPointSource}`));
+        log(chalk10.gray(`  Declaration only: ${fullGen.analysis.isDeclarationOnly ? "yes" : "no"}`));
+        log(chalk10.gray(`  External types:   ${fullGen.analysis.resolvedExternalTypes ? "resolved" : "skipped"}`));
         if (fullGen.analysis.maxTypeDepth) {
-          log(chalk9.gray(`  Max type depth:   ${fullGen.analysis.maxTypeDepth}`));
+          log(chalk10.gray(`  Max type depth:   ${fullGen.analysis.maxTypeDepth}`));
         }
         if (fullGen.analysis.schemaExtraction) {
           const se = fullGen.analysis.schemaExtraction;
-          log(chalk9.gray(`  Schema extraction: ${se.method}`));
+          log(chalk10.gray(`  Schema extraction: ${se.method}`));
           if (se.runtimeCount) {
-            log(chalk9.gray(`  Runtime schemas:   ${se.runtimeCount} (${se.vendors?.join(", ")})`));
+            log(chalk10.gray(`  Runtime schemas:   ${se.runtimeCount} (${se.vendors?.join(", ")})`));
           }
         }
         log("");
-        log(chalk9.bold("Environment"));
-        log(chalk9.gray(`  node_modules:     ${fullGen.environment.hasNodeModules ? "found" : "not found"}`));
+        log(chalk10.bold("Environment"));
+        log(chalk10.gray(`  node_modules:     ${fullGen.environment.hasNodeModules ? "found" : "not found"}`));
         if (fullGen.environment.packageManager) {
-          log(chalk9.gray(`  Package manager:  ${fullGen.environment.packageManager}`));
+          log(chalk10.gray(`  Package manager:  ${fullGen.environment.packageManager}`));
         }
         if (fullGen.environment.isMonorepo) {
-          log(chalk9.gray(`  Monorepo:         yes`));
+          log(chalk10.gray(`  Monorepo:         yes`));
         }
         if (fullGen.environment.targetPackage) {
-          log(chalk9.gray(`  Target package:   ${fullGen.environment.targetPackage}`));
+          log(chalk10.gray(`  Target package:   ${fullGen.environment.targetPackage}`));
         }
         if (fullGen.issues.length > 0) {
           log("");
-          log(chalk9.bold("Issues"));
+          log(chalk10.bold("Issues"));
           for (const issue of fullGen.issues) {
-            const prefix2 = issue.severity === "error" ? chalk9.red(">") : issue.severity === "warning" ? chalk9.yellow(">") : chalk9.cyan(">");
+            const prefix2 = issue.severity === "error" ? chalk10.red(">") : issue.severity === "warning" ? chalk10.yellow(">") : chalk10.cyan(">");
             log(`${prefix2} [${issue.code}] ${issue.message}`);
             if (issue.suggestion) {
-              log(chalk9.gray(`    ${issue.suggestion}`));
+              log(chalk10.gray(`    ${issue.suggestion}`));
             }
           }
         }
       }
       if (options.showDiagnostics && result.diagnostics.length > 0) {
         log("");
-        log(chalk9.bold("Diagnostics"));
+        log(chalk10.bold("Diagnostics"));
         for (const diagnostic of result.diagnostics) {
-          const prefix2 = diagnostic.severity === "error" ? chalk9.red(">") : diagnostic.severity === "warning" ? chalk9.yellow(">") : chalk9.cyan(">");
+          const prefix2 = diagnostic.severity === "error" ? chalk10.red(">") : diagnostic.severity === "warning" ? chalk10.yellow(">") : chalk10.cyan(">");
           log(formatDiagnosticOutput(prefix2, diagnostic, targetDir));
         }
       }
     } catch (commandError) {
-      error(chalk9.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk10.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
@@ -4637,7 +4987,7 @@ function registerSpecCommand(program, dependencies = {}) {
 
 // src/commands/trends.ts
 import * as fs8 from "node:fs";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import {
   formatDelta as formatDelta2,
   getExtendedTrend,
@@ -4647,7 +4997,7 @@ import {
   renderSparkline,
   saveSnapshot
 } from "@doccov/sdk";
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 function formatDate(timestamp) {
   const date = new Date(timestamp);
   return date.toLocaleDateString("en-US", {
@@ -4660,19 +5010,19 @@ function formatDate(timestamp) {
 }
 function getColorForScore(score) {
   if (score >= 90)
-    return chalk10.green;
+    return chalk11.green;
   if (score >= 70)
-    return chalk10.yellow;
+    return chalk11.yellow;
   if (score >= 50)
-    return chalk10.hex("#FFA500");
-  return chalk10.red;
+    return chalk11.hex("#FFA500");
+  return chalk11.red;
 }
 function formatSnapshot(snapshot) {
   const color = getColorForScore(snapshot.coverageScore);
   const date = formatDate(snapshot.timestamp);
   const version = 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${version}${commit}`;
+  const commit = snapshot.commit ? chalk11.gray(` (${snapshot.commit.slice(0, 7)})`) : "";
+  return `${chalk11.gray(date)}  ${color(`${snapshot.coverageScore}%`)}  ${snapshot.documentedExports}/${snapshot.totalExports} exports${version}${commit}`;
 }
 function formatWeekDate(timestamp) {
   const date = new Date(timestamp);
@@ -4680,26 +5030,26 @@ function formatWeekDate(timestamp) {
 }
 function formatVelocity(velocity) {
   if (velocity > 0)
-    return chalk10.green(`+${velocity}%/day`);
+    return chalk11.green(`+${velocity}%/day`);
   if (velocity < 0)
-    return chalk10.red(`${velocity}%/day`);
-  return chalk10.gray("0%/day");
+    return chalk11.red(`${velocity}%/day`);
+  return chalk11.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("--weekly", "Show weekly summary breakdown").action(async (options) => {
-    const cwd = path11.resolve(options.cwd);
+    const cwd = path12.resolve(options.cwd);
     if (options.prune) {
       const keepCount = parseInt(options.prune, 10);
       if (!Number.isNaN(keepCount)) {
         const deleted = pruneHistory(cwd, keepCount);
-        console.log(chalk10.green(`Pruned ${deleted} old snapshots, kept ${keepCount} most recent`));
+        console.log(chalk11.green(`Pruned ${deleted} old snapshots, kept ${keepCount} most recent`));
       }
       return;
     }
     if (options.record) {
-      const specPath = path11.resolve(cwd, "openpkg.json");
+      const specPath = path12.resolve(cwd, "openpkg.json");
       if (!fs8.existsSync(specPath)) {
-        console.error(chalk10.red("No openpkg.json found. Run `doccov spec` first to generate a spec."));
+        console.error(chalk11.red("No openpkg.json found. Run `doccov spec` first to generate a spec."));
         process.exit(1);
       }
       const spin = spinner("Recording coverage snapshot");
@@ -4712,21 +5062,21 @@ function registerTrendsCommand(program) {
         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));
+          const deltaColor = trend.delta > 0 ? chalk11.green : trend.delta < 0 ? chalk11.red : chalk11.gray;
+          console.log(chalk11.gray("Change from previous:"), deltaColor(deltaStr));
         }
         return;
       } catch (error) {
         spin.fail("Failed to record snapshot");
-        console.error(chalk10.red("Failed to read openpkg.json:"), error instanceof Error ? error.message : error);
+        console.error(chalk11.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."));
+      console.log(chalk11.yellow("No coverage history found."));
+      console.log(chalk11.gray("Run `doccov trends --record` to save the current coverage."));
       return;
     }
     if (options.json) {
@@ -4741,83 +5091,83 @@ function registerTrendsCommand(program) {
     }
     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(chalk11.bold("Coverage Trends"));
+    console.log(chalk11.gray(`Package: ${snapshots[0].package}`));
+    console.log(chalk11.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)`));
+      const deltaColor = overallDelta > 0 ? chalk11.green : overallDelta < 0 ? chalk11.red : chalk11.gray;
+      console.log(chalk11.gray("Overall trend:"), deltaColor(deltaStr), chalk11.gray(`(${snapshots.length} snapshots)`));
       console.log("");
     }
     if (options.extended) {
-      const specPath = path11.resolve(cwd, "openpkg.json");
+      const specPath = path12.resolve(cwd, "openpkg.json");
       if (fs8.existsSync(specPath)) {
         try {
           const specContent = fs8.readFileSync(specPath, "utf-8");
           const spec = JSON.parse(specContent);
           const extended = getExtendedTrend(spec, cwd);
-          console.log(chalk10.bold("Extended Analysis"));
-          console.log(chalk10.gray("90-day retention"));
+          console.log(chalk11.bold("Extended Analysis"));
+          console.log(chalk11.gray("90-day retention"));
           console.log("");
           console.log("  Velocity:");
           console.log(`    7-day:   ${formatVelocity(extended.velocity7d)}`);
           console.log(`    30-day:  ${formatVelocity(extended.velocity30d)}`);
           console.log(`    90-day:  ${formatVelocity(extended.velocity90d)}`);
           console.log("");
-          const projColor = extended.projected30d >= extended.trend.current.coverageScore ? chalk10.green : chalk10.red;
+          const projColor = extended.projected30d >= extended.trend.current.coverageScore ? chalk11.green : chalk11.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}%`)}`);
+          console.log(`  All-time high:   ${chalk11.green(`${extended.allTimeHigh}%`)}`);
+          console.log(`  All-time low:    ${chalk11.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(chalk11.gray(`  Data range: ${startDate} - ${endDate}`));
           }
           console.log("");
           if (options.weekly && extended.weeklySummaries.length > 0) {
-            console.log(chalk10.bold("Weekly Summary"));
+            console.log(chalk11.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 deltaColor = week.delta > 0 ? chalk11.green : week.delta < 0 ? chalk11.red : chalk11.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(chalk11.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(chalk11.yellow("Could not load openpkg.json for extended analysis"));
           console.log("");
         }
       }
     }
-    console.log(chalk10.bold("History"));
+    console.log(chalk11.bold("History"));
     const displaySnapshots = snapshots.slice(0, limit);
     for (let i = 0;i < displaySnapshots.length; i++) {
       const snapshot = displaySnapshots[i];
-      const prefix2 = i === 0 ? chalk10.cyan("→") : " ";
+      const prefix2 = i === 0 ? chalk11.cyan("→") : " ";
       console.log(`${prefix2} ${formatSnapshot(snapshot)}`);
     }
     if (snapshots.length > limit) {
-      console.log(chalk10.gray(`  ... and ${snapshots.length - limit} more`));
+      console.log(chalk11.gray(`  ... and ${snapshots.length - limit} more`));
     }
   });
 }
 
 // src/cli.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path12.dirname(__filename2);
-var packageJson = JSON.parse(readFileSync7(path12.join(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = path13.dirname(__filename2);
+var packageJson = JSON.parse(readFileSync7(path13.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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/cli",
-  "version": "0.30.6",
+  "version": "0.31.0",
   "description": "DocCov CLI - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",
@@ -48,8 +48,8 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^1.0.0",
     "@ai-sdk/openai": "^1.0.0",
-    "@doccov/sdk": "^0.30.6",
-    "@doccov/spec": "^0.27.0",
+    "@doccov/sdk": "^0.31.0",
+    "@doccov/spec": "^0.31.0",
     "@inquirer/prompts": "^7.8.0",
     "@openpkg-ts/spec": "^0.23.0",
     "ai": "^4.0.0",