@doccov/cli 0.4.7 → 0.5.0

package/dist/cli.js

@@ -29,10 +29,15 @@ var stringList = z.union([
   z.string(),
   z.array(z.string())
 ]);
+var docsConfigSchema = z.object({
+  include: stringList.optional(),
+  exclude: stringList.optional()
+});
 var docCovConfigSchema = z.object({
   include: stringList.optional(),
   exclude: stringList.optional(),
-  plugins: z.array(z.unknown()).optional()
+  plugins: z.array(z.unknown()).optional(),
+  docs: docsConfigSchema.optional()
 });
 var normalizeList = (value) => {
   if (!value) {
@@ -45,10 +50,22 @@ var normalizeList = (value) => {
 var normalizeConfig = (input) => {
   const include = normalizeList(input.include);
   const exclude = normalizeList(input.exclude);
+  let docs;
+  if (input.docs) {
+    const docsInclude = normalizeList(input.docs.include);
+    const docsExclude = normalizeList(input.docs.exclude);
+    if (docsInclude || docsExclude) {
+      docs = {
+        include: docsInclude,
+        exclude: docsExclude
+      };
+    }
+  }
   return {
     include,
     exclude,
-    plugins: input.plugins
+    plugins: input.plugins,
+    docs
   };
 };
 
@@ -124,21 +141,33 @@ ${formatIssues(issues)}`);
 // src/config/index.ts
 var defineConfig = (config) => config;
 // src/cli.ts
-import { readFileSync as readFileSync9 } from "node:fs";
-import * as path13 from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import * as path9 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
 // src/commands/check.ts
-import * as fs2 from "node:fs";
-import * as path3 from "node:path";
+import * as fs from "node:fs";
+import * as path2 from "node:path";
 import {
+  applyEdits,
+  categorizeDrifts,
+  createSourceFile,
   DocCov,
+  detectEntryPoint,
   detectExampleAssertionFailures,
   detectExampleRuntimeErrors,
+  detectMonorepo,
+  findPackageByName,
+  findJSDocLocation,
+  generateFixesForExport,
   hasNonAssertionComments,
+  mergeFixes,
+  NodeFileSystem,
   parseAssertions,
-  runExamplesWithPackage
+  parseJSDocToPatch,
+  runExamplesWithPackage,
+  serializeJSDoc
 } from "@doccov/sdk";
 import chalk from "chalk";
 import ora from "ora";
@@ -211,158 +240,6 @@ async function parseAssertionsWithLLM(code) {
   }
 }
 
-// src/utils/package-utils.ts
-import * as fs from "node:fs";
-import * as path2 from "node:path";
-async function findEntryPoint(packageDir, preferSource = false) {
-  const packageJsonPath = path2.join(packageDir, "package.json");
-  if (!fs.existsSync(packageJsonPath)) {
-    return findDefaultEntryPoint(packageDir);
-  }
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-  if (preferSource) {
-    const srcIndex = path2.join(packageDir, "src/index.ts");
-    if (fs.existsSync(srcIndex)) {
-      return srcIndex;
-    }
-  }
-  if (!preferSource && (packageJson.types || packageJson.typings)) {
-    const typesPath = path2.join(packageDir, packageJson.types || packageJson.typings);
-    if (fs.existsSync(typesPath)) {
-      return typesPath;
-    }
-  }
-  if (packageJson.exports) {
-    const exportPath = resolveExportsField(packageJson.exports, packageDir);
-    if (exportPath) {
-      return exportPath;
-    }
-  }
-  if (packageJson.main) {
-    const mainBase = packageJson.main.replace(/\.(js|mjs|cjs)$/, "");
-    const dtsPath = path2.join(packageDir, `${mainBase}.d.ts`);
-    if (fs.existsSync(dtsPath)) {
-      return dtsPath;
-    }
-    const tsPath = path2.join(packageDir, `${mainBase}.ts`);
-    if (fs.existsSync(tsPath)) {
-      return tsPath;
-    }
-    const mainPath = path2.join(packageDir, packageJson.main);
-    if (fs.existsSync(mainPath) && fs.statSync(mainPath).isDirectory()) {
-      const indexDts = path2.join(mainPath, "index.d.ts");
-      const indexTs = path2.join(mainPath, "index.ts");
-      if (fs.existsSync(indexDts))
-        return indexDts;
-      if (fs.existsSync(indexTs))
-        return indexTs;
-    }
-  }
-  return findDefaultEntryPoint(packageDir);
-}
-function resolveExportsField(exports, packageDir) {
-  if (typeof exports === "string") {
-    return findTypeScriptFile(path2.join(packageDir, exports));
-  }
-  if (typeof exports === "object" && exports !== null && "." in exports) {
-    const dotExport = exports["."];
-    if (typeof dotExport === "string") {
-      return findTypeScriptFile(path2.join(packageDir, dotExport));
-    }
-    if (dotExport && typeof dotExport === "object") {
-      const dotRecord = dotExport;
-      const typesEntry = dotRecord.types;
-      if (typeof typesEntry === "string") {
-        const typesPath = path2.join(packageDir, typesEntry);
-        if (fs.existsSync(typesPath)) {
-          return typesPath;
-        }
-      }
-      for (const condition of ["import", "require", "default"]) {
-        const target = dotRecord[condition];
-        if (typeof target === "string") {
-          const result = findTypeScriptFile(path2.join(packageDir, target));
-          if (result)
-            return result;
-        }
-      }
-    }
-  }
-  return null;
-}
-function findTypeScriptFile(jsPath) {
-  if (!fs.existsSync(jsPath))
-    return null;
-  const dtsPath = jsPath.replace(/\.(js|mjs|cjs)$/, ".d.ts");
-  if (fs.existsSync(dtsPath)) {
-    return dtsPath;
-  }
-  const tsPath = jsPath.replace(/\.(js|mjs|cjs)$/, ".ts");
-  if (fs.existsSync(tsPath)) {
-    return tsPath;
-  }
-  return null;
-}
-async function findDefaultEntryPoint(packageDir) {
-  const candidates = [
-    "dist/index.d.ts",
-    "dist/index.ts",
-    "lib/index.d.ts",
-    "lib/index.ts",
-    "src/index.ts",
-    "index.d.ts",
-    "index.ts"
-  ];
-  for (const candidate of candidates) {
-    const fullPath = path2.join(packageDir, candidate);
-    if (fs.existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  throw new Error(`Could not find entry point in ${packageDir}`);
-}
-async function findPackageInMonorepo(rootDir, packageName) {
-  const rootPackageJsonPath = path2.join(rootDir, "package.json");
-  if (!fs.existsSync(rootPackageJsonPath)) {
-    return null;
-  }
-  const rootPackageJson = JSON.parse(fs.readFileSync(rootPackageJsonPath, "utf-8"));
-  if (rootPackageJson.name === packageName) {
-    return rootDir;
-  }
-  let workspacePatterns = Array.isArray(rootPackageJson.workspaces) ? rootPackageJson.workspaces : rootPackageJson.workspaces?.packages || [];
-  if (workspacePatterns.length === 0) {
-    const pnpmWorkspacePath = path2.join(rootDir, "pnpm-workspace.yaml");
-    if (fs.existsSync(pnpmWorkspacePath)) {
-      const content = fs.readFileSync(pnpmWorkspacePath, "utf-8");
-      const packagesMatch = content.match(/packages:\s*\n((?:\s*-\s*.+\n?)+)/);
-      if (packagesMatch) {
-        workspacePatterns = packagesMatch[1].split(`
-`).map((line) => line.replace(/^\s*-\s*['"]?/, "").replace(/['"]?\s*$/, "")).filter((line) => line.length > 0);
-      }
-    }
-  }
-  for (const pattern of workspacePatterns) {
-    const searchPath = path2.join(rootDir, pattern.replace("/**", "").replace("/*", ""));
-    if (fs.existsSync(searchPath) && fs.statSync(searchPath).isDirectory()) {
-      const entries = fs.readdirSync(searchPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const packagePath = path2.join(searchPath, entry.name);
-          const packageJsonPath = path2.join(packagePath, "package.json");
-          if (fs.existsSync(packageJsonPath)) {
-            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-            if (packageJson.name === packageName) {
-              return packagePath;
-            }
-          }
-        }
-      }
-    }
-  }
-  return null;
-}
-
 // src/commands/check.ts
 var defaultDependencies = {
   createDocCov: (options) => new DocCov(options),
@@ -370,32 +247,66 @@ var defaultDependencies = {
   log: console.log,
   error: console.error
 };
+function collectDriftsFromExports(exports) {
+  const results = [];
+  for (const exp of exports) {
+    for (const drift of exp.docs?.drift ?? []) {
+      results.push({ export: exp, drift });
+    }
+  }
+  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) {
+    const existing = map.get(exp) ?? [];
+    existing.push(drift);
+    map.set(exp, existing);
+  }
+  return map;
+}
 function registerCheckCommand(program, dependencies = {}) {
   const { createDocCov, spinner, log, error } = {
     ...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("--run-examples", "Execute @example blocks and fail on runtime errors").option("--ignore-drift", "Do not fail on documentation drift").option("--skip-resolve", "Skip external type resolution from node_modules").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("--run-examples", "Execute @example blocks and fail on runtime errors").option("--ignore-drift", "Do not fail on documentation drift").option("--skip-resolve", "Skip external type resolution from node_modules").option("--write", "Auto-fix drift issues").option("--only <types>", "Only fix specific drift types (comma-separated)").option("--dry-run", "Preview fixes without writing (requires --write)").action(async (entry, options) => {
     try {
       let targetDir = options.cwd;
       let entryFile = entry;
+      const fileSystem = new NodeFileSystem(options.cwd);
       if (options.package) {
-        const packageDir = await findPackageInMonorepo(options.cwd, options.package);
-        if (!packageDir) {
-          throw new Error(`Package "${options.package}" not found in monorepo`);
+        const mono = await detectMonorepo(fileSystem);
+        if (!mono.isMonorepo) {
+          throw new Error(`Not a monorepo. Remove --package flag for single-package repos.`);
         }
-        targetDir = packageDir;
-        log(chalk.gray(`Found package at ${path3.relative(options.cwd, packageDir)}`));
+        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}`));
       }
       if (!entryFile) {
-        entryFile = await findEntryPoint(targetDir, true);
-        log(chalk.gray(`Auto-detected entry point: ${path3.relative(targetDir, 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 = path3.resolve(targetDir, entryFile);
-        if (fs2.existsSync(entryFile) && fs2.statSync(entryFile).isDirectory()) {
+        entryFile = path2.resolve(targetDir, entryFile);
+        if (fs.existsSync(entryFile) && fs.statSync(entryFile).isDirectory()) {
           targetDir = entryFile;
-          entryFile = await findEntryPoint(entryFile, true);
-          log(chalk.gray(`Auto-detected entry point: ${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}`));
         }
       }
       const minCoverage = clampCoverage(options.minCoverage ?? 80);
@@ -537,7 +448,116 @@ function registerCheckCommand(program, dependencies = {}) {
       const coverageScore = spec.docs?.coverageScore ?? 0;
       const failingExports = collectFailingExports(spec.exports ?? [], minCoverage);
       const missingExamples = options.requireExamples ? failingExports.filter((item) => item.missing?.includes("examples")) : [];
-      const driftExports = [...collectDrift(spec.exports ?? []), ...runtimeDrifts];
+      let driftExports = [...collectDrift(spec.exports ?? []), ...runtimeDrifts];
+      const fixedDriftKeys = new Set;
+      if (options.write && 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 (fixable.length === 0) {
+            log(chalk.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
+          } else {
+            log("");
+            log(chalk.bold(`Found ${fixable.length} fixable issue(s)`));
+            if (nonFixable.length > 0) {
+              log(chalk.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
+            }
+            log("");
+            const groupedDrifts = groupByExport(filteredDrifts.filter((d) => fixable.includes(d.drift)));
+            const edits = [];
+            const editsByFile = new Map;
+            for (const [exp, drifts] of groupedDrifts) {
+              if (!exp.source?.file) {
+                log(chalk.gray(`  Skipping ${exp.name}: no source location`));
+                continue;
+              }
+              if (exp.source.file.endsWith(".d.ts")) {
+                log(chalk.gray(`  Skipping ${exp.name}: declaration file`));
+                continue;
+              }
+              const filePath = path2.resolve(targetDir, exp.source.file);
+              if (!fs.existsSync(filePath)) {
+                log(chalk.gray(`  Skipping ${exp.name}: file not found`));
+                continue;
+              }
+              const sourceFile = createSourceFile(filePath);
+              const location = findJSDocLocation(sourceFile, exp.name, exp.source.line);
+              if (!location) {
+                log(chalk.gray(`  Skipping ${exp.name}: could not find declaration`));
+                continue;
+              }
+              let existingPatch = {};
+              if (location.hasExisting && location.existingJSDoc) {
+                existingPatch = parseJSDocToPatch(location.existingJSDoc);
+              }
+              const fixes = generateFixesForExport({ ...exp, docs: { ...exp.docs, drift: drifts } }, existingPatch);
+              if (fixes.length === 0)
+                continue;
+              for (const drift of drifts) {
+                fixedDriftKeys.add(`${exp.name}:${drift.issue}`);
+              }
+              const mergedPatch = mergeFixes(fixes, existingPatch);
+              const newJSDoc = serializeJSDoc(mergedPatch, location.indent);
+              const edit = {
+                filePath,
+                symbolName: exp.name,
+                startLine: location.startLine,
+                endLine: location.endLine,
+                hasExisting: location.hasExisting,
+                existingJSDoc: location.existingJSDoc,
+                newJSDoc,
+                indent: location.indent
+              };
+              edits.push(edit);
+              const fileEdits = editsByFile.get(filePath) ?? [];
+              fileEdits.push({ export: exp, edit, fixes, existingPatch });
+              editsByFile.set(filePath, fileEdits);
+            }
+            if (edits.length > 0) {
+              if (options.dryRun) {
+                log(chalk.bold("Dry run - changes that would be made:"));
+                log("");
+                for (const [filePath, fileEdits] of editsByFile) {
+                  const relativePath = path2.relative(targetDir, filePath);
+                  log(chalk.cyan(`  ${relativePath}:`));
+                  for (const { export: exp, edit, fixes } of fileEdits) {
+                    const lineInfo = edit.hasExisting ? `lines ${edit.startLine + 1}-${edit.endLine + 1}` : `line ${edit.startLine + 1}`;
+                    log(`    ${chalk.bold(exp.name)} [${lineInfo}]`);
+                    for (const fix of fixes) {
+                      log(chalk.green(`      + ${fix.description}`));
+                    }
+                  }
+                  log("");
+                }
+                log(chalk.gray("Run without --dry-run to apply these changes."));
+              } else {
+                const applySpinner = spinner("Applying fixes...");
+                applySpinner.start();
+                const applyResult = await applyEdits(edits);
+                if (applyResult.errors.length > 0) {
+                  applySpinner.warn("Some fixes could not be applied");
+                  for (const err of applyResult.errors) {
+                    error(chalk.red(`  ${err.file}: ${err.error}`));
+                  }
+                } else {
+                  applySpinner.succeed(`Applied ${applyResult.editsApplied} fix(es) to ${applyResult.filesModified} file(s)`);
+                }
+                log("");
+                for (const [filePath, fileEdits] of editsByFile) {
+                  const relativePath = path2.relative(targetDir, filePath);
+                  log(chalk.green(`  ✓ ${relativePath}: ${fileEdits.length} fix(es)`));
+                }
+              }
+            }
+          }
+        }
+        if (!options.dryRun) {
+          driftExports = driftExports.filter((d) => !fixedDriftKeys.has(`${d.name}:${d.issue}`));
+        }
+      }
       const coverageFailed = coverageScore < minCoverage;
       const hasMissingExamples = missingExamples.length > 0;
       const hasDrift = !options.ignoreDrift && driftExports.length > 0;
@@ -627,30 +647,131 @@ function collectDrift(exportsList) {
 }
 
 // src/commands/diff.ts
-import * as fs3 from "node:fs";
-import * as path4 from "node:path";
-import { diffSpec } from "@openpkg-ts/spec";
+import * as fs2 from "node:fs";
+import * as path3 from "node:path";
+import {
+  diffSpecWithDocs,
+  getDocsImpactSummary,
+  hasDocsImpact,
+  parseMarkdownFiles
+} from "@doccov/sdk";
 import chalk2 from "chalk";
+import { glob } from "glob";
+
+// src/utils/docs-impact-ai.ts
+import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
+import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
+import { generateObject as generateObject2, generateText } from "ai";
+import { z as z3 } from "zod";
+var CodeBlockUsageSchema = z3.object({
+  isImpacted: z3.boolean().describe("Whether the code block is affected by the change"),
+  reason: z3.string().describe("Explanation of why/why not the code is impacted"),
+  usageType: z3.enum(["direct-call", "import-only", "indirect", "not-used"]).describe("How the export is used in this code block"),
+  suggestedFix: z3.string().optional().describe("If impacted, the suggested code change"),
+  confidence: z3.enum(["high", "medium", "low"]).describe("Confidence level of the analysis")
+});
+var MultiBlockAnalysisSchema = z3.object({
+  groups: z3.array(z3.object({
+    blockIndices: z3.array(z3.number()).describe("Indices of blocks that should run together"),
+    reason: z3.string().describe("Why these blocks are related")
+  })).describe("Groups of related code blocks"),
+  skippedBlocks: z3.array(z3.number()).describe("Indices of blocks that should be skipped (incomplete/illustrative)")
+});
+function getModel2() {
+  const provider = process.env.DOCCOV_LLM_PROVIDER?.toLowerCase();
+  if (provider === "anthropic" || process.env.ANTHROPIC_API_KEY) {
+    const anthropic = createAnthropic2();
+    return anthropic("claude-sonnet-4-20250514");
+  }
+  const openai = createOpenAI2();
+  return openai("gpt-4o-mini");
+}
+function isAIDocsAnalysisAvailable() {
+  return Boolean(process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY);
+}
+async function generateImpactSummary(impacts) {
+  if (!isAIDocsAnalysisAvailable()) {
+    return null;
+  }
+  if (impacts.length === 0) {
+    return "No documentation impacts detected.";
+  }
+  try {
+    const { text } = await generateText({
+      model: getModel2(),
+      prompt: `Summarize these documentation impacts for a GitHub PR comment.
+
+Impacts:
+${impacts.map((i) => `- ${i.file}: ${i.exportName} (${i.changeType})`).join(`
+`)}
+
+Write a brief, actionable summary (2-3 sentences) explaining:
+1. How many files/references are affected
+2. What type of updates are needed
+3. Priority recommendation
+
+Keep it concise and developer-friendly.`
+    });
+    return text.trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/diff.ts
 var defaultDependencies2 = {
-  readFileSync: fs3.readFileSync,
+  readFileSync: fs2.readFileSync,
   log: console.log,
   error: console.error
 };
 function registerDiffCommand(program, dependencies = {}) {
-  const { readFileSync: readFileSync3, log, error } = {
+  const { readFileSync: readFileSync2, log, error } = {
     ...defaultDependencies2,
     ...dependencies
   };
-  program.command("diff <base> <head>").description("Compare two OpenPkg specs and report coverage delta").option("--output <format>", "Output format: json or text", "text").option("--fail-on-regression", "Exit with error if coverage regressed").option("--fail-on-drift", "Exit with error if new drift was introduced").action((base, head, options) => {
+  program.command("diff <base> <head>").description("Compare two OpenPkg specs and report coverage delta").option("--output <format>", "Output format: json or text", "text").option("--fail-on-regression", "Exit with error if coverage regressed").option("--fail-on-drift", "Exit with error if new drift was introduced").option("--docs <glob>", "Glob pattern for markdown docs to check for impact", collect, []).option("--fail-on-docs-impact", "Exit with error if docs need updates").option("--ai", "Use AI for deeper analysis and fix suggestions").action(async (base, head, options) => {
     try {
-      const baseSpec = loadSpec(base, readFileSync3);
-      const headSpec = loadSpec(head, readFileSync3);
-      const diff = diffSpec(baseSpec, headSpec);
+      const baseSpec = loadSpec(base, readFileSync2);
+      const headSpec = loadSpec(head, readFileSync2);
+      let markdownFiles;
+      let docsPatterns = options.docs;
+      if (!docsPatterns || docsPatterns.length === 0) {
+        const configResult = await loadDocCovConfig(process.cwd());
+        if (configResult.config?.docs?.include) {
+          docsPatterns = configResult.config.docs.include;
+          log(chalk2.gray(`Using docs patterns from config: ${docsPatterns.join(", ")}`));
+        }
+      }
+      if (docsPatterns && docsPatterns.length > 0) {
+        markdownFiles = await loadMarkdownFiles(docsPatterns);
+      }
+      const diff = diffSpecWithDocs(baseSpec, headSpec, { markdownFiles });
       const format = options.output ?? "text";
       if (format === "json") {
         log(JSON.stringify(diff, null, 2));
       } else {
         printTextDiff(diff, log, error);
+        if (options.ai && diff.docsImpact && hasDocsImpact(diff)) {
+          if (!isAIDocsAnalysisAvailable()) {
+            log(chalk2.yellow(`
+⚠ AI analysis unavailable (set OPENAI_API_KEY or ANTHROPIC_API_KEY)`));
+          } else {
+            log(chalk2.gray(`
+Generating AI summary...`));
+            const impacts = diff.docsImpact.impactedFiles.flatMap((f) => f.references.map((r) => ({
+              file: f.file,
+              exportName: r.exportName,
+              changeType: r.changeType,
+              context: r.context
+            })));
+            const summary = await generateImpactSummary(impacts);
+            if (summary) {
+              log("");
+              log(chalk2.bold("AI Summary"));
+              log(chalk2.cyan(`  ${summary}`));
+            }
+          }
+        }
       }
       if (options.failOnRegression && diff.coverageDelta < 0) {
         error(chalk2.red(`
@@ -664,19 +785,42 @@ ${diff.driftIntroduced} new drift issue(s) introduced`));
         process.exitCode = 1;
         return;
       }
+      if (options.failOnDocsImpact && hasDocsImpact(diff)) {
+        const summary = getDocsImpactSummary(diff);
+        error(chalk2.red(`
+${summary.totalIssues} docs issue(s) require attention`));
+        process.exitCode = 1;
+        return;
+      }
     } catch (commandError) {
       error(chalk2.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     }
   });
 }
-function loadSpec(filePath, readFileSync3) {
-  const resolvedPath = path4.resolve(filePath);
-  if (!fs3.existsSync(resolvedPath)) {
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+async function loadMarkdownFiles(patterns) {
+  const files = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, { nodir: true });
+    for (const filePath of matches) {
+      try {
+        const content = fs2.readFileSync(filePath, "utf-8");
+        files.push({ path: filePath, content });
+      } catch {}
+    }
+  }
+  return parseMarkdownFiles(files);
+}
+function loadSpec(filePath, readFileSync2) {
+  const resolvedPath = path3.resolve(filePath);
+  if (!fs2.existsSync(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   try {
-    const content = readFileSync3(resolvedPath, "utf-8");
+    const content = readFileSync2(resolvedPath, "utf-8");
     return JSON.parse(content);
   } catch (parseError) {
     throw new Error(`Failed to parse ${filePath}: ${parseError instanceof Error ? parseError.message : parseError}`);
@@ -744,218 +888,61 @@ function printTextDiff(diff, log, _error) {
       log(chalk2.green(`  -${diff.driftResolved} drift issue(s) resolved`));
     }
   }
-  log("");
-}
-
-// src/commands/fix.ts
-import * as fs4 from "node:fs";
-import * as path5 from "node:path";
-import {
-  applyEdits,
-  categorizeDrifts,
-  createSourceFile,
-  DocCov as DocCov2,
-  findJSDocLocation,
-  generateFixesForExport,
-  mergeFixes,
-  parseJSDocToPatch,
-  serializeJSDoc
-} from "@doccov/sdk";
-import chalk3 from "chalk";
-import ora2 from "ora";
-var defaultDependencies3 = {
-  createDocCov: (options) => new DocCov2(options),
-  spinner: (text) => ora2(text),
-  log: console.log,
-  error: console.error
-};
-function collectDrifts(exports) {
-  const results = [];
-  for (const exp of exports) {
-    const drifts = exp.docs?.drift ?? [];
-    for (const drift of drifts) {
-      results.push({ export: exp, drift });
-    }
-  }
-  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) {
-    const existing = map.get(exp) ?? [];
-    existing.push(drift);
-    map.set(exp, existing);
-  }
-  return map;
-}
-function registerFixCommand(program, dependencies = {}) {
-  const { createDocCov, spinner, log, error } = {
-    ...defaultDependencies3,
-    ...dependencies
-  };
-  program.command("fix [entry]").description("Automatically fix documentation drift").option("--cwd <dir>", "Working directory", process.cwd()).option("--package <name>", "Target package name (for monorepos)").option("--dry-run", "Preview changes without writing").option("--only <types>", "Only fix specific drift types (comma-separated)").option("--skip-resolve", "Skip external type resolution from node_modules").action(async (entry, options) => {
-    try {
-      let targetDir = options.cwd;
-      let entryFile = entry;
-      if (options.package) {
-        const packageDir = await findPackageInMonorepo(options.cwd, options.package);
-        if (!packageDir) {
-          throw new Error(`Package "${options.package}" not found in monorepo`);
+  if (diff.docsImpact) {
+    log("");
+    log(chalk2.bold("Docs Impact"));
+    const { impactedFiles, missingDocs, stats } = diff.docsImpact;
+    log(chalk2.gray(`  Scanned ${stats.filesScanned} file(s), ${stats.codeBlocksFound} code block(s)`));
+    if (impactedFiles.length > 0) {
+      log("");
+      log(chalk2.yellow(`  ${impactedFiles.length} file(s) need updates:`));
+      for (const file of impactedFiles.slice(0, 10)) {
+        log(chalk2.yellow(`    \uD83D\uDCC4 ${file.file}`));
+        for (const ref of file.references.slice(0, 3)) {
+          const changeLabel = ref.changeType === "signature-changed" ? "signature changed" : ref.changeType === "removed" ? "removed" : "deprecated";
+          log(chalk2.gray(`       Line ${ref.line}: ${ref.exportName} (${changeLabel})`));
         }
-        targetDir = packageDir;
-        log(chalk3.gray(`Found package at ${path5.relative(options.cwd, packageDir)}`));
-      }
-      if (!entryFile) {
-        entryFile = await findEntryPoint(targetDir, true);
-        log(chalk3.gray(`Auto-detected entry point: ${path5.relative(targetDir, entryFile)}`));
-      } else {
-        entryFile = path5.resolve(targetDir, entryFile);
-        if (fs4.existsSync(entryFile) && fs4.statSync(entryFile).isDirectory()) {
-          targetDir = entryFile;
-          entryFile = await findEntryPoint(entryFile, true);
-          log(chalk3.gray(`Auto-detected entry point: ${entryFile}`));
+        if (file.references.length > 3) {
+          log(chalk2.gray(`       ... and ${file.references.length - 3} more reference(s)`));
         }
       }
-      const resolveExternalTypes = !options.skipResolve;
-      const analyzeSpinner = spinner("Analyzing documentation...");
-      analyzeSpinner.start();
-      const doccov = createDocCov({ resolveExternalTypes });
-      const result = await doccov.analyzeFileWithDiagnostics(entryFile);
-      const spec = result.spec;
-      analyzeSpinner.succeed("Analysis complete");
-      const allDrifts = collectDrifts(spec.exports ?? []);
-      if (allDrifts.length === 0) {
-        log(chalk3.green("No drift issues found. Documentation is in sync!"));
-        return;
-      }
-      const filteredDrifts = filterDriftsByType(allDrifts, options.only);
-      if (filteredDrifts.length === 0) {
-        log(chalk3.yellow("No matching drift issues for the specified types."));
-        return;
-      }
-      const { fixable, nonFixable } = categorizeDrifts(filteredDrifts.map((d) => d.drift));
-      if (fixable.length === 0) {
-        log(chalk3.yellow(`Found ${nonFixable.length} drift issue(s), but none are auto-fixable.`));
-        log(chalk3.gray("Non-fixable drift types require manual intervention:"));
-        for (const drift of nonFixable.slice(0, 5)) {
-          log(chalk3.gray(`  • ${drift.type}: ${drift.issue}`));
-        }
-        return;
+      if (impactedFiles.length > 10) {
+        log(chalk2.gray(`    ... and ${impactedFiles.length - 10} more file(s)`));
       }
+    }
+    if (missingDocs.length > 0) {
       log("");
-      log(chalk3.bold(`Found ${fixable.length} fixable issue(s)`));
-      if (nonFixable.length > 0) {
-        log(chalk3.gray(`(${nonFixable.length} non-fixable issue(s) skipped)`));
+      log(chalk2.yellow(`  ${missingDocs.length} new export(s) missing docs:`));
+      for (const name of missingDocs.slice(0, 5)) {
+        log(chalk2.yellow(`    • ${name}`));
       }
-      log("");
-      const groupedDrifts = groupByExport(filteredDrifts.filter((d) => fixable.includes(d.drift)));
-      const edits = [];
-      const editsByFile = new Map;
-      for (const [exp, drifts] of groupedDrifts) {
-        if (!exp.source?.file) {
-          log(chalk3.gray(`  Skipping ${exp.name}: no source location`));
-          continue;
-        }
-        if (exp.source.file.endsWith(".d.ts")) {
-          log(chalk3.gray(`  Skipping ${exp.name}: declaration file`));
-          continue;
-        }
-        const filePath = path5.resolve(targetDir, exp.source.file);
-        if (!fs4.existsSync(filePath)) {
-          log(chalk3.gray(`  Skipping ${exp.name}: file not found`));
-          continue;
-        }
-        const sourceFile = createSourceFile(filePath);
-        const location = findJSDocLocation(sourceFile, exp.name, exp.source.line);
-        if (!location) {
-          log(chalk3.gray(`  Skipping ${exp.name}: could not find declaration`));
-          continue;
-        }
-        let existingPatch = {};
-        if (location.hasExisting && location.existingJSDoc) {
-          existingPatch = parseJSDocToPatch(location.existingJSDoc);
-        }
-        const fixes = generateFixesForExport({ ...exp, docs: { ...exp.docs, drift: drifts } }, existingPatch);
-        if (fixes.length === 0)
-          continue;
-        const mergedPatch = mergeFixes(fixes, existingPatch);
-        const newJSDoc = serializeJSDoc(mergedPatch, location.indent);
-        const edit = {
-          filePath,
-          symbolName: exp.name,
-          startLine: location.startLine,
-          endLine: location.endLine,
-          hasExisting: location.hasExisting,
-          existingJSDoc: location.existingJSDoc,
-          newJSDoc,
-          indent: location.indent
-        };
-        edits.push(edit);
-        const fileEdits = editsByFile.get(filePath) ?? [];
-        fileEdits.push({ export: exp, edit, fixes, existingPatch });
-        editsByFile.set(filePath, fileEdits);
-      }
-      if (edits.length === 0) {
-        log(chalk3.yellow("No edits could be generated."));
-        return;
-      }
-      if (options.dryRun) {
-        log(chalk3.bold("Dry run - changes that would be made:"));
-        log("");
-        for (const [filePath, fileEdits] of editsByFile) {
-          const relativePath = path5.relative(targetDir, filePath);
-          log(chalk3.cyan(`  ${relativePath}:`));
-          for (const { export: exp, edit, fixes } of fileEdits) {
-            const lineInfo = edit.hasExisting ? `lines ${edit.startLine + 1}-${edit.endLine + 1}` : `line ${edit.startLine + 1}`;
-            log(`    ${chalk3.bold(exp.name)} [${lineInfo}]`);
-            for (const fix of fixes) {
-              log(chalk3.green(`      + ${fix.description}`));
-            }
-          }
-          log("");
-        }
-        log(chalk3.gray("Run without --dry-run to apply these changes."));
-      } else {
-        const applySpinner = spinner("Applying fixes...");
-        applySpinner.start();
-        const result2 = await applyEdits(edits);
-        if (result2.errors.length > 0) {
-          applySpinner.warn("Some fixes could not be applied");
-          for (const err of result2.errors) {
-            error(chalk3.red(`  ${err.file}: ${err.error}`));
-          }
-        } else {
-          applySpinner.succeed(`Applied ${result2.editsApplied} fix(es) to ${result2.filesModified} file(s)`);
-        }
-        log("");
-        for (const [filePath, fileEdits] of editsByFile) {
-          const relativePath = path5.relative(targetDir, filePath);
-          log(chalk3.green(`  ✓ ${relativePath}: ${fileEdits.length} fix(es)`));
-        }
+      if (missingDocs.length > 5) {
+        log(chalk2.gray(`    ... and ${missingDocs.length - 5} more`));
       }
-    } catch (commandError) {
-      error(chalk3.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
-      process.exitCode = 1;
     }
-  });
+    if (impactedFiles.length === 0 && missingDocs.length === 0) {
+      log(chalk2.green("  ✓ No docs impact detected"));
+    }
+  }
+  log("");
 }
 
 // src/commands/generate.ts
-import * as fs6 from "node:fs";
-import * as path7 from "node:path";
-import { DocCov as DocCov3 } from "@doccov/sdk";
+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
+} from "@doccov/sdk";
 import { normalize, validateSpec } from "@openpkg-ts/spec";
-import chalk5 from "chalk";
-import ora3 from "ora";
+import chalk4 from "chalk";
+import ora2 from "ora";
 
 // src/utils/filter-options.ts
-import chalk4 from "chalk";
+import chalk3 from "chalk";
 var unique = (values) => Array.from(new Set(values));
 var parseListFlag = (value) => {
   if (!value) {
@@ -965,7 +952,7 @@ var parseListFlag = (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) => chalk4.cyan(value)).join(", ")}`;
+var formatList = (label, values) => `${label}: ${values.map((value) => chalk3.cyan(value)).join(", ")}`;
 var mergeFilterOptions = (config, cliOptions) => {
   const messages = [];
   const configInclude = config?.include;
@@ -1004,119 +991,11 @@ var mergeFilterOptions = (config, cliOptions) => {
   };
 };
 
-// src/utils/entry-detection.ts
-import * as fs5 from "node:fs";
-import * as path6 from "node:path";
-function detectEntryPoint(repoDir) {
-  const pkgPath = path6.join(repoDir, "package.json");
-  if (!fs5.existsSync(pkgPath)) {
-    throw new Error("No package.json found - not a valid npm package");
-  }
-  let pkg;
-  try {
-    pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
-  } catch {
-    throw new Error("Failed to parse package.json");
-  }
-  if (typeof pkg.types === "string") {
-    const resolved = resolveToTs(repoDir, pkg.types);
-    if (resolved) {
-      return { entryPath: resolved, source: "types" };
-    }
-  }
-  if (typeof pkg.typings === "string") {
-    const resolved = resolveToTs(repoDir, pkg.typings);
-    if (resolved) {
-      return { entryPath: resolved, source: "types" };
-    }
-  }
-  const exports = pkg.exports;
-  if (exports) {
-    const mainExport = exports["."];
-    if (typeof mainExport === "object" && mainExport !== null) {
-      const exportObj = mainExport;
-      if (typeof exportObj.types === "string") {
-        const resolved = resolveToTs(repoDir, exportObj.types);
-        if (resolved) {
-          return { entryPath: resolved, source: "exports" };
-        }
-      }
-    }
-  }
-  if (typeof pkg.main === "string") {
-    const resolved = resolveToTs(repoDir, pkg.main);
-    if (resolved) {
-      return { entryPath: resolved, source: "main" };
-    }
-  }
-  if (typeof pkg.module === "string") {
-    const resolved = resolveToTs(repoDir, pkg.module);
-    if (resolved) {
-      return { entryPath: resolved, source: "module" };
-    }
-  }
-  const commonPaths = [
-    "src/index.ts",
-    "src/index.tsx",
-    "src/main.ts",
-    "index.ts",
-    "lib/index.ts",
-    "source/index.ts"
-  ];
-  for (const p of commonPaths) {
-    if (fs5.existsSync(path6.join(repoDir, p))) {
-      return { entryPath: p, source: "fallback" };
-    }
-  }
-  throw new Error("Could not detect TypeScript entry point. No types field in package.json and no common entry paths found.");
-}
-function resolveToTs(baseDir, filePath) {
-  const normalized = filePath.replace(/^\.\//, "");
-  const isSourceTs = normalized.endsWith(".ts") && !normalized.endsWith(".d.ts") || normalized.endsWith(".tsx");
-  if (isSourceTs) {
-    if (fs5.existsSync(path6.join(baseDir, normalized))) {
-      return normalized;
-    }
-  }
-  const candidates = [];
-  if (normalized.startsWith("dist/")) {
-    const srcPath = normalized.replace(/^dist\//, "src/");
-    candidates.push(srcPath.replace(/\.js$/, ".ts"));
-    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
-    candidates.push(srcPath.replace(/\.js$/, ".tsx"));
-  }
-  if (normalized.startsWith("build/")) {
-    const srcPath = normalized.replace(/^build\//, "src/");
-    candidates.push(srcPath.replace(/\.js$/, ".ts"));
-    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
-  }
-  if (normalized.startsWith("lib/")) {
-    const srcPath = normalized.replace(/^lib\//, "src/");
-    candidates.push(srcPath.replace(/\.js$/, ".ts"));
-    candidates.push(srcPath.replace(/\.d\.ts$/, ".ts"));
-  }
-  candidates.push(normalized.replace(/\.js$/, ".ts"));
-  candidates.push(normalized.replace(/\.d\.ts$/, ".ts"));
-  candidates.push(normalized.replace(/\.js$/, ".tsx"));
-  if (normalized.endsWith(".d.ts")) {
-    const baseName = path6.basename(normalized, ".d.ts");
-    candidates.push(`src/${baseName}.ts`);
-  }
-  for (const candidate of candidates) {
-    if (candidate.endsWith(".d.ts"))
-      continue;
-    if (fs5.existsSync(path6.join(baseDir, candidate))) {
-      return candidate;
-    }
-  }
-  return;
-}
-
 // src/commands/generate.ts
-var defaultDependencies4 = {
-  createDocCov: (options) => new DocCov3(options),
-  writeFileSync: fs6.writeFileSync,
-  spinner: (text) => ora3(text),
+var defaultDependencies3 = {
+  createDocCov: (options) => new DocCov2(options),
+  writeFileSync: fs3.writeFileSync,
+  spinner: (text) => ora2(text),
   log: console.log,
   error: console.error
 };
@@ -1135,38 +1014,46 @@ function stripDocsFields(spec) {
 }
 function formatDiagnosticOutput(prefix, diagnostic, baseDir) {
   const location = diagnostic.location;
-  const relativePath = location?.file ? path7.relative(baseDir, location.file) || location.file : undefined;
-  const locationText = location && relativePath ? chalk5.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
+  const relativePath = location?.file ? path4.relative(baseDir, location.file) || location.file : undefined;
+  const locationText = location && relativePath ? chalk4.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
   const locationPrefix = locationText ? `${locationText} ` : "";
   return `${prefix} ${locationPrefix}${diagnostic.message}`;
 }
 function registerGenerateCommand(program, dependencies = {}) {
   const { createDocCov, writeFileSync: writeFileSync2, spinner, log, error } = {
-    ...defaultDependencies4,
+    ...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) => {
     try {
       let targetDir = options.cwd;
       let entryFile = entry;
+      const fileSystem = new NodeFileSystem2(options.cwd);
       if (options.package) {
-        const packageDir = await findPackageInMonorepo(options.cwd, options.package);
-        if (!packageDir) {
-          throw new Error(`Package "${options.package}" not found in monorepo`);
+        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 = packageDir;
-        log(chalk5.gray(`Found package at ${path7.relative(options.cwd, packageDir)}`));
+        targetDir = path4.join(options.cwd, pkg.path);
+        log(chalk4.gray(`Found package at ${pkg.path}`));
       }
       if (!entryFile) {
-        const detected = detectEntryPoint(targetDir);
-        entryFile = path7.join(targetDir, detected.entryPath);
-        log(chalk5.gray(`Auto-detected entry point: ${detected.entryPath} (from ${detected.source})`));
+        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 = path7.resolve(targetDir, entryFile);
-        if (fs6.existsSync(entryFile) && fs6.statSync(entryFile).isDirectory()) {
-          const detected = detectEntryPoint(entryFile);
-          entryFile = path7.join(entryFile, detected.entryPath);
-          log(chalk5.gray(`Auto-detected entry point: ${detected.entryPath} (from ${detected.source})`));
+        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})`));
         }
       }
       const resolveExternalTypes = !options.skipResolve;
@@ -1178,15 +1065,15 @@ function registerGenerateCommand(program, dependencies = {}) {
       try {
         config = await loadDocCovConfig(targetDir);
         if (config?.filePath) {
-          log(chalk5.gray(`Loaded configuration from ${path7.relative(targetDir, config.filePath)}`));
+          log(chalk4.gray(`Loaded configuration from ${path4.relative(targetDir, config.filePath)}`));
         }
       } catch (configError) {
-        error(chalk5.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
+        error(chalk4.red("Failed to load DocCov config:"), configError instanceof Error ? configError.message : configError);
         process.exit(1);
       }
       const resolvedFilters = mergeFilterOptions(config, cliFilters);
       for (const message of resolvedFilters.messages) {
-        log(chalk5.gray(`• ${message}`));
+        log(chalk4.gray(`• ${message}`));
       }
       const spinnerInstance = spinner("Generating OpenPkg spec...");
       spinnerInstance.start();
@@ -1210,7 +1097,7 @@ function registerGenerateCommand(program, dependencies = {}) {
       if (!result) {
         throw new Error("Failed to produce an OpenPkg spec.");
       }
-      const outputPath = path7.resolve(process.cwd(), options.output);
+      const outputPath = path4.resolve(process.cwd(), options.output);
       let normalized = normalize(result.spec);
       if (options.docs === false) {
         normalized = stripDocsFields(normalized);
@@ -1219,85 +1106,85 @@ function registerGenerateCommand(program, dependencies = {}) {
       if (!validation.ok) {
         spinnerInstance.fail("Spec failed schema validation");
         for (const err of validation.errors) {
-          error(chalk5.red(`schema: ${err.instancePath || "/"} ${err.message}`));
+          error(chalk4.red(`schema: ${err.instancePath || "/"} ${err.message}`));
         }
         process.exit(1);
       }
       writeFileSync2(outputPath, JSON.stringify(normalized, null, 2));
-      log(chalk5.green(`✓ Generated ${options.output}`));
-      log(chalk5.gray(`  ${getArrayLength(normalized.exports)} exports`));
-      log(chalk5.gray(`  ${getArrayLength(normalized.types)} types`));
+      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(chalk5.bold("Diagnostics"));
+        log(chalk4.bold("Diagnostics"));
         for (const diagnostic of result.diagnostics) {
-          const prefix = diagnostic.severity === "error" ? chalk5.red("✖") : diagnostic.severity === "warning" ? chalk5.yellow("⚠") : chalk5.cyan("ℹ");
+          const prefix = diagnostic.severity === "error" ? chalk4.red("✖") : diagnostic.severity === "warning" ? chalk4.yellow("⚠") : chalk4.cyan("ℹ");
           log(formatDiagnosticOutput(prefix, diagnostic, targetDir));
         }
       }
     } catch (commandError) {
-      error(chalk5.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk4.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exit(1);
     }
   });
 }
 
 // src/commands/init.ts
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
-import chalk6 from "chalk";
-var defaultDependencies5 = {
-  fileExists: fs7.existsSync,
-  writeFileSync: fs7.writeFileSync,
-  readFileSync: fs7.readFileSync,
+import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+import chalk5 from "chalk";
+var defaultDependencies4 = {
+  fileExists: fs4.existsSync,
+  writeFileSync: fs4.writeFileSync,
+  readFileSync: fs4.readFileSync,
   log: console.log,
   error: console.error
 };
 function registerInitCommand(program, dependencies = {}) {
-  const { fileExists: fileExists2, writeFileSync: writeFileSync3, readFileSync: readFileSync5, log, error } = {
-    ...defaultDependencies5,
+  const { fileExists: fileExists2, writeFileSync: writeFileSync3, readFileSync: readFileSync3, log, error } = {
+    ...defaultDependencies4,
     ...dependencies
   };
   program.command("init").description("Create a DocCov configuration file").option("--cwd <dir>", "Working directory", process.cwd()).option("--format <format>", "Config format: auto, mjs, js, cjs", "auto").action((options) => {
-    const cwd = path8.resolve(options.cwd);
+    const cwd = path5.resolve(options.cwd);
     const formatOption = String(options.format ?? "auto").toLowerCase();
     if (!isValidFormat(formatOption)) {
-      error(chalk6.red(`Invalid format "${formatOption}". Use auto, mjs, js, or cjs.`));
+      error(chalk5.red(`Invalid format "${formatOption}". Use auto, mjs, js, or cjs.`));
       process.exitCode = 1;
       return;
     }
     const existing = findExistingConfig(cwd, fileExists2);
     if (existing) {
-      error(chalk6.red(`A DocCov config already exists at ${path8.relative(cwd, existing) || "./doccov.config.*"}.`));
+      error(chalk5.red(`A DocCov config already exists at ${path5.relative(cwd, existing) || "./doccov.config.*"}.`));
       process.exitCode = 1;
       return;
     }
-    const packageType = detectPackageType(cwd, fileExists2, readFileSync5);
+    const packageType = detectPackageType(cwd, fileExists2, readFileSync3);
     const targetFormat = resolveFormat(formatOption, packageType);
     if (targetFormat === "js" && packageType !== "module") {
-      log(chalk6.yellow('Package is not marked as "type": "module"; creating doccov.config.js may require enabling ESM.'));
+      log(chalk5.yellow('Package is not marked as "type": "module"; creating doccov.config.js may require enabling ESM.'));
     }
     const fileName = `doccov.config.${targetFormat}`;
-    const outputPath = path8.join(cwd, fileName);
+    const outputPath = path5.join(cwd, fileName);
     if (fileExists2(outputPath)) {
-      error(chalk6.red(`Cannot create ${fileName}; file already exists.`));
+      error(chalk5.red(`Cannot create ${fileName}; file already exists.`));
       process.exitCode = 1;
       return;
     }
     const template = buildTemplate(targetFormat);
     writeFileSync3(outputPath, template, { encoding: "utf8" });
-    log(chalk6.green(`✓ Created ${path8.relative(process.cwd(), outputPath)}`));
+    log(chalk5.green(`✓ Created ${path5.relative(process.cwd(), outputPath)}`));
   });
 }
 var isValidFormat = (value) => {
   return value === "auto" || value === "mjs" || value === "js" || value === "cjs";
 };
 var findExistingConfig = (cwd, fileExists2) => {
-  let current = path8.resolve(cwd);
-  const { root } = path8.parse(current);
+  let current = path5.resolve(cwd);
+  const { root } = path5.parse(current);
   while (true) {
     for (const candidate of DOCCOV_CONFIG_FILENAMES) {
-      const candidatePath = path8.join(current, candidate);
+      const candidatePath = path5.join(current, candidate);
       if (fileExists2(candidatePath)) {
         return candidatePath;
       }
@@ -1305,17 +1192,17 @@ var findExistingConfig = (cwd, fileExists2) => {
     if (current === root) {
       break;
     }
-    current = path8.dirname(current);
+    current = path5.dirname(current);
   }
   return null;
 };
-var detectPackageType = (cwd, fileExists2, readFileSync5) => {
+var detectPackageType = (cwd, fileExists2, readFileSync3) => {
   const packageJsonPath = findNearestPackageJson(cwd, fileExists2);
   if (!packageJsonPath) {
     return;
   }
   try {
-    const raw = readFileSync5(packageJsonPath, "utf8");
+    const raw = readFileSync3(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.type === "module") {
       return "module";
@@ -1327,17 +1214,17 @@ var detectPackageType = (cwd, fileExists2, readFileSync5) => {
   return;
 };
 var findNearestPackageJson = (cwd, fileExists2) => {
-  let current = path8.resolve(cwd);
-  const { root } = path8.parse(current);
+  let current = path5.resolve(cwd);
+  const { root } = path5.parse(current);
   while (true) {
-    const candidate = path8.join(current, "package.json");
+    const candidate = path5.join(current, "package.json");
     if (fileExists2(candidate)) {
       return candidate;
     }
     if (current === root) {
       break;
     }
-    current = path8.dirname(current);
+    current = path5.dirname(current);
   }
   return null;
 };
@@ -1373,11 +1260,17 @@ var buildTemplate = (format) => {
 };
 
 // src/commands/report.ts
-import * as fs8 from "node:fs";
-import * as path9 from "node:path";
-import { DocCov as DocCov4 } from "@doccov/sdk";
-import chalk7 from "chalk";
-import ora4 from "ora";
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
+import {
+  DocCov as DocCov3,
+  detectEntryPoint as detectEntryPoint3,
+  detectMonorepo as detectMonorepo3,
+  findPackageByName as findPackageByName3,
+  NodeFileSystem as NodeFileSystem3
+} from "@doccov/sdk";
+import chalk6 from "chalk";
+import ora3 from "ora";
 
 // src/reports/markdown.ts
 function bar(pct, width = 10) {
@@ -1554,25 +1447,34 @@ function registerReportCommand(program) {
     try {
       let spec;
       if (options.spec) {
-        const specPath = path9.resolve(options.cwd, options.spec);
-        spec = JSON.parse(fs8.readFileSync(specPath, "utf-8"));
+        const specPath = path6.resolve(options.cwd, options.spec);
+        spec = JSON.parse(fs5.readFileSync(specPath, "utf-8"));
       } else {
         let targetDir = options.cwd;
         let entryFile = entry;
+        const fileSystem = new NodeFileSystem3(options.cwd);
         if (options.package) {
-          const packageDir = await findPackageInMonorepo(options.cwd, options.package);
-          if (!packageDir)
-            throw new Error(`Package "${options.package}" not found`);
-          targetDir = packageDir;
+          const mono = await detectMonorepo3(fileSystem);
+          if (!mono.isMonorepo) {
+            throw new Error(`Not a monorepo. Remove --package flag for single-package repos.`);
+          }
+          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);
         }
         if (!entryFile) {
-          entryFile = await findEntryPoint(targetDir, true);
+          const targetFs = new NodeFileSystem3(targetDir);
+          const detected = await detectEntryPoint3(targetFs);
+          entryFile = path6.join(targetDir, detected.path);
         } else {
-          entryFile = path9.resolve(targetDir, entryFile);
+          entryFile = path6.resolve(targetDir, entryFile);
         }
-        const spinner = ora4("Analyzing...").start();
+        const spinner = ora3("Analyzing...").start();
         const resolveExternalTypes = !options.skipResolve;
-        const doccov = new DocCov4({ resolveExternalTypes });
+        const doccov = new DocCov3({ resolveExternalTypes });
         const result = await doccov.analyzeFileWithDiagnostics(entryFile);
         spinner.succeed("Analysis complete");
         spec = result.spec;
@@ -1589,26 +1491,36 @@ function registerReportCommand(program) {
         output = renderMarkdown(stats, { limit });
       }
       if (options.out) {
-        const outPath = path9.resolve(options.cwd, options.out);
-        fs8.writeFileSync(outPath, output);
-        console.log(chalk7.green(`Report written to ${outPath}`));
+        const outPath = path6.resolve(options.cwd, options.out);
+        fs5.writeFileSync(outPath, output);
+        console.log(chalk6.green(`Report written to ${outPath}`));
       } else {
         console.log(output);
       }
     } catch (err) {
-      console.error(chalk7.red("Error:"), err instanceof Error ? err.message : err);
+      console.error(chalk6.red("Error:"), err instanceof Error ? err.message : err);
       process.exitCode = 1;
     }
   });
 }
 
 // src/commands/scan.ts
-import * as fs11 from "node:fs";
+import * as fs7 from "node:fs";
 import * as os from "node:os";
-import * as path12 from "node:path";
-import { DocCov as DocCov5 } from "@doccov/sdk";
-import chalk8 from "chalk";
-import ora5 from "ora";
+import * as path8 from "node:path";
+import {
+  DocCov as DocCov4,
+  detectBuildInfo,
+  detectEntryPoint as detectEntryPoint4,
+  detectMonorepo as detectMonorepo4,
+  detectPackageManager,
+  findPackageByName as findPackageByName4,
+  formatPackageList,
+  getInstallCommand,
+  NodeFileSystem as NodeFileSystem4
+} from "@doccov/sdk";
+import chalk7 from "chalk";
+import ora4 from "ora";
 import { simpleGit } from "simple-git";
 
 // src/utils/github-url.ts
@@ -1642,17 +1554,17 @@ function buildDisplayUrl(parsed) {
 }
 
 // src/utils/llm-build-plan.ts
-import * as fs9 from "node:fs";
-import * as path10 from "node:path";
-import { createAnthropic as createAnthropic2 } from "@ai-sdk/anthropic";
-import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
-import { generateObject as generateObject2 } from "ai";
-import { z as z3 } from "zod";
-var BuildPlanSchema = z3.object({
-  installCommand: z3.string().optional().describe("Additional install command if needed"),
-  buildCommands: z3.array(z3.string()).describe('Build steps to run, e.g. ["npm run build:wasm"]'),
-  entryPoint: z3.string().describe("Path to TS/TSX entry file after build"),
-  notes: z3.string().optional().describe("Caveats or warnings")
+import * as fs6 from "node:fs";
+import * as path7 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";
+import { z as z4 } from "zod";
+var BuildPlanSchema = z4.object({
+  installCommand: z4.string().optional().describe("Additional install command if needed"),
+  buildCommands: z4.array(z4.string()).describe('Build steps to run, e.g. ["npm run build:wasm"]'),
+  entryPoint: z4.string().describe("Path to TS/TSX entry file after build"),
+  notes: z4.string().optional().describe("Caveats or warnings")
 });
 var CONTEXT_FILES = [
   "package.json",
@@ -1667,22 +1579,22 @@ var CONTEXT_FILES = [
   "wasm-pack.json"
 ];
 var MAX_FILE_CHARS = 2000;
-function getModel2() {
+function getModel3() {
   const provider = process.env.DOCCOV_LLM_PROVIDER?.toLowerCase();
   if (provider === "anthropic" || process.env.ANTHROPIC_API_KEY) {
-    const anthropic = createAnthropic2();
+    const anthropic = createAnthropic3();
     return anthropic("claude-sonnet-4-20250514");
   }
-  const openai = createOpenAI2();
+  const openai = createOpenAI3();
   return openai("gpt-4o-mini");
 }
 async function gatherContextFiles(repoDir) {
   const sections = [];
   for (const fileName of CONTEXT_FILES) {
-    const filePath = path10.join(repoDir, fileName);
-    if (fs9.existsSync(filePath)) {
+    const filePath = path7.join(repoDir, fileName);
+    if (fs6.existsSync(filePath)) {
       try {
-        let content = fs9.readFileSync(filePath, "utf-8");
+        let content = fs6.readFileSync(filePath, "utf-8");
         if (content.length > MAX_FILE_CHARS) {
           content = `${content.slice(0, MAX_FILE_CHARS)}
 ... (truncated)`;
@@ -1724,8 +1636,8 @@ async function generateBuildPlan(repoDir) {
   if (!context.trim()) {
     return null;
   }
-  const model = getModel2();
-  const { object } = await generateObject2({
+  const model = getModel3();
+  const { object } = await generateObject3({
     model,
     schema: BuildPlanSchema,
     prompt: BUILD_PLAN_PROMPT(context)
@@ -1733,119 +1645,16 @@ async function generateBuildPlan(repoDir) {
   return object;
 }
 
-// src/utils/monorepo-detection.ts
-import * as fs10 from "node:fs";
-import * as path11 from "node:path";
-import { glob } from "glob";
-async function detectMonorepo(repoDir) {
-  const pkgPath = path11.join(repoDir, "package.json");
-  if (!fs10.existsSync(pkgPath)) {
-    return { isMonorepo: false, packages: [], type: "none" };
-  }
-  let pkg;
-  try {
-    pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
-  } catch {
-    return { isMonorepo: false, packages: [], type: "none" };
-  }
-  if (pkg.workspaces) {
-    const patterns = extractWorkspacePatterns(pkg.workspaces);
-    const packages = await resolveWorkspacePackages(repoDir, patterns);
-    return { isMonorepo: packages.length > 0, packages, type: "npm" };
-  }
-  const pnpmPath = path11.join(repoDir, "pnpm-workspace.yaml");
-  if (fs10.existsSync(pnpmPath)) {
-    const patterns = parsePnpmWorkspace(pnpmPath);
-    const packages = await resolveWorkspacePackages(repoDir, patterns);
-    return { isMonorepo: packages.length > 0, packages, type: "pnpm" };
-  }
-  const lernaPath = path11.join(repoDir, "lerna.json");
-  if (fs10.existsSync(lernaPath)) {
-    try {
-      const lerna = JSON.parse(fs10.readFileSync(lernaPath, "utf-8"));
-      const patterns = lerna.packages ?? ["packages/*"];
-      const packages = await resolveWorkspacePackages(repoDir, patterns);
-      return { isMonorepo: packages.length > 0, packages, type: "lerna" };
-    } catch {}
-  }
-  return { isMonorepo: false, packages: [], type: "none" };
-}
-function extractWorkspacePatterns(workspaces) {
-  if (Array.isArray(workspaces)) {
-    return workspaces.filter((w) => typeof w === "string");
-  }
-  if (typeof workspaces === "object" && workspaces !== null) {
-    const ws = workspaces;
-    if (Array.isArray(ws.packages)) {
-      return ws.packages.filter((w) => typeof w === "string");
-    }
-  }
-  return [];
-}
-function parsePnpmWorkspace(filePath) {
-  try {
-    const content = fs10.readFileSync(filePath, "utf-8");
-    const match = content.match(/packages:\s*\n((?:\s+-\s+.+\n?)+)/);
-    if (match) {
-      const lines = match[1].split(`
-`);
-      return lines.map((line) => line.replace(/^\s+-\s+['"]?/, "").replace(/['"]?\s*$/, "")).filter(Boolean);
-    }
-  } catch {}
-  return ["packages/*"];
-}
-async function resolveWorkspacePackages(repoDir, patterns) {
-  const packages = [];
-  for (const pattern of patterns) {
-    const normalizedPattern = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
-    try {
-      const matches = await glob(normalizedPattern, {
-        cwd: repoDir,
-        absolute: false
-      });
-      for (const match of matches) {
-        const pkgJsonPath = path11.join(repoDir, match, "package.json");
-        if (fs10.existsSync(pkgJsonPath)) {
-          try {
-            const pkgJson = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf-8"));
-            packages.push({
-              name: pkgJson.name ?? path11.basename(match),
-              path: path11.join(repoDir, match),
-              relativePath: match
-            });
-          } catch {}
-        }
-      }
-    } catch {}
-  }
-  return packages.sort((a, b) => a.name.localeCompare(b.name));
-}
-async function findPackage(repoDir, packageName) {
-  const mono = await detectMonorepo(repoDir);
-  if (!mono.isMonorepo) {
-    return;
-  }
-  return mono.packages.find((pkg) => pkg.name === packageName || pkg.relativePath === packageName);
-}
-function formatPackageList(packages, limit = 10) {
-  const lines = packages.slice(0, limit).map((pkg) => `  --package ${pkg.name}`);
-  if (packages.length > limit) {
-    lines.push(`  ... and ${packages.length - limit} more`);
-  }
-  return lines.join(`
-`);
-}
-
 // src/commands/scan.ts
-var defaultDependencies6 = {
-  createDocCov: (options) => new DocCov5(options),
-  spinner: (text) => ora5(text),
+var defaultDependencies5 = {
+  createDocCov: (options) => new DocCov4(options),
+  spinner: (text) => ora4(text),
   log: console.log,
   error: console.error
 };
 function registerScanCommand(program, dependencies = {}) {
   const { createDocCov, spinner, 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) => {
@@ -1855,11 +1664,11 @@ 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(chalk7.bold(`Scanning ${displayUrl}`));
+      log(chalk7.gray(`Branch/tag: ${parsed.ref}`));
       log("");
-      tempDir = path12.join(os.tmpdir(), `doccov-scan-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-      fs11.mkdirSync(tempDir, { recursive: true });
+      tempDir = path8.join(os.tmpdir(), `doccov-scan-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      fs7.mkdirSync(tempDir, { recursive: true });
       const cloneSpinner = spinner(`Cloning ${parsed.owner}/${parsed.repo}...`);
       cloneSpinner.start();
       try {
@@ -1883,37 +1692,31 @@ function registerScanCommand(program, dependencies = {}) {
         }
         throw new Error(`Clone failed: ${message}`);
       }
+      const fileSystem = new NodeFileSystem4(tempDir);
       if (options.skipInstall) {
-        log(chalk8.gray("Skipping dependency installation (--skip-install)"));
+        log(chalk7.gray("Skipping dependency installation (--skip-install)"));
       } else {
         const installSpinner = spinner("Installing dependencies...");
         installSpinner.start();
         const installErrors = [];
         try {
           const { execSync } = await import("node:child_process");
-          const lockfileCommands = [
-            { file: "pnpm-lock.yaml", cmd: "pnpm install --frozen-lockfile" },
-            { file: "bun.lock", cmd: "bun install --frozen-lockfile" },
-            { file: "bun.lockb", cmd: "bun install --frozen-lockfile" },
-            { file: "yarn.lock", cmd: "yarn install --frozen-lockfile" },
-            { file: "package-lock.json", cmd: "npm install --legacy-peer-deps" }
-          ];
+          const pmInfo = await detectPackageManager(fileSystem);
+          const installCmd = getInstallCommand(pmInfo);
+          const cmdString = installCmd.join(" ");
           let installed = false;
-          for (const { file, cmd } of lockfileCommands) {
-            if (fs11.existsSync(path12.join(tempDir, file))) {
-              try {
-                execSync(cmd, {
-                  cwd: tempDir,
-                  stdio: "pipe",
-                  timeout: 180000
-                });
-                installed = true;
-                break;
-              } catch (cmdError) {
-                const stderr = cmdError?.stderr?.toString() ?? "";
-                const msg = cmdError instanceof Error ? cmdError.message : String(cmdError);
-                installErrors.push(`[${cmd}] ${stderr.slice(0, 150) || msg.slice(0, 150)}`);
-              }
+          if (pmInfo.lockfile) {
+            try {
+              execSync(cmdString, {
+                cwd: tempDir,
+                stdio: "pipe",
+                timeout: 180000
+              });
+              installed = true;
+            } catch (cmdError) {
+              const stderr = cmdError?.stderr?.toString() ?? "";
+              const msg = cmdError instanceof Error ? cmdError.message : String(cmdError);
+              installErrors.push(`[${cmdString}] ${stderr.slice(0, 150) || msg.slice(0, 150)}`);
             }
           }
           if (!installed) {
@@ -1947,67 +1750,46 @@ function registerScanCommand(program, dependencies = {}) {
           } else {
             installSpinner.warn("Could not install dependencies (analysis may be limited)");
             for (const err of installErrors) {
-              log(chalk8.gray(`  ${err}`));
+              log(chalk7.gray(`  ${err}`));
             }
           }
         } catch (outerError) {
           const msg = outerError instanceof Error ? outerError.message : String(outerError);
           installSpinner.warn(`Could not install dependencies: ${msg.slice(0, 100)}`);
           for (const err of installErrors) {
-            log(chalk8.gray(`  ${err}`));
+            log(chalk7.gray(`  ${err}`));
           }
         }
       }
       let targetDir = tempDir;
       let packageName;
-      const mono = await detectMonorepo(tempDir);
+      const mono = await detectMonorepo4(fileSystem);
       if (mono.isMonorepo) {
         if (!options.package) {
           error("");
-          error(chalk8.red(`Monorepo detected with ${mono.packages.length} packages. Specify target with --package:`));
+          error(chalk7.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 = await findPackage(tempDir, options.package);
+        const pkg = findPackageByName4(mono.packages, options.package);
         if (!pkg) {
           error("");
-          error(chalk8.red(`Package "${options.package}" not found. Available packages:`));
+          error(chalk7.red(`Package "${options.package}" not found. Available packages:`));
           error("");
           error(formatPackageList(mono.packages));
           error("");
           throw new Error(`Package not found: ${options.package}`);
         }
-        targetDir = pkg.path;
+        targetDir = path8.join(tempDir, pkg.path);
         packageName = pkg.name;
-        log(chalk8.gray(`Analyzing package: ${packageName}`));
+        log(chalk7.gray(`Analyzing package: ${packageName}`));
       }
       const entrySpinner = spinner("Detecting entry point...");
       entrySpinner.start();
       let entryPath;
-      const needsBuildStep = (pkgDir, repoRoot, entryFile) => {
-        if (!entryFile.endsWith(".d.ts"))
-          return false;
-        const cargoLocations = [
-          path12.join(pkgDir, "Cargo.toml"),
-          path12.join(repoRoot, "Cargo.toml")
-        ];
-        const hasCargoToml = cargoLocations.some((p) => fs11.existsSync(p));
-        const checkWasmScripts = (dir) => {
-          const pkgPath = path12.join(dir, "package.json");
-          if (fs11.existsSync(pkgPath)) {
-            try {
-              const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
-              const scripts = Object.values(pkg.scripts ?? {}).join(" ");
-              return scripts.includes("wasm-pack") || scripts.includes("wasm");
-            } catch {}
-          }
-          return false;
-        };
-        const hasWasmPackScript = checkWasmScripts(pkgDir) || checkWasmScripts(repoRoot);
-        return hasCargoToml || hasWasmPackScript;
-      };
+      const targetFs = mono.isMonorepo ? new NodeFileSystem4(targetDir) : fileSystem;
       let buildFailed = false;
       const runLlmFallback = async (reason) => {
         entrySpinner.text = `${reason}, trying LLM fallback...`;
@@ -2018,53 +1800,55 @@ 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(chalk7.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(chalk7.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(chalk7.yellow(`  ⚠ Build failed: missing dependencies`));
               } else {
-                log(chalk8.yellow(`  ⚠ Build failed: ${msg.slice(0, 80)}`));
+                log(chalk7.yellow(`  ⚠ Build failed: ${msg.slice(0, 80)}`));
               }
             }
           }
         }
         if (plan.notes) {
-          log(chalk8.gray(`  Note: ${plan.notes}`));
+          log(chalk7.gray(`  Note: ${plan.notes}`));
         }
         return plan.entryPoint;
       };
       try {
-        const entry = detectEntryPoint(targetDir);
-        if (needsBuildStep(targetDir, tempDir, entry.entryPath)) {
+        const entry = await detectEntryPoint4(targetFs);
+        const buildInfo = await detectBuildInfo(targetFs);
+        const needsBuildStep = entry.isDeclarationOnly && buildInfo.exoticIndicators.wasm;
+        if (needsBuildStep) {
           entrySpinner.text = "Detected .d.ts entry with WASM indicators...";
           const llmEntry = await runLlmFallback("WASM project detected");
           if (llmEntry) {
-            entryPath = path12.join(targetDir, llmEntry);
+            entryPath = path8.join(targetDir, llmEntry);
             if (buildFailed) {
               entrySpinner.succeed(`Entry point: ${llmEntry} (using pre-committed declarations)`);
-              log(chalk8.gray("  Coverage may be limited - generated .d.ts files typically lack JSDoc"));
+              log(chalk7.gray("  Coverage may be limited - generated .d.ts files typically lack JSDoc"));
             } else {
               entrySpinner.succeed(`Entry point: ${llmEntry} (from LLM fallback - WASM project)`);
             }
           } else {
-            entryPath = path12.join(targetDir, entry.entryPath);
-            entrySpinner.succeed(`Entry point: ${entry.entryPath} (from ${entry.source})`);
-            log(chalk8.yellow("  ⚠ WASM project detected but no API key - analysis may be limited"));
+            entryPath = path8.join(targetDir, entry.path);
+            entrySpinner.succeed(`Entry point: ${entry.path} (from ${entry.source})`);
+            log(chalk7.yellow("  ⚠ WASM project detected but no API key - analysis may be limited"));
           }
         } else {
-          entryPath = path12.join(targetDir, entry.entryPath);
-          entrySpinner.succeed(`Entry point: ${entry.entryPath} (from ${entry.source})`);
+          entryPath = path8.join(targetDir, entry.path);
+          entrySpinner.succeed(`Entry point: ${entry.path} (from ${entry.source})`);
         }
       } catch (entryError) {
         const llmEntry = await runLlmFallback("Heuristics failed");
         if (llmEntry) {
-          entryPath = path12.join(targetDir, llmEntry);
+          entryPath = path8.join(targetDir, llmEntry);
           entrySpinner.succeed(`Entry point: ${llmEntry} (from LLM fallback)`);
         } else {
           entrySpinner.fail("Could not detect entry point (set OPENAI_API_KEY for smart fallback)");
@@ -2086,9 +1870,9 @@ function registerScanCommand(program, dependencies = {}) {
       const spec = result.spec;
       const coverageScore = spec.docs?.coverageScore ?? 0;
       if (options.saveSpec) {
-        const specPath = path12.resolve(process.cwd(), options.saveSpec);
-        fs11.writeFileSync(specPath, JSON.stringify(spec, null, 2));
-        log(chalk8.green(`✓ Saved spec to ${options.saveSpec}`));
+        const specPath = path8.resolve(process.cwd(), options.saveSpec);
+        fs7.writeFileSync(specPath, JSON.stringify(spec, null, 2));
+        log(chalk7.green(`✓ Saved spec to ${options.saveSpec}`));
       }
       const undocumented = [];
       const driftIssues = [];
@@ -2125,7 +1909,7 @@ function registerScanCommand(program, dependencies = {}) {
         printTextResult(scanResult, log);
       }
     } catch (commandError) {
-      error(chalk8.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
+      error(chalk7.red("Error:"), commandError instanceof Error ? commandError.message : commandError);
       process.exitCode = 1;
     } finally {
       if (tempDir && options.cleanup !== false) {
@@ -2135,46 +1919,46 @@ function registerScanCommand(program, dependencies = {}) {
           stdio: "ignore"
         }).unref();
       } else if (tempDir) {
-        log(chalk8.gray(`Repo preserved at: ${tempDir}`));
+        log(chalk7.gray(`Repo preserved at: ${tempDir}`));
       }
     }
   });
 }
 function printTextResult(result, log) {
   log("");
-  log(chalk8.bold("DocCov Scan Results"));
+  log(chalk7.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: ${chalk7.cyan(repoName)}`);
+  log(`Branch: ${chalk7.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 ? chalk7.green : result.coverage >= 50 ? chalk7.yellow : chalk7.red;
+  log(chalk7.bold("Coverage"));
   log(`  ${coverageColor(`${result.coverage}%`)}`);
   log("");
-  log(chalk8.bold("Stats"));
+  log(chalk7.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(chalk7.bold("Undocumented Exports"));
     for (const name of result.undocumented.slice(0, 10)) {
-      log(chalk8.yellow(`  ! ${name}`));
+      log(chalk7.yellow(`  ! ${name}`));
     }
     if (result.undocumented.length > 10) {
-      log(chalk8.gray(`  ... and ${result.undocumented.length - 10} more`));
+      log(chalk7.gray(`  ... and ${result.undocumented.length - 10} more`));
     }
   }
   if (result.drift.length > 0) {
     log("");
-    log(chalk8.bold("Drift Issues"));
+    log(chalk7.bold("Drift Issues"));
     for (const d of result.drift.slice(0, 5)) {
-      log(chalk8.red(`  • ${d.export}: ${d.issue}`));
+      log(chalk7.red(`  • ${d.export}: ${d.issue}`));
     }
     if (result.drift.length > 5) {
-      log(chalk8.gray(`  ... and ${result.drift.length - 5} more`));
+      log(chalk7.gray(`  ... and ${result.drift.length - 5} more`));
     }
   }
   log("");
@@ -2182,14 +1966,13 @@ function printTextResult(result, log) {
 
 // src/cli.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path13.dirname(__filename2);
-var packageJson = JSON.parse(readFileSync9(path13.join(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = path9.dirname(__filename2);
+var packageJson = JSON.parse(readFileSync5(path9.join(__dirname2, "../package.json"), "utf-8"));
 var program = new Command;
 program.name("doccov").description("DocCov - Documentation coverage and drift detection for TypeScript").version(packageJson.version);
 registerGenerateCommand(program);
 registerCheckCommand(program);
 registerDiffCommand(program);
-registerFixCommand(program);
 registerInitCommand(program);
 registerReportCommand(program);
 registerScanCommand(program);