@doccov/cli 0.6.0 → 0.7.0

package/dist/cli.js

@@ -168,8 +168,8 @@ ${formatIssues(issues)}`);
 // src/config/index.ts
 var defineConfig = (config) => config;
 // src/cli.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import * as path11 from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import * as path8 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -181,12 +181,9 @@ import {
   categorizeDrifts,
   createSourceFile,
   DocCov,
-  detectEntryPoint,
   detectExampleAssertionFailures,
   detectExampleRuntimeErrors,
-  detectMonorepo,
   findJSDocLocation,
-  findPackageByName,
   generateFixesForExport,
   getDefaultConfig as getLintDefaultConfig,
   hasNonAssertionComments,
@@ -195,6 +192,7 @@ import {
   NodeFileSystem,
   parseAssertions,
   parseJSDocToPatch,
+  resolveTarget,
   runExamplesWithPackage,
   serializeJSDoc,
   typecheckExamples
@@ -284,12 +282,6 @@ function collectDriftsFromExports(exports) {
   }
   return results;
 }
-function filterDriftsByType(drifts, onlyTypes) {
-  if (!onlyTypes)
-    return drifts;
-  const allowedTypes = new Set(onlyTypes.split(",").map((t) => t.trim()));
-  return drifts.filter((d) => allowedTypes.has(d.drift.type));
-}
 function groupByExport(drifts) {
   const map = new Map;
   for (const { export: exp, drift } of drifts) {
@@ -304,38 +296,20 @@ function registerCheckCommand(program, dependencies = {}) {
     ...defaultDependencies,
     ...dependencies
   };
-  program.command("check [entry]").description("Fail if documentation coverage falls below a threshold").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("--require-examples", "Require at least one @example for every export").option("--exec", "Execute @example blocks at runtime").option("--no-lint", "Skip lint checks").option("--no-typecheck", "Skip example type checking").option("--ignore-drift", "Do not fail on documentation drift").option("--skip-resolve", "Skip external type resolution from node_modules").option("--fix", "Auto-fix drift and lint issues").option("--write", "Alias for --fix").option("--only <types>", "Only fix specific drift types (comma-separated)").option("--dry-run", "Preview fixes without writing (requires --fix)").action(async (entry, options) => {
+  program.command("check [entry]").description("Fail if documentation coverage falls below a threshold").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("--require-examples", "Require at least one @example for every export").option("--exec", "Execute @example blocks at runtime").option("--no-lint", "Skip lint checks").option("--no-typecheck", "Skip example type checking").option("--ignore-drift", "Do not fail on documentation drift").option("--skip-resolve", "Skip external type resolution from node_modules").option("--fix", "Auto-fix drift and lint issues").option("--write", "Alias for --fix").option("--dry-run", "Preview fixes without writing (requires --fix)").action(async (entry, options) => {
     try {
-      let targetDir = options.cwd;
-      let entryFile = entry;
       const fileSystem = new NodeFileSystem(options.cwd);
-      if (options.package) {
-        const mono = await detectMonorepo(fileSystem);
-        if (!mono.isMonorepo) {
-          throw new Error(`Not a monorepo. Remove --package flag for single-package repos.`);
-        }
-        const pkg = findPackageByName(mono.packages, options.package);
-        if (!pkg) {
-          const available = mono.packages.map((p) => p.name).join(", ");
-          throw new Error(`Package "${options.package}" not found. Available: ${available}`);
-        }
-        targetDir = path2.join(options.cwd, pkg.path);
-        log(chalk.gray(`Found package at ${pkg.path}`));
+      const resolved = await resolveTarget(fileSystem, {
+        cwd: options.cwd,
+        package: options.package,
+        entry
+      });
+      const { targetDir, entryFile, packageInfo, entryPointInfo } = resolved;
+      if (packageInfo) {
+        log(chalk.gray(`Found package at ${packageInfo.path}`));
       }
-      if (!entryFile) {
-        const targetFs = new NodeFileSystem(targetDir);
-        const detected = await detectEntryPoint(targetFs);
-        entryFile = path2.join(targetDir, detected.path);
-        log(chalk.gray(`Auto-detected entry point: ${detected.path} (from ${detected.source})`));
-      } else {
-        entryFile = path2.resolve(targetDir, entryFile);
-        if (fs.existsSync(entryFile) && fs.statSync(entryFile).isDirectory()) {
-          targetDir = entryFile;
-          const dirFs = new NodeFileSystem(entryFile);
-          const detected = await detectEntryPoint(dirFs);
-          entryFile = path2.join(entryFile, detected.path);
-          log(chalk.gray(`Auto-detected entry point: ${detected.path}`));
-        }
+      if (!entry) {
+        log(chalk.gray(`Auto-detected entry point: ${entryPointInfo.path} (from ${entryPointInfo.source})`));
       }
       const minCoverage = clampCoverage(options.minCoverage ?? 80);
       const resolveExternalTypes = !options.skipResolve;
@@ -537,11 +511,8 @@ function registerCheckCommand(program, dependencies = {}) {
       const fixedDriftKeys = new Set;
       if (shouldFix && driftExports.length > 0) {
         const allDrifts = collectDriftsFromExports(spec.exports ?? []);
-        const filteredDrifts = filterDriftsByType(allDrifts, options.only);
-        if (filteredDrifts.length === 0 && options.only) {
-          log(chalk.yellow("No matching drift issues for the specified types."));
-        } else if (filteredDrifts.length > 0) {
-          const { fixable, nonFixable } = categorizeDrifts(filteredDrifts.map((d) => d.drift));
+        if (allDrifts.length > 0) {
+          const { fixable, nonFixable } = categorizeDrifts(allDrifts.map((d) => d.drift));
           if (fixable.length === 0) {
             log(chalk.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
           } else {
@@ -551,7 +522,7 @@ function registerCheckCommand(program, dependencies = {}) {
               log(chalk.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
             }
             log("");
-            const groupedDrifts = groupByExport(filteredDrifts.filter((d) => fixable.includes(d.drift)));
+            const groupedDrifts = groupByExport(allDrifts.filter((d) => fixable.includes(d.drift)));
             const edits = [];
             const editsByFile = new Map;
             for (const [exp, drifts] of groupedDrifts) {
@@ -1363,59 +1334,207 @@ import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 import {
   DocCov as DocCov2,
-  detectEntryPoint as detectEntryPoint2,
-  detectMonorepo as detectMonorepo2,
-  findPackageByName as findPackageByName2,
-  NodeFileSystem as NodeFileSystem2
+  NodeFileSystem as NodeFileSystem2,
+  resolveTarget as resolveTarget2
 } from "@doccov/sdk";
 import { normalize, validateSpec } from "@openpkg-ts/spec";
 import chalk4 from "chalk";
 
+// src/reports/markdown.ts
+function bar(pct, width = 10) {
+  const filled = Math.round(pct / 100 * width);
+  return "█".repeat(filled) + "░".repeat(width - filled);
+}
+function renderMarkdown(stats, options = {}) {
+  const limit = options.limit ?? 20;
+  const lines = [];
+  lines.push(`# DocCov Report: ${stats.packageName}@${stats.version}`);
+  lines.push("");
+  lines.push(`**Coverage: ${stats.coverageScore}%** \`${bar(stats.coverageScore)}\``);
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Exports | ${stats.totalExports} |`);
+  lines.push(`| Fully documented | ${stats.fullyDocumented} |`);
+  lines.push(`| Partially documented | ${stats.partiallyDocumented} |`);
+  lines.push(`| Undocumented | ${stats.undocumented} |`);
+  lines.push(`| Drift issues | ${stats.driftCount} |`);
+  lines.push("");
+  lines.push("## Coverage by Signal");
+  lines.push("");
+  lines.push("| Signal | Coverage |");
+  lines.push("|--------|----------|");
+  for (const [sig, s] of Object.entries(stats.signalCoverage)) {
+    lines.push(`| ${sig} | ${s.pct}% \`${bar(s.pct, 8)}\` |`);
+  }
+  if (stats.byKind.length > 0) {
+    lines.push("");
+    lines.push("## Coverage by Kind");
+    lines.push("");
+    lines.push("| Kind | Count | Avg Score |");
+    lines.push("|------|-------|-----------|");
+    for (const k of stats.byKind) {
+      lines.push(`| ${k.kind} | ${k.count} | ${k.avgScore}% |`);
+    }
+  }
+  const lowExports = stats.exports.filter((e) => e.score < 100).slice(0, limit);
+  if (lowExports.length > 0) {
+    lines.push("");
+    lines.push("## Lowest Coverage Exports");
+    lines.push("");
+    lines.push("| Export | Kind | Score | Missing |");
+    lines.push("|--------|------|-------|---------|");
+    for (const e of lowExports) {
+      lines.push(`| \`${e.name}\` | ${e.kind} | ${e.score}% | ${e.missing.join(", ") || "-"} |`);
+    }
+    const totalLow = stats.exports.filter((e) => e.score < 100).length;
+    if (totalLow > limit) {
+      lines.push(`| ... | | | ${totalLow - limit} more |`);
+    }
+  }
+  if (stats.driftIssues.length > 0) {
+    lines.push("");
+    lines.push("## Drift Issues");
+    lines.push("");
+    lines.push("| Export | Type | Issue |");
+    lines.push("|--------|------|-------|");
+    for (const d of stats.driftIssues.slice(0, limit)) {
+      const hint = d.suggestion ? ` → ${d.suggestion}` : "";
+      lines.push(`| \`${d.exportName}\` | ${d.type} | ${d.issue}${hint} |`);
+    }
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("*Generated by [DocCov](https://doccov.com)*");
+  return lines.join(`
+`);
+}
+
+// src/reports/html.ts
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderHtml(stats, options = {}) {
+  const md = renderMarkdown(stats, options);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>DocCov Report: ${escapeHtml(stats.packageName)}</title>
+  <style>
+    :root { --bg: #0d1117; --fg: #c9d1d9; --border: #30363d; --accent: #58a6ff; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: var(--bg); color: var(--fg); max-width: 900px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
+    h1, h2 { border-bottom: 1px solid var(--border); padding-bottom: 0.5rem; }
+    table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
+    th, td { border: 1px solid var(--border); padding: 0.5rem 1rem; text-align: left; }
+    th { background: #161b22; }
+    code { background: #161b22; padding: 0.2rem 0.4rem; border-radius: 4px; font-size: 0.9em; }
+    a { color: var(--accent); }
+  </style>
+</head>
+<body>
+<pre style="white-space: pre-wrap; font-family: inherit;">${escapeHtml(md)}</pre>
+</body>
+</html>`;
+}
+// src/reports/stats.ts
+function computeStats(spec) {
+  const exports = spec.exports ?? [];
+  const signals = {
+    description: { covered: 0, total: 0 },
+    params: { covered: 0, total: 0 },
+    returns: { covered: 0, total: 0 },
+    examples: { covered: 0, total: 0 }
+  };
+  const kindMap = new Map;
+  const driftIssues = [];
+  let fullyDocumented = 0;
+  let partiallyDocumented = 0;
+  let undocumented = 0;
+  for (const exp of exports) {
+    const score = exp.docs?.coverageScore ?? 0;
+    const missing = exp.docs?.missing ?? [];
+    for (const sig of ["description", "params", "returns", "examples"]) {
+      signals[sig].total++;
+      if (!missing.includes(sig))
+        signals[sig].covered++;
+    }
+    const kindEntry = kindMap.get(exp.kind) ?? { count: 0, totalScore: 0 };
+    kindEntry.count++;
+    kindEntry.totalScore += score;
+    kindMap.set(exp.kind, kindEntry);
+    if (score === 100)
+      fullyDocumented++;
+    else if (score > 0)
+      partiallyDocumented++;
+    else
+      undocumented++;
+    for (const d of exp.docs?.drift ?? []) {
+      driftIssues.push({
+        exportName: exp.name,
+        type: d.type,
+        issue: d.issue,
+        suggestion: d.suggestion
+      });
+    }
+  }
+  const signalCoverage = Object.fromEntries(Object.entries(signals).map(([k, v]) => [
+    k,
+    { ...v, pct: v.total ? Math.round(v.covered / v.total * 100) : 0 }
+  ]));
+  const byKind = Array.from(kindMap.entries()).map(([kind, { count, totalScore }]) => ({
+    kind,
+    count,
+    avgScore: Math.round(totalScore / count)
+  })).sort((a, b) => b.count - a.count);
+  const sortedExports = exports.map((e) => ({
+    name: e.name,
+    kind: e.kind,
+    score: e.docs?.coverageScore ?? 0,
+    missing: e.docs?.missing ?? []
+  })).sort((a, b) => a.score - b.score);
+  return {
+    packageName: spec.meta.name ?? "unknown",
+    version: spec.meta.version ?? "0.0.0",
+    coverageScore: spec.docs?.coverageScore ?? 0,
+    totalExports: exports.length,
+    fullyDocumented,
+    partiallyDocumented,
+    undocumented,
+    driftCount: driftIssues.length,
+    signalCoverage,
+    byKind,
+    exports: sortedExports,
+    driftIssues
+  };
+}
 // src/utils/filter-options.ts
+import { mergeFilters, parseListFlag } from "@doccov/sdk";
 import chalk3 from "chalk";
-var unique = (values) => Array.from(new Set(values));
-var parseListFlag = (value) => {
-  if (!value) {
-    return;
-  }
-  const rawItems = Array.isArray(value) ? value : [value];
-  const normalized = rawItems.flatMap((item) => String(item).split(",")).map((item) => item.trim()).filter(Boolean);
-  return normalized.length > 0 ? unique(normalized) : undefined;
-};
 var formatList = (label, values) => `${label}: ${values.map((value) => chalk3.cyan(value)).join(", ")}`;
 var mergeFilterOptions = (config, cliOptions) => {
   const messages = [];
-  const configInclude = config?.include;
-  const configExclude = config?.exclude;
-  const cliInclude = cliOptions.include;
-  const cliExclude = cliOptions.exclude;
-  let include = configInclude;
-  let exclude = configExclude;
-  let source = include || exclude ? "config" : undefined;
-  if (configInclude) {
-    messages.push(formatList("include filters from config", configInclude));
-  }
-  if (configExclude) {
-    messages.push(formatList("exclude filters from config", configExclude));
-  }
-  if (cliInclude) {
-    include = include ? include.filter((item) => cliInclude.includes(item)) : cliInclude;
-    source = include ? "combined" : "cli";
-    messages.push(formatList("apply include filters from CLI", cliInclude));
-  }
-  if (cliExclude) {
-    exclude = exclude ? unique([...exclude, ...cliExclude]) : cliExclude;
-    source = source ? "combined" : "cli";
-    messages.push(formatList("apply exclude filters from CLI", cliExclude));
-  }
-  include = include ? unique(include) : undefined;
-  exclude = exclude ? unique(exclude) : undefined;
-  if (!include && !exclude) {
+  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,
-    exclude,
+    include: resolved.include,
+    exclude: resolved.exclude,
     source,
     messages
   };
@@ -1453,37 +1572,20 @@ function registerGenerateCommand(program, dependencies = {}) {
     ...defaultDependencies3,
     ...dependencies
   };
-  program.command("generate [entry]").description("Generate OpenPkg specification for documentation coverage analysis").option("-o, --output <file>", "Output file", "openpkg.json").option("-p, --package <name>", "Target package name (for monorepos)").option("--cwd <dir>", "Working directory", process.cwd()).option("--skip-resolve", "Skip external type resolution from node_modules").option("--include <ids>", "Filter exports by identifier (comma-separated or repeated)").option("--exclude <ids>", "Exclude exports by identifier (comma-separated or repeated)").option("--show-diagnostics", "Print TypeScript diagnostics from analysis").option("--no-docs", "Omit docs coverage fields from output (pure structural spec)").option("-y, --yes", "Skip all prompts and use defaults").action(async (entry, options) => {
+  program.command("generate [entry]").description("Generate OpenPkg specification for documentation coverage analysis").option("-o, --output <file>", "Output file", "openpkg.json").option("--format <format>", "Output format: json, markdown, html", "json").option("-p, --package <name>", "Target package name (for monorepos)").option("--cwd <dir>", "Working directory", process.cwd()).option("--skip-resolve", "Skip external type resolution from node_modules").option("--include <ids>", "Filter exports by identifier (comma-separated or repeated)").option("--exclude <ids>", "Exclude exports by identifier (comma-separated or repeated)").option("--show-diagnostics", "Print TypeScript diagnostics from analysis").option("--no-docs", "Omit docs coverage fields from output (pure structural spec)").option("--limit <n>", "Max exports to show in report tables (for markdown/html)", "20").option("-y, --yes", "Skip all prompts and use defaults").action(async (entry, options) => {
     try {
-      let targetDir = options.cwd;
-      let entryFile = entry;
       const fileSystem = new NodeFileSystem2(options.cwd);
-      if (options.package) {
-        const mono = await detectMonorepo2(fileSystem);
-        if (!mono.isMonorepo) {
-          throw new Error(`Not a monorepo. Remove --package flag for single-package repos.`);
-        }
-        const pkg = findPackageByName2(mono.packages, options.package);
-        if (!pkg) {
-          const available = mono.packages.map((p) => p.name).join(", ");
-          throw new Error(`Package "${options.package}" not found. Available: ${available}`);
-        }
-        targetDir = path4.join(options.cwd, pkg.path);
-        log(chalk4.gray(`Found package at ${pkg.path}`));
+      const resolved = await resolveTarget2(fileSystem, {
+        cwd: options.cwd,
+        package: options.package,
+        entry
+      });
+      const { targetDir, entryFile, packageInfo, entryPointInfo } = resolved;
+      if (packageInfo) {
+        log(chalk4.gray(`Found package at ${packageInfo.path}`));
       }
-      if (!entryFile) {
-        const targetFs = new NodeFileSystem2(targetDir);
-        const detected = await detectEntryPoint2(targetFs);
-        entryFile = path4.join(targetDir, detected.path);
-        log(chalk4.gray(`Auto-detected entry point: ${detected.path} (from ${detected.source})`));
-      } else {
-        entryFile = path4.resolve(targetDir, entryFile);
-        if (fs3.existsSync(entryFile) && fs3.statSync(entryFile).isDirectory()) {
-          const dirFs = new NodeFileSystem2(entryFile);
-          const detected = await detectEntryPoint2(dirFs);
-          entryFile = path4.join(entryFile, detected.path);
-          log(chalk4.gray(`Auto-detected entry point: ${detected.path} (from ${detected.source})`));
-        }
+      if (!entry) {
+        log(chalk4.gray(`Auto-detected entry point: ${entryPointInfo.path} (from ${entryPointInfo.source})`));
       }
       const resolveExternalTypes = !options.skipResolve;
       const cliFilters = {
@@ -1528,23 +1630,34 @@ function registerGenerateCommand(program, dependencies = {}) {
       if (!result) {
         throw new Error("Failed to produce an OpenPkg spec.");
       }
-      const outputPath = path4.resolve(process.cwd(), options.output);
       let normalized = normalize(result.spec);
       if (options.docs === false) {
         normalized = stripDocsFields(normalized);
       }
       const validation = validateSpec(normalized);
       if (!validation.ok) {
-        spinnerInstance.fail("Spec failed schema validation");
+        error(chalk4.red("Spec failed schema validation"));
         for (const err of validation.errors) {
           error(chalk4.red(`schema: ${err.instancePath || "/"} ${err.message}`));
         }
         process.exit(1);
       }
-      writeFileSync2(outputPath, JSON.stringify(normalized, null, 2));
-      log(chalk4.green(`✓ Generated ${options.output}`));
-      log(chalk4.gray(`  ${getArrayLength(normalized.exports)} exports`));
-      log(chalk4.gray(`  ${getArrayLength(normalized.types)} types`));
+      const format = options.format ?? "json";
+      const outputPath = path4.resolve(process.cwd(), options.output);
+      if (format === "markdown" || format === "html") {
+        const stats = computeStats(normalized);
+        const limit = parseInt(options.limit, 10) || 20;
+        const reportOutput = format === "html" ? renderHtml(stats, { limit }) : renderMarkdown(stats, { limit });
+        writeFileSync2(outputPath, reportOutput);
+        log(chalk4.green(`✓ Generated ${format} report: ${options.output}`));
+        log(chalk4.gray(`  Coverage: ${stats.coverageScore}%`));
+        log(chalk4.gray(`  ${stats.totalExports} exports, ${stats.driftCount} drift issues`));
+      } else {
+        writeFileSync2(outputPath, JSON.stringify(normalized, null, 2));
+        log(chalk4.green(`✓ Generated ${options.output}`));
+        log(chalk4.gray(`  ${getArrayLength(normalized.exports)} exports`));
+        log(chalk4.gray(`  ${getArrayLength(normalized.types)} types`));
+      }
       if (options.showDiagnostics && result.diagnostics.length > 0) {
         log("");
         log(chalk4.bold("Diagnostics"));
@@ -1690,518 +1803,32 @@ var buildTemplate = (format) => {
 `);
 };
 
-// src/commands/lint.ts
-import * as fs5 from "node:fs";
-import * as path6 from "node:path";
+// src/commands/scan.ts
+import * as fs6 from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+import * as path7 from "node:path";
 import {
-  applyEdits as applyEdits2,
-  createSourceFile as createSourceFile2,
   DocCov as DocCov3,
-  detectEntryPoint as detectEntryPoint3,
-  detectMonorepo as detectMonorepo3,
-  findJSDocLocation as findJSDocLocation2,
-  findPackageByName as findPackageByName3,
-  getDefaultConfig,
-  getRule,
-  lintExport as lintExport2,
+  buildCloneUrl,
+  buildDisplayUrl,
+  detectBuildInfo,
+  detectEntryPoint,
+  detectMonorepo,
+  detectPackageManager,
+  extractSpecSummary,
+  findPackageByName,
+  formatPackageList,
+  getInstallCommand,
   NodeFileSystem as NodeFileSystem3,
-  serializeJSDoc as serializeJSDoc2
+  parseGitHubUrl
 } from "@doccov/sdk";
 import chalk6 from "chalk";
-var defaultDependencies5 = {
-  createDocCov: (options) => new DocCov3(options),
-  log: console.log,
-  error: console.error
-};
-function getRawJSDoc(exp, targetDir) {
-  if (!exp.source?.file)
-    return;
-  const filePath = path6.resolve(targetDir, exp.source.file);
-  if (!fs5.existsSync(filePath))
-    return;
-  try {
-    const sourceFile = createSourceFile2(filePath);
-    const location = findJSDocLocation2(sourceFile, exp.name, exp.source.line);
-    return location?.existingJSDoc;
-  } catch {
-    return;
-  }
-}
-function registerLintCommand(program, dependencies = {}) {
-  const { createDocCov, log, error } = {
-    ...defaultDependencies5,
-    ...dependencies
-  };
-  program.command("lint [entry]").description("Lint documentation for style and quality issues").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--fix", "Auto-fix fixable issues").option("--write", "Alias for --fix").option("--rule <name>", "Run only a specific rule").option("--skip-resolve", "Skip external type resolution").action(async (entry, options) => {
-    try {
-      let targetDir = options.cwd;
-      let entryFile = entry;
-      const fileSystem = new NodeFileSystem3(options.cwd);
-      if (options.package) {
-        const mono = await detectMonorepo3(fileSystem);
-        if (!mono.isMonorepo) {
-          throw new Error("Not a monorepo. Remove --package flag.");
-        }
-        const pkg = findPackageByName3(mono.packages, options.package);
-        if (!pkg) {
-          const available = mono.packages.map((p) => p.name).join(", ");
-          throw new Error(`Package "${options.package}" not found. Available: ${available}`);
-        }
-        targetDir = path6.join(options.cwd, pkg.path);
-        log(chalk6.gray(`Found package at ${pkg.path}`));
-      }
-      if (!entryFile) {
-        const targetFs = new NodeFileSystem3(targetDir);
-        const detected = await detectEntryPoint3(targetFs);
-        entryFile = path6.join(targetDir, detected.path);
-        log(chalk6.gray(`Auto-detected entry point: ${detected.path}`));
-      } else {
-        entryFile = path6.resolve(targetDir, entryFile);
-        if (fs5.existsSync(entryFile) && fs5.statSync(entryFile).isDirectory()) {
-          targetDir = entryFile;
-          const dirFs = new NodeFileSystem3(entryFile);
-          const detected = await detectEntryPoint3(dirFs);
-          entryFile = path6.join(entryFile, detected.path);
-          log(chalk6.gray(`Auto-detected entry point: ${detected.path}`));
-        }
-      }
-      const resolveExternalTypes = !options.skipResolve;
-      process.stdout.write(chalk6.cyan(`> Analyzing documentation...
-`));
-      const doccov = createDocCov({ resolveExternalTypes });
-      const specResult = await doccov.analyzeFileWithDiagnostics(entryFile);
-      if (!specResult) {
-        throw new Error("Failed to analyze documentation.");
-      }
-      process.stdout.write(chalk6.cyan(`> Running lint rules...
-`));
-      let config = getDefaultConfig();
-      if (options.rule) {
-        const rule = getRule(options.rule);
-        if (!rule) {
-          throw new Error(`Unknown rule: ${options.rule}`);
-        }
-        const rules = {};
-        for (const key of Object.keys(config.rules)) {
-          rules[key] = "off";
-        }
-        rules[options.rule] = rule.defaultSeverity === "off" ? "warn" : rule.defaultSeverity;
-        config = { rules };
-      }
-      const exportsWithJSDoc = [];
-      for (const exp of specResult.spec.exports ?? []) {
-        const rawJSDoc = getRawJSDoc(exp, targetDir);
-        exportsWithJSDoc.push({
-          export: exp,
-          rawJSDoc,
-          filePath: exp.source?.file ? path6.resolve(targetDir, exp.source.file) : undefined
-        });
-      }
-      const allViolations = [];
-      for (const { export: exp, rawJSDoc, filePath } of exportsWithJSDoc) {
-        const violations = lintExport2(exp, rawJSDoc, config);
-        for (const violation of violations) {
-          allViolations.push({ export: exp, violation, filePath, rawJSDoc });
-        }
-      }
-      const shouldFix = options.fix || options.write;
-      const fixableViolations = allViolations.filter((v) => v.violation.fixable);
-      if (shouldFix && fixableViolations.length > 0) {
-        process.stdout.write(chalk6.cyan(`> Applying fixes...
-`));
-        const edits = [];
-        for (const { export: exp, rawJSDoc, filePath } of fixableViolations) {
-          if (!filePath || !rawJSDoc)
-            continue;
-          if (filePath.endsWith(".d.ts"))
-            continue;
-          const sourceFile = createSourceFile2(filePath);
-          const location = findJSDocLocation2(sourceFile, exp.name, exp.source?.line);
-          if (!location)
-            continue;
-          const rule = getRule("consistent-param-style");
-          if (!rule?.fix)
-            continue;
-          const patch = rule.fix(exp, rawJSDoc);
-          if (!patch)
-            continue;
-          const newJSDoc = serializeJSDoc2(patch, location.indent);
-          edits.push({
-            filePath,
-            symbolName: exp.name,
-            startLine: location.startLine,
-            endLine: location.endLine,
-            hasExisting: location.hasExisting,
-            existingJSDoc: location.existingJSDoc,
-            newJSDoc,
-            indent: location.indent
-          });
-        }
-        if (edits.length > 0) {
-          const result = await applyEdits2(edits);
-          if (result.errors.length > 0) {
-            for (const err of result.errors) {
-              error(chalk6.red(`  ${err.file}: ${err.error}`));
-            }
-          } else {
-            process.stdout.write(chalk6.green(`✓ Fixed ${result.editsApplied} issue(s) in ${result.filesModified} file(s)
-`));
-          }
-          const fixedExports = new Set(edits.map((e) => e.symbolName));
-          const remaining = allViolations.filter((v) => !v.violation.fixable || !fixedExports.has(v.export.name));
-          allViolations.length = 0;
-          allViolations.push(...remaining);
-        }
-      }
-      if (allViolations.length === 0) {
-        log(chalk6.green("✓ No lint issues found"));
-        return;
-      }
-      const byFile = new Map;
-      for (const v of allViolations) {
-        const file = v.filePath ?? "unknown";
-        const existing = byFile.get(file) ?? [];
-        existing.push(v);
-        byFile.set(file, existing);
-      }
-      log("");
-      for (const [filePath, violations] of byFile) {
-        const relativePath = path6.relative(targetDir, filePath);
-        log(chalk6.underline(relativePath));
-        for (const { export: exp, violation } of violations) {
-          const line = exp.source?.line ?? 0;
-          const severity = violation.severity === "error" ? chalk6.red("error") : chalk6.yellow("warning");
-          const fixable = violation.fixable ? chalk6.gray(" (fixable)") : "";
-          log(`  ${line}:1  ${severity}  ${violation.message}  ${chalk6.gray(violation.rule)}${fixable}`);
-        }
-        log("");
-      }
-      const errorCount = allViolations.filter((v) => v.violation.severity === "error").length;
-      const warnCount = allViolations.filter((v) => v.violation.severity === "warn").length;
-      const fixableCount = allViolations.filter((v) => v.violation.fixable).length;
-      const summary = [];
-      if (errorCount > 0)
-        summary.push(chalk6.red(`${errorCount} error(s)`));
-      if (warnCount > 0)
-        summary.push(chalk6.yellow(`${warnCount} warning(s)`));
-      if (fixableCount > 0 && !shouldFix) {
-        summary.push(chalk6.gray(`${fixableCount} fixable with --fix`));
-      }
-      log(summary.join(", "));
-      if (errorCount > 0) {
-        process.exit(1);
-      }
-    } catch (commandError) {
-      error(chalk6.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
-      process.exit(1);
-    }
-  });
-}
-
-// src/commands/report.ts
-import * as fs6 from "node:fs";
-import * as path7 from "node:path";
-import {
-  DocCov as DocCov4,
-  detectEntryPoint as detectEntryPoint4,
-  detectMonorepo as detectMonorepo4,
-  findPackageByName as findPackageByName4,
-  NodeFileSystem as NodeFileSystem4
-} from "@doccov/sdk";
-import chalk7 from "chalk";
-
-// src/reports/markdown.ts
-function bar(pct, width = 10) {
-  const filled = Math.round(pct / 100 * width);
-  return "█".repeat(filled) + "░".repeat(width - filled);
-}
-function renderMarkdown(stats, options = {}) {
-  const limit = options.limit ?? 20;
-  const lines = [];
-  lines.push(`# DocCov Report: ${stats.packageName}@${stats.version}`);
-  lines.push("");
-  lines.push(`**Coverage: ${stats.coverageScore}%** \`${bar(stats.coverageScore)}\``);
-  lines.push("");
-  lines.push("| Metric | Value |");
-  lines.push("|--------|-------|");
-  lines.push(`| Exports | ${stats.totalExports} |`);
-  lines.push(`| Fully documented | ${stats.fullyDocumented} |`);
-  lines.push(`| Partially documented | ${stats.partiallyDocumented} |`);
-  lines.push(`| Undocumented | ${stats.undocumented} |`);
-  lines.push(`| Drift issues | ${stats.driftCount} |`);
-  lines.push("");
-  lines.push("## Coverage by Signal");
-  lines.push("");
-  lines.push("| Signal | Coverage |");
-  lines.push("|--------|----------|");
-  for (const [sig, s] of Object.entries(stats.signalCoverage)) {
-    lines.push(`| ${sig} | ${s.pct}% \`${bar(s.pct, 8)}\` |`);
-  }
-  if (stats.byKind.length > 0) {
-    lines.push("");
-    lines.push("## Coverage by Kind");
-    lines.push("");
-    lines.push("| Kind | Count | Avg Score |");
-    lines.push("|------|-------|-----------|");
-    for (const k of stats.byKind) {
-      lines.push(`| ${k.kind} | ${k.count} | ${k.avgScore}% |`);
-    }
-  }
-  const lowExports = stats.exports.filter((e) => e.score < 100).slice(0, limit);
-  if (lowExports.length > 0) {
-    lines.push("");
-    lines.push("## Lowest Coverage Exports");
-    lines.push("");
-    lines.push("| Export | Kind | Score | Missing |");
-    lines.push("|--------|------|-------|---------|");
-    for (const e of lowExports) {
-      lines.push(`| \`${e.name}\` | ${e.kind} | ${e.score}% | ${e.missing.join(", ") || "-"} |`);
-    }
-    const totalLow = stats.exports.filter((e) => e.score < 100).length;
-    if (totalLow > limit) {
-      lines.push(`| ... | | | ${totalLow - limit} more |`);
-    }
-  }
-  if (stats.driftIssues.length > 0) {
-    lines.push("");
-    lines.push("## Drift Issues");
-    lines.push("");
-    lines.push("| Export | Type | Issue |");
-    lines.push("|--------|------|-------|");
-    for (const d of stats.driftIssues.slice(0, limit)) {
-      const hint = d.suggestion ? ` → ${d.suggestion}` : "";
-      lines.push(`| \`${d.exportName}\` | ${d.type} | ${d.issue}${hint} |`);
-    }
-  }
-  lines.push("");
-  lines.push("---");
-  lines.push("*Generated by [DocCov](https://doccov.com)*");
-  return lines.join(`
-`);
-}
-
-// src/reports/html.ts
-function escapeHtml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function renderHtml(stats, options = {}) {
-  const md = renderMarkdown(stats, options);
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>DocCov Report: ${escapeHtml(stats.packageName)}</title>
-  <style>
-    :root { --bg: #0d1117; --fg: #c9d1d9; --border: #30363d; --accent: #58a6ff; }
-    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: var(--bg); color: var(--fg); max-width: 900px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
-    h1, h2 { border-bottom: 1px solid var(--border); padding-bottom: 0.5rem; }
-    table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
-    th, td { border: 1px solid var(--border); padding: 0.5rem 1rem; text-align: left; }
-    th { background: #161b22; }
-    code { background: #161b22; padding: 0.2rem 0.4rem; border-radius: 4px; font-size: 0.9em; }
-    a { color: var(--accent); }
-  </style>
-</head>
-<body>
-<pre style="white-space: pre-wrap; font-family: inherit;">${escapeHtml(md)}</pre>
-</body>
-</html>`;
-}
-// src/reports/stats.ts
-function computeStats(spec) {
-  const exports = spec.exports ?? [];
-  const signals = {
-    description: { covered: 0, total: 0 },
-    params: { covered: 0, total: 0 },
-    returns: { covered: 0, total: 0 },
-    examples: { covered: 0, total: 0 }
-  };
-  const kindMap = new Map;
-  const driftIssues = [];
-  let fullyDocumented = 0;
-  let partiallyDocumented = 0;
-  let undocumented = 0;
-  for (const exp of exports) {
-    const score = exp.docs?.coverageScore ?? 0;
-    const missing = exp.docs?.missing ?? [];
-    for (const sig of ["description", "params", "returns", "examples"]) {
-      signals[sig].total++;
-      if (!missing.includes(sig))
-        signals[sig].covered++;
-    }
-    const kindEntry = kindMap.get(exp.kind) ?? { count: 0, totalScore: 0 };
-    kindEntry.count++;
-    kindEntry.totalScore += score;
-    kindMap.set(exp.kind, kindEntry);
-    if (score === 100)
-      fullyDocumented++;
-    else if (score > 0)
-      partiallyDocumented++;
-    else
-      undocumented++;
-    for (const d of exp.docs?.drift ?? []) {
-      driftIssues.push({
-        exportName: exp.name,
-        type: d.type,
-        issue: d.issue,
-        suggestion: d.suggestion
-      });
-    }
-  }
-  const signalCoverage = Object.fromEntries(Object.entries(signals).map(([k, v]) => [
-    k,
-    { ...v, pct: v.total ? Math.round(v.covered / v.total * 100) : 0 }
-  ]));
-  const byKind = Array.from(kindMap.entries()).map(([kind, { count, totalScore }]) => ({
-    kind,
-    count,
-    avgScore: Math.round(totalScore / count)
-  })).sort((a, b) => b.count - a.count);
-  const sortedExports = exports.map((e) => ({
-    name: e.name,
-    kind: e.kind,
-    score: e.docs?.coverageScore ?? 0,
-    missing: e.docs?.missing ?? []
-  })).sort((a, b) => a.score - b.score);
-  return {
-    packageName: spec.meta.name ?? "unknown",
-    version: spec.meta.version ?? "0.0.0",
-    coverageScore: spec.docs?.coverageScore ?? 0,
-    totalExports: exports.length,
-    fullyDocumented,
-    partiallyDocumented,
-    undocumented,
-    driftCount: driftIssues.length,
-    signalCoverage,
-    byKind,
-    exports: sortedExports,
-    driftIssues
-  };
-}
-// src/commands/report.ts
-function registerReportCommand(program) {
-  program.command("report [entry]").description("Generate a documentation coverage report").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--spec <file>", "Use existing openpkg.json instead of analyzing").option("--output <format>", "Output format: markdown, html, json", "markdown").option("--out <file>", "Write to file instead of stdout").option("--limit <n>", "Max exports to show in tables", "20").option("--skip-resolve", "Skip external type resolution from node_modules").action(async (entry, options) => {
-    try {
-      let spec;
-      if (options.spec) {
-        const specPath = path7.resolve(options.cwd, options.spec);
-        spec = JSON.parse(fs6.readFileSync(specPath, "utf-8"));
-      } else {
-        let targetDir = options.cwd;
-        let entryFile = entry;
-        const fileSystem = new NodeFileSystem4(options.cwd);
-        if (options.package) {
-          const mono = await detectMonorepo4(fileSystem);
-          if (!mono.isMonorepo) {
-            throw new Error(`Not a monorepo. Remove --package flag for single-package repos.`);
-          }
-          const pkg = findPackageByName4(mono.packages, options.package);
-          if (!pkg) {
-            const available = mono.packages.map((p) => p.name).join(", ");
-            throw new Error(`Package "${options.package}" not found. Available: ${available}`);
-          }
-          targetDir = path7.join(options.cwd, pkg.path);
-        }
-        if (!entryFile) {
-          const targetFs = new NodeFileSystem4(targetDir);
-          const detected = await detectEntryPoint4(targetFs);
-          entryFile = path7.join(targetDir, detected.path);
-        } else {
-          entryFile = path7.resolve(targetDir, entryFile);
-        }
-        process.stdout.write(chalk7.cyan(`> Analyzing...
-`));
-        try {
-          const resolveExternalTypes = !options.skipResolve;
-          const doccov = new DocCov4({ resolveExternalTypes });
-          const result = await doccov.analyzeFileWithDiagnostics(entryFile);
-          process.stdout.write(chalk7.green(`✓ Analysis complete
-`));
-          spec = result.spec;
-        } catch (analysisError) {
-          process.stdout.write(chalk7.red(`✗ Analysis failed
-`));
-          throw analysisError;
-        }
-      }
-      const stats = computeStats(spec);
-      const format = options.output;
-      const limit = parseInt(options.limit, 10) || 20;
-      let output;
-      if (format === "json") {
-        output = JSON.stringify(stats, null, 2);
-      } else if (format === "html") {
-        output = renderHtml(stats, { limit });
-      } else {
-        output = renderMarkdown(stats, { limit });
-      }
-      if (options.out) {
-        const outPath = path7.resolve(options.cwd, options.out);
-        fs6.writeFileSync(outPath, output);
-        console.log(chalk7.green(`Report written to ${outPath}`));
-      } else {
-        console.log(output);
-      }
-    } catch (err) {
-      console.error(chalk7.red("Error:"), err instanceof Error ? err.message : err);
-      process.exitCode = 1;
-    }
-  });
-}
-
-// src/commands/scan.ts
-import * as fs8 from "node:fs";
-import * as fsPromises from "node:fs/promises";
-import * as os from "node:os";
-import * as path9 from "node:path";
-import {
-  DocCov as DocCov5,
-  detectBuildInfo,
-  detectEntryPoint as detectEntryPoint5,
-  detectMonorepo as detectMonorepo5,
-  detectPackageManager,
-  findPackageByName as findPackageByName5,
-  formatPackageList,
-  getInstallCommand,
-  NodeFileSystem as NodeFileSystem5
-} from "@doccov/sdk";
-import chalk8 from "chalk";
 import { simpleGit } from "simple-git";
 
-// src/utils/github-url.ts
-function parseGitHubUrl(input, defaultRef = "main") {
-  const trimmed = input.trim();
-  if (!trimmed) {
-    throw new Error("GitHub URL cannot be empty");
-  }
-  let normalized = trimmed.replace(/^https?:\/\//, "").replace(/^git@github\.com:/, "").replace(/\.git$/, "");
-  normalized = normalized.replace(/^github\.com\//, "");
-  const parts = normalized.split("/").filter(Boolean);
-  if (parts.length < 2) {
-    throw new Error(`Invalid GitHub URL format: "${input}". Expected owner/repo or https://github.com/owner/repo`);
-  }
-  const owner = parts[0];
-  const repo = parts[1];
-  let ref = defaultRef;
-  if (parts.length >= 4 && (parts[2] === "tree" || parts[2] === "blob")) {
-    ref = parts.slice(3).join("/");
-  }
-  if (!owner || !repo) {
-    throw new Error(`Could not parse owner/repo from: "${input}"`);
-  }
-  return { owner, repo, ref };
-}
-function buildCloneUrl(parsed) {
-  return `https://github.com/${parsed.owner}/${parsed.repo}.git`;
-}
-function buildDisplayUrl(parsed) {
-  return `github.com/${parsed.owner}/${parsed.repo}`;
-}
-
 // src/utils/llm-build-plan.ts
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
 import { createAnthropic as createAnthropic3 } from "@ai-sdk/anthropic";
 import { createOpenAI as createOpenAI3 } from "@ai-sdk/openai";
 import { generateObject as generateObject3 } from "ai";
@@ -2237,10 +1864,10 @@ function getModel3() {
 async function gatherContextFiles(repoDir) {
   const sections = [];
   for (const fileName of CONTEXT_FILES) {
-    const filePath = path8.join(repoDir, fileName);
-    if (fs7.existsSync(filePath)) {
+    const filePath = path6.join(repoDir, fileName);
+    if (fs5.existsSync(filePath)) {
       try {
-        let content = fs7.readFileSync(filePath, "utf-8");
+        let content = fs5.readFileSync(filePath, "utf-8");
         if (content.length > MAX_FILE_CHARS) {
           content = `${content.slice(0, MAX_FILE_CHARS)}
 ... (truncated)`;
@@ -2292,14 +1919,14 @@ async function generateBuildPlan(repoDir) {
 }
 
 // src/commands/scan.ts
-var defaultDependencies6 = {
-  createDocCov: (options) => new DocCov5(options),
+var defaultDependencies5 = {
+  createDocCov: (options) => new DocCov3(options),
   log: console.log,
   error: console.error
 };
 function registerScanCommand(program, dependencies = {}) {
   const { createDocCov, log, error } = {
-    ...defaultDependencies6,
+    ...defaultDependencies5,
     ...dependencies
   };
   program.command("scan <url>").description("Analyze docs coverage for any public GitHub repository").option("--ref <branch>", "Branch or tag to analyze").option("--package <name>", "Target package in monorepo").option("--output <format>", "Output format: text or json", "text").option("--no-cleanup", "Keep cloned repo (for debugging)").option("--skip-install", "Skip dependency installation (faster, but may limit type resolution)").option("--skip-resolve", "Skip external type resolution from node_modules").option("--save-spec <path>", "Save full OpenPkg spec to file").action(async (url, options) => {
@@ -2309,12 +1936,12 @@ function registerScanCommand(program, dependencies = {}) {
       const cloneUrl = buildCloneUrl(parsed);
       const displayUrl = buildDisplayUrl(parsed);
       log("");
-      log(chalk8.bold(`Scanning ${displayUrl}`));
-      log(chalk8.gray(`Branch/tag: ${parsed.ref}`));
+      log(chalk6.bold(`Scanning ${displayUrl}`));
+      log(chalk6.gray(`Branch/tag: ${parsed.ref}`));
       log("");
-      tempDir = path9.join(os.tmpdir(), `doccov-scan-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-      fs8.mkdirSync(tempDir, { recursive: true });
-      process.stdout.write(chalk8.cyan(`> Cloning ${parsed.owner}/${parsed.repo}...
+      tempDir = path7.join(os.tmpdir(), `doccov-scan-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      fs6.mkdirSync(tempDir, { recursive: true });
+      process.stdout.write(chalk6.cyan(`> Cloning ${parsed.owner}/${parsed.repo}...
 `));
       try {
         const git = simpleGit({
@@ -2336,10 +1963,10 @@ function registerScanCommand(program, dependencies = {}) {
         } finally {
           process.env = originalEnv;
         }
-        process.stdout.write(chalk8.green(`✓ Cloned ${parsed.owner}/${parsed.repo}
+        process.stdout.write(chalk6.green(`✓ Cloned ${parsed.owner}/${parsed.repo}
 `));
       } catch (cloneError) {
-        process.stdout.write(chalk8.red(`✗ Failed to clone repository
+        process.stdout.write(chalk6.red(`✗ Failed to clone repository
 `));
         const message = cloneError instanceof Error ? cloneError.message : String(cloneError);
         if (message.includes("Authentication failed") || message.includes("could not read Username") || message.includes("terminal prompts disabled") || message.includes("Invalid username or password") || message.includes("Permission denied")) {
@@ -2355,11 +1982,11 @@ function registerScanCommand(program, dependencies = {}) {
         }
         throw new Error(`Clone failed: ${message}`);
       }
-      const fileSystem = new NodeFileSystem5(tempDir);
+      const fileSystem = new NodeFileSystem3(tempDir);
       if (options.skipInstall) {
-        log(chalk8.gray("Skipping dependency installation (--skip-install)"));
+        log(chalk6.gray("Skipping dependency installation (--skip-install)"));
       } else {
-        process.stdout.write(chalk8.cyan(`> Installing dependencies...
+        process.stdout.write(chalk6.cyan(`> Installing dependencies...
 `));
         const installErrors = [];
         try {
@@ -2409,56 +2036,56 @@ function registerScanCommand(program, dependencies = {}) {
             }
           }
           if (installed) {
-            process.stdout.write(chalk8.green(`✓ Dependencies installed
+            process.stdout.write(chalk6.green(`✓ Dependencies installed
 `));
           } else {
-            process.stdout.write(chalk8.yellow(`⚠ Could not install dependencies (analysis may be limited)
+            process.stdout.write(chalk6.yellow(`⚠ Could not install dependencies (analysis may be limited)
 `));
             for (const err of installErrors) {
-              log(chalk8.gray(`  ${err}`));
+              log(chalk6.gray(`  ${err}`));
             }
           }
         } catch (outerError) {
           const msg = outerError instanceof Error ? outerError.message : String(outerError);
-          process.stdout.write(chalk8.yellow(`⚠ Could not install dependencies: ${msg.slice(0, 100)}
+          process.stdout.write(chalk6.yellow(`⚠ Could not install dependencies: ${msg.slice(0, 100)}
 `));
           for (const err of installErrors) {
-            log(chalk8.gray(`  ${err}`));
+            log(chalk6.gray(`  ${err}`));
           }
         }
       }
       let targetDir = tempDir;
       let packageName;
-      const mono = await detectMonorepo5(fileSystem);
+      const mono = await detectMonorepo(fileSystem);
       if (mono.isMonorepo) {
         if (!options.package) {
           error("");
-          error(chalk8.red(`Monorepo detected with ${mono.packages.length} packages. Specify target with --package:`));
+          error(chalk6.red(`Monorepo detected with ${mono.packages.length} packages. Specify target with --package:`));
           error("");
           error(formatPackageList(mono.packages));
           error("");
           throw new Error("Monorepo requires --package flag");
         }
-        const pkg = findPackageByName5(mono.packages, options.package);
+        const pkg = findPackageByName(mono.packages, options.package);
         if (!pkg) {
           error("");
-          error(chalk8.red(`Package "${options.package}" not found. Available packages:`));
+          error(chalk6.red(`Package "${options.package}" not found. Available packages:`));
           error("");
           error(formatPackageList(mono.packages));
           error("");
           throw new Error(`Package not found: ${options.package}`);
         }
-        targetDir = path9.join(tempDir, pkg.path);
+        targetDir = path7.join(tempDir, pkg.path);
         packageName = pkg.name;
-        log(chalk8.gray(`Analyzing package: ${packageName}`));
+        log(chalk6.gray(`Analyzing package: ${packageName}`));
       }
-      process.stdout.write(chalk8.cyan(`> Detecting entry point...
+      process.stdout.write(chalk6.cyan(`> Detecting entry point...
 `));
       let entryPath;
-      const targetFs = mono.isMonorepo ? new NodeFileSystem5(targetDir) : fileSystem;
+      const targetFs = mono.isMonorepo ? new NodeFileSystem3(targetDir) : fileSystem;
       let buildFailed = false;
       const runLlmFallback = async (reason) => {
-        process.stdout.write(chalk8.cyan(`> ${reason}, trying LLM fallback...
+        process.stdout.write(chalk6.cyan(`> ${reason}, trying LLM fallback...
 `));
         const plan = await generateBuildPlan(targetDir);
         if (!plan) {
@@ -2467,117 +2094,100 @@ function registerScanCommand(program, dependencies = {}) {
         if (plan.buildCommands.length > 0) {
           const { execSync } = await import("node:child_process");
           for (const cmd of plan.buildCommands) {
-            log(chalk8.gray(`  Running: ${cmd}`));
+            log(chalk6.gray(`  Running: ${cmd}`));
             try {
               execSync(cmd, { cwd: targetDir, stdio: "pipe", timeout: 300000 });
             } catch (buildError) {
               buildFailed = true;
               const msg = buildError instanceof Error ? buildError.message : String(buildError);
               if (msg.includes("rustc") || msg.includes("cargo") || msg.includes("wasm-pack")) {
-                log(chalk8.yellow(`  ⚠ Build requires Rust toolchain (not available)`));
+                log(chalk6.yellow(`  ⚠ Build requires Rust toolchain (not available)`));
               } else if (msg.includes("rimraf") || msg.includes("command not found")) {
-                log(chalk8.yellow(`  ⚠ Build failed: missing dependencies`));
+                log(chalk6.yellow(`  ⚠ Build failed: missing dependencies`));
               } else {
-                log(chalk8.yellow(`  ⚠ Build failed: ${msg.slice(0, 80)}`));
+                log(chalk6.yellow(`  ⚠ Build failed: ${msg.slice(0, 80)}`));
               }
             }
           }
         }
         if (plan.notes) {
-          log(chalk8.gray(`  Note: ${plan.notes}`));
+          log(chalk6.gray(`  Note: ${plan.notes}`));
         }
         return plan.entryPoint;
       };
       try {
-        const entry = await detectEntryPoint5(targetFs);
+        const entry = await detectEntryPoint(targetFs);
         const buildInfo = await detectBuildInfo(targetFs);
         const needsBuildStep = entry.isDeclarationOnly && buildInfo.exoticIndicators.wasm;
         if (needsBuildStep) {
-          process.stdout.write(chalk8.cyan(`> Detected .d.ts entry with WASM indicators...
+          process.stdout.write(chalk6.cyan(`> Detected .d.ts entry with WASM indicators...
 `));
           const llmEntry = await runLlmFallback("WASM project detected");
           if (llmEntry) {
-            entryPath = path9.join(targetDir, llmEntry);
+            entryPath = path7.join(targetDir, llmEntry);
             if (buildFailed) {
-              process.stdout.write(chalk8.green(`✓ Entry point: ${llmEntry} (using pre-committed declarations)
+              process.stdout.write(chalk6.green(`✓ Entry point: ${llmEntry} (using pre-committed declarations)
 `));
-              log(chalk8.gray("  Coverage may be limited - generated .d.ts files typically lack JSDoc"));
+              log(chalk6.gray("  Coverage may be limited - generated .d.ts files typically lack JSDoc"));
             } else {
-              process.stdout.write(chalk8.green(`✓ Entry point: ${llmEntry} (from LLM fallback - WASM project)
+              process.stdout.write(chalk6.green(`✓ Entry point: ${llmEntry} (from LLM fallback - WASM project)
 `));
             }
           } else {
-            entryPath = path9.join(targetDir, entry.path);
-            process.stdout.write(chalk8.green(`✓ Entry point: ${entry.path} (from ${entry.source})
+            entryPath = path7.join(targetDir, entry.path);
+            process.stdout.write(chalk6.green(`✓ Entry point: ${entry.path} (from ${entry.source})
 `));
-            log(chalk8.yellow("  ⚠ WASM project detected but no API key - analysis may be limited"));
+            log(chalk6.yellow("  ⚠ WASM project detected but no API key - analysis may be limited"));
           }
         } else {
-          entryPath = path9.join(targetDir, entry.path);
-          process.stdout.write(chalk8.green(`✓ Entry point: ${entry.path} (from ${entry.source})
+          entryPath = path7.join(targetDir, entry.path);
+          process.stdout.write(chalk6.green(`✓ Entry point: ${entry.path} (from ${entry.source})
 `));
         }
       } catch (entryError) {
         const llmEntry = await runLlmFallback("Heuristics failed");
         if (llmEntry) {
-          entryPath = path9.join(targetDir, llmEntry);
-          process.stdout.write(chalk8.green(`✓ Entry point: ${llmEntry} (from LLM fallback)
+          entryPath = path7.join(targetDir, llmEntry);
+          process.stdout.write(chalk6.green(`✓ Entry point: ${llmEntry} (from LLM fallback)
 `));
         } else {
-          process.stdout.write(chalk8.red(`✗ Could not detect entry point (set OPENAI_API_KEY for smart fallback)
+          process.stdout.write(chalk6.red(`✗ Could not detect entry point (set OPENAI_API_KEY for smart fallback)
 `));
           throw entryError;
         }
       }
-      process.stdout.write(chalk8.cyan(`> Analyzing documentation coverage...
+      process.stdout.write(chalk6.cyan(`> Analyzing documentation coverage...
 `));
       let result;
       try {
         const resolveExternalTypes = !options.skipResolve;
         const doccov = createDocCov({ resolveExternalTypes });
         result = await doccov.analyzeFileWithDiagnostics(entryPath);
-        process.stdout.write(chalk8.green(`✓ Analysis complete
+        process.stdout.write(chalk6.green(`✓ Analysis complete
 `));
       } catch (analysisError) {
-        process.stdout.write(chalk8.red(`✗ Analysis failed
+        process.stdout.write(chalk6.red(`✗ Analysis failed
 `));
         throw analysisError;
       }
       const spec = result.spec;
-      const coverageScore = spec.docs?.coverageScore ?? 0;
       if (options.saveSpec) {
-        const specPath = path9.resolve(process.cwd(), options.saveSpec);
-        fs8.writeFileSync(specPath, JSON.stringify(spec, null, 2));
-        log(chalk8.green(`✓ Saved spec to ${options.saveSpec}`));
-      }
-      const undocumented = [];
-      const driftIssues = [];
-      for (const exp of spec.exports ?? []) {
-        const expDocs = exp.docs;
-        if (!expDocs)
-          continue;
-        if ((expDocs.missing?.length ?? 0) > 0 || (expDocs.coverageScore ?? 0) < 100) {
-          undocumented.push(exp.name);
-        }
-        for (const d of expDocs.drift ?? []) {
-          driftIssues.push({
-            export: exp.name,
-            type: d.type,
-            issue: d.issue
-          });
-        }
+        const specPath = path7.resolve(process.cwd(), options.saveSpec);
+        fs6.writeFileSync(specPath, JSON.stringify(spec, null, 2));
+        log(chalk6.green(`✓ Saved spec to ${options.saveSpec}`));
       }
+      const summary = extractSpecSummary(spec);
       const scanResult = {
         owner: parsed.owner,
         repo: parsed.repo,
         ref: parsed.ref,
         packageName,
-        coverage: coverageScore,
-        exportCount: spec.exports?.length ?? 0,
-        typeCount: spec.types?.length ?? 0,
-        driftCount: driftIssues.length,
-        undocumented,
-        drift: driftIssues
+        coverage: summary.coverage,
+        exportCount: summary.exportCount,
+        typeCount: summary.typeCount,
+        driftCount: summary.driftCount,
+        undocumented: summary.undocumented,
+        drift: summary.drift
       };
       if (options.output === "json") {
         log(JSON.stringify(scanResult, null, 2));
@@ -2585,186 +2195,68 @@ function registerScanCommand(program, dependencies = {}) {
         printTextResult(scanResult, log);
       }
     } catch (commandError) {
-      error(chalk8.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk6.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     } finally {
       if (tempDir && options.cleanup !== false) {
         fsPromises.rm(tempDir, { recursive: true, force: true }).catch(() => {});
       } else if (tempDir) {
-        log(chalk8.gray(`Repo preserved at: ${tempDir}`));
+        log(chalk6.gray(`Repo preserved at: ${tempDir}`));
       }
     }
   });
 }
 function printTextResult(result, log) {
   log("");
-  log(chalk8.bold("DocCov Scan Results"));
+  log(chalk6.bold("DocCov Scan Results"));
   log("─".repeat(40));
   const repoName = result.packageName ? `${result.owner}/${result.repo} (${result.packageName})` : `${result.owner}/${result.repo}`;
-  log(`Repository: ${chalk8.cyan(repoName)}`);
-  log(`Branch: ${chalk8.gray(result.ref)}`);
+  log(`Repository: ${chalk6.cyan(repoName)}`);
+  log(`Branch: ${chalk6.gray(result.ref)}`);
   log("");
-  const coverageColor = result.coverage >= 80 ? chalk8.green : result.coverage >= 50 ? chalk8.yellow : chalk8.red;
-  log(chalk8.bold("Coverage"));
+  const coverageColor = result.coverage >= 80 ? chalk6.green : result.coverage >= 50 ? chalk6.yellow : chalk6.red;
+  log(chalk6.bold("Coverage"));
   log(`  ${coverageColor(`${result.coverage}%`)}`);
   log("");
-  log(chalk8.bold("Stats"));
+  log(chalk6.bold("Stats"));
   log(`  ${result.exportCount} exports`);
   log(`  ${result.typeCount} types`);
   log(`  ${result.undocumented.length} undocumented`);
   log(`  ${result.driftCount} drift issues`);
   if (result.undocumented.length > 0) {
     log("");
-    log(chalk8.bold("Undocumented Exports"));
+    log(chalk6.bold("Undocumented Exports"));
     for (const name of result.undocumented.slice(0, 10)) {
-      log(chalk8.yellow(`  ! ${name}`));
+      log(chalk6.yellow(`  ! ${name}`));
     }
     if (result.undocumented.length > 10) {
-      log(chalk8.gray(`  ... and ${result.undocumented.length - 10} more`));
+      log(chalk6.gray(`  ... and ${result.undocumented.length - 10} more`));
     }
   }
   if (result.drift.length > 0) {
     log("");
-    log(chalk8.bold("Drift Issues"));
+    log(chalk6.bold("Drift Issues"));
     for (const d of result.drift.slice(0, 5)) {
-      log(chalk8.red(`  • ${d.export}: ${d.issue}`));
+      log(chalk6.red(`  • ${d.export}: ${d.issue}`));
     }
     if (result.drift.length > 5) {
-      log(chalk8.gray(`  ... and ${result.drift.length - 5} more`));
+      log(chalk6.gray(`  ... and ${result.drift.length - 5} more`));
     }
   }
   log("");
 }
 
-// src/commands/typecheck.ts
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
-import {
-  DocCov as DocCov6,
-  detectEntryPoint as detectEntryPoint6,
-  detectMonorepo as detectMonorepo6,
-  findPackageByName as findPackageByName6,
-  NodeFileSystem as NodeFileSystem6,
-  typecheckExamples as typecheckExamples2
-} from "@doccov/sdk";
-import chalk9 from "chalk";
-var defaultDependencies7 = {
-  createDocCov: (options) => new DocCov6(options),
-  log: console.log,
-  error: console.error
-};
-function registerTypecheckCommand(program, dependencies = {}) {
-  const { createDocCov, log, error } = {
-    ...defaultDependencies7,
-    ...dependencies
-  };
-  program.command("typecheck [entry]").description("Type-check @example blocks without executing them").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--skip-resolve", "Skip external type resolution").action(async (entry, options) => {
-    try {
-      let targetDir = options.cwd;
-      let entryFile = entry;
-      const fileSystem = new NodeFileSystem6(options.cwd);
-      if (options.package) {
-        const mono = await detectMonorepo6(fileSystem);
-        if (!mono.isMonorepo) {
-          throw new Error("Not a monorepo. Remove --package flag.");
-        }
-        const pkg = findPackageByName6(mono.packages, options.package);
-        if (!pkg) {
-          const available = mono.packages.map((p) => p.name).join(", ");
-          throw new Error(`Package "${options.package}" not found. Available: ${available}`);
-        }
-        targetDir = path10.join(options.cwd, pkg.path);
-        log(chalk9.gray(`Found package at ${pkg.path}`));
-      }
-      if (!entryFile) {
-        const targetFs = new NodeFileSystem6(targetDir);
-        const detected = await detectEntryPoint6(targetFs);
-        entryFile = path10.join(targetDir, detected.path);
-        log(chalk9.gray(`Auto-detected entry point: ${detected.path}`));
-      } else {
-        entryFile = path10.resolve(targetDir, entryFile);
-        if (fs9.existsSync(entryFile) && fs9.statSync(entryFile).isDirectory()) {
-          targetDir = entryFile;
-          const dirFs = new NodeFileSystem6(entryFile);
-          const detected = await detectEntryPoint6(dirFs);
-          entryFile = path10.join(entryFile, detected.path);
-          log(chalk9.gray(`Auto-detected entry point: ${detected.path}`));
-        }
-      }
-      const resolveExternalTypes = !options.skipResolve;
-      process.stdout.write(chalk9.cyan(`> Analyzing documentation...
-`));
-      const doccov = createDocCov({ resolveExternalTypes });
-      const specResult = await doccov.analyzeFileWithDiagnostics(entryFile);
-      if (!specResult) {
-        throw new Error("Failed to analyze documentation.");
-      }
-      const allExamples = [];
-      for (const exp of specResult.spec.exports ?? []) {
-        if (exp.examples && exp.examples.length > 0) {
-          allExamples.push({ exportName: exp.name, examples: exp.examples });
-        }
-      }
-      if (allExamples.length === 0) {
-        log(chalk9.gray("No @example blocks found"));
-        return;
-      }
-      const totalExamples = allExamples.reduce((sum, e) => sum + e.examples.length, 0);
-      process.stdout.write(chalk9.cyan(`> Type-checking ${totalExamples} example(s)...
-`));
-      const allErrors = [];
-      let passed = 0;
-      let failed = 0;
-      for (const { exportName, examples } of allExamples) {
-        const result = typecheckExamples2(examples, targetDir);
-        for (const err of result.errors) {
-          allErrors.push({ exportName, error: err });
-        }
-        passed += result.passed;
-        failed += result.failed;
-      }
-      if (allErrors.length === 0) {
-        log(chalk9.green(`✓ All ${totalExamples} example(s) passed type checking`));
-        return;
-      }
-      log("");
-      const byExport = new Map;
-      for (const { exportName, error: err } of allErrors) {
-        const existing = byExport.get(exportName) ?? [];
-        existing.push(err);
-        byExport.set(exportName, existing);
-      }
-      for (const [exportName, errors] of byExport) {
-        log(chalk9.red(`✗ ${exportName}`));
-        for (const err of errors) {
-          log(chalk9.gray(`  @example block ${err.exampleIndex + 1}, line ${err.line}:`));
-          log(chalk9.red(`    ${err.message}`));
-        }
-        log("");
-      }
-      log(chalk9.red(`${failed} example(s) failed`) + chalk9.gray(`, ${passed} passed`));
-      process.exit(1);
-    } catch (commandError) {
-      error(chalk9.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
-      process.exit(1);
-    }
-  });
-}
-
 // src/cli.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path11.dirname(__filename2);
-var packageJson = JSON.parse(readFileSync5(path11.join(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = path8.dirname(__filename2);
+var packageJson = JSON.parse(readFileSync4(path8.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);
 registerGenerateCommand(program);
 registerCheckCommand(program);
 registerDiffCommand(program);
 registerInitCommand(program);
-registerLintCommand(program);
-registerReportCommand(program);
 registerScanCommand(program);
-registerTypecheckCommand(program);
 program.command("*", { hidden: true }).action(() => {
   program.outputHelp();
 });