@doccov/sdk 0.29.0 → 0.29.4

package/dist/index.d.ts

@@ -664,7 +664,7 @@ declare function hashFiles(filePaths: string[], cwd: string): Record<string, str
 declare function diffHashes(cached: Record<string, string>, current: Record<string, string>): string[];
 import { OpenPkg as OpenPkg3 } from "@openpkg-ts/spec";
 /** Current cache format version - bump when spec extraction logic changes */
-declare const CACHE_VERSION = "1.1.0";
+declare const CACHE_VERSION = "1.3.0";
 /** Default cache file path */
 declare const SPEC_CACHE_FILE = ".doccov/cache/spec.cache.json";
 /**
@@ -674,6 +674,35 @@ interface SpecCacheConfig {
 	resolveExternalTypes: boolean;
 }
 /**
+* Cached diagnostic from spec analysis.
+*/
+interface CachedDiagnostic {
+	message: string;
+	severity: "error" | "warning" | "info";
+	suggestion?: string;
+	code?: string;
+	location?: {
+		file: string;
+		line?: number;
+		column?: number;
+	};
+}
+/**
+* Cached forgotten info.
+*/
+interface CachedForgottenExport {
+	name: string;
+	definedIn?: string;
+	referencedBy: Array<{
+		typeName: string;
+		exportName: string;
+		location: "return" | "parameter" | "property" | "extends" | "type-parameter";
+		path?: string;
+	}>;
+	isExternal: boolean;
+	fix?: string;
+}
+/**
 * Cached spec with validation metadata.
 */
 interface SpecCache {
@@ -698,6 +727,10 @@ interface SpecCache {
 	config: SpecCacheConfig;
 	/** The cached OpenPkg spec */
 	spec: OpenPkg3;
+	/** Cached spec-level diagnostics (info/warning messages from extraction) */
+	specDiagnostics?: CachedDiagnostic[];
+	/** Cached forgotten exports */
+	forgottenExports?: CachedForgottenExport[];
 }
 /**
 * Result of cache validation.
@@ -726,6 +759,10 @@ interface CacheContext {
 	config: SpecCacheConfig;
 	/** Working directory */
 	cwd: string;
+	/** Spec-level diagnostics to cache */
+	specDiagnostics?: CachedDiagnostic[];
+	/** Forgotten exports to cache */
+	forgottenExports?: CachedForgottenExport[];
 }
 /**
 * Load cached spec from disk.
@@ -937,7 +974,7 @@ interface DocCovOptions {
 	resolveExternalTypes?: boolean;
 	/** Enable spec caching (default: true) */
 	useCache?: boolean;
-	/** Working directory for cache operations (default: process.cwd()) */
+	/** Working directory for cache operations (default: git repo root or process.cwd()) */
 	cwd?: string;
 	/**
 	* Schema extraction mode for validation libraries (Zod, Valibot, etc.)
@@ -952,6 +989,7 @@ interface Diagnostic {
 	message: string;
 	severity: "error" | "warning" | "info";
 	suggestion?: string;
+	code?: string;
 	location?: {
 		file: string;
 		line?: number;
@@ -2580,7 +2618,7 @@ interface SpecSummary {
 * ```
 */
 declare function extractSpecSummary(openpkg: OpenPkg8, doccov: DocCovSpec4): SpecSummary;
-import { OpenPkg as OpenPkg_krlvfzpjos } from "@openpkg-ts/spec";
+import { OpenPkg as OpenPkg_hlpylamjdn } from "@openpkg-ts/spec";
 /**
 * Build Plan types for AI-powered repository scanning.
 */
@@ -2677,7 +2715,7 @@ interface BuildPlanExecutionResult {
 	/** Whether all required steps succeeded */
 	success: boolean;
 	/** Generated OpenPkg spec (if successful) */
-	spec?: OpenPkg_krlvfzpjos;
+	spec?: OpenPkg_hlpylamjdn;
 	/** Results for each step */
 	stepResults: BuildPlanStepResult[];
 	/** Total execution time in milliseconds */

package/dist/index.js

@@ -80,61 +80,14 @@ import {
   getDiffReportPath,
   getReportPath
 } from "./shared/chunk-r4wa72ae.js";
-// src/openpkg.ts
+// src/analyzer.ts
 import * as fsSync from "node:fs";
-import * as fs4 from "node:fs/promises";
+import * as fs5 from "node:fs/promises";
 import * as path7 from "node:path";
-
-// src/analysis/program.ts
-import * as path from "node:path";
-var DEFAULT_COMPILER_OPTIONS = {
-  target: ts.ScriptTarget.Latest,
-  module: ts.ModuleKind.CommonJS,
-  lib: ["lib.es2021.d.ts"],
-  declaration: true,
-  moduleResolution: ts.ModuleResolutionKind.NodeJs
-};
-function createProgram({
-  entryFile,
-  baseDir = path.dirname(entryFile),
-  content
-}) {
-  const configPath = ts.findConfigFile(baseDir, ts.sys.fileExists, "tsconfig.json");
-  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
-  if (configPath) {
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
-    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
-  }
-  const allowJsVal = compilerOptions.allowJs;
-  if (typeof allowJsVal === "boolean" && allowJsVal) {
-    compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
-  }
-  const compilerHost = ts.createCompilerHost(compilerOptions, true);
-  let inMemorySource;
-  if (content !== undefined) {
-    inMemorySource = ts.createSourceFile(entryFile, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
-    compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-      if (fileName === entryFile) {
-        return inMemorySource;
-      }
-      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-    };
-  }
-  const program = ts.createProgram([entryFile], compilerOptions, compilerHost);
-  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
-  return {
-    program,
-    compilerHost,
-    compilerOptions,
-    sourceFile,
-    configPath
-  };
-}
+import { createProgram as createProgram2 } from "@openpkg-ts/extract";
 
 // src/analysis/run-analysis.ts
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as path3 from "node:path";
 import { extract } from "@openpkg-ts/extract";
 
@@ -142,6 +95,18 @@ import { extract } from "@openpkg-ts/extract";
 import * as path2 from "node:path";
 
 // src/options.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function findRepoRoot(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, ".git"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return startDir;
+}
 var DEFAULT_MAX_TYPE_DEPTH = 20;
 var DEFAULT_OPTIONS = {
   includePrivate: false,
@@ -155,11 +120,12 @@ function normalizeDocCovOptions(options = {}) {
     ...options,
     maxDepth: options.maxDepth ?? DEFAULT_MAX_TYPE_DEPTH,
     useCache: options.useCache ?? true,
-    cwd: options.cwd ?? process.cwd()
+    cwd: options.cwd ?? findRepoRoot(process.cwd())
   };
 }
 
 // src/analysis/context.ts
+import { createProgram } from "@openpkg-ts/extract";
 function createAnalysisContext({
   entryFile,
   packageDir,
@@ -192,7 +158,7 @@ function findNearestPackageJson(startDir) {
   let current = startDir;
   while (true) {
     const candidate = path3.join(current, "package.json");
-    if (fs.existsSync(candidate)) {
+    if (fs2.existsSync(candidate)) {
       return candidate;
     }
     const parent = path3.dirname(current);
@@ -224,7 +190,7 @@ function hasNodeModulesDirectoryFallback(startDir) {
   let current = startDir;
   while (true) {
     const candidate = path3.join(current, "node_modules");
-    if (fs.existsSync(candidate)) {
+    if (fs2.existsSync(candidate)) {
       return true;
     }
     const parent = path3.dirname(current);
@@ -285,7 +251,8 @@ async function runAnalysis(input) {
     specDiagnostics.push({
       message: diag.message,
       severity: diag.severity,
-      suggestion: diag.suggestion
+      suggestion: diag.suggestion,
+      code: diag.code
     });
   }
   const sourceFiles = program.getSourceFiles().filter((sf) => !sf.isDeclarationFile && sf.fileName.startsWith(baseDir)).map((sf) => sf.fileName);
@@ -307,11 +274,11 @@ async function runAnalysis(input) {
 
 // src/cache/hash.ts
 import * as crypto from "node:crypto";
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import * as path4 from "node:path";
 function hashFile(filePath) {
   try {
-    const content = fs2.readFileSync(filePath);
+    const content = fs3.readFileSync(filePath);
     return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
   } catch {
     return null;
@@ -346,24 +313,33 @@ function diffHashes(cached, current) {
   return changed;
 }
 // src/cache/spec-cache.ts
-import * as fs3 from "node:fs";
+import * as fs4 from "node:fs";
 import * as path5 from "node:path";
-var CACHE_VERSION = "1.1.0";
+var CACHE_VERSION = "1.3.0";
 var SPEC_CACHE_FILE = ".doccov/cache/spec.cache.json";
 function loadSpecCache(cwd) {
   try {
     const cachePath = path5.resolve(cwd, SPEC_CACHE_FILE);
-    if (!fs3.existsSync(cachePath)) {
+    if (!fs4.existsSync(cachePath)) {
       return null;
     }
-    const content = fs3.readFileSync(cachePath, "utf-8");
+    const content = fs4.readFileSync(cachePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveSpecCache(spec, context) {
-  const { entryFile, sourceFiles, tsconfigPath, packageJsonPath, config, cwd } = context;
+  const {
+    entryFile,
+    sourceFiles,
+    tsconfigPath,
+    packageJsonPath,
+    config,
+    cwd,
+    specDiagnostics,
+    forgottenExports
+  } = context;
   const cache = {
     cacheVersion: CACHE_VERSION,
     generatedAt: new Date().toISOString(),
@@ -375,14 +351,16 @@ function saveSpecCache(spec, context) {
       sourceFiles: hashFiles(sourceFiles, cwd)
     },
     config,
-    spec
+    spec,
+    specDiagnostics,
+    forgottenExports
   };
   const cachePath = path5.resolve(cwd, SPEC_CACHE_FILE);
   const dir = path5.dirname(cachePath);
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
   }
-  fs3.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+  fs4.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
 }
 function validateSpecCache(cache, context) {
   const { entryFile, sourceFiles, tsconfigPath, packageJsonPath, config, cwd } = context;
@@ -413,8 +391,8 @@ function validateSpecCache(cache, context) {
 }
 function clearSpecCache(cwd) {
   const cachePath = path5.resolve(cwd, SPEC_CACHE_FILE);
-  if (fs3.existsSync(cachePath)) {
-    fs3.unlinkSync(cachePath);
+  if (fs4.existsSync(cachePath)) {
+    fs4.unlinkSync(cachePath);
     return true;
   }
   return false;
@@ -654,7 +632,7 @@ var applyFilters = (spec, options) => {
   };
 };
 
-// src/openpkg.ts
+// src/analyzer.ts
 class DocCov {
   options;
   constructor(options = {}) {
@@ -668,7 +646,7 @@ class DocCov {
   }
   async analyzeFile(filePath, analyzeOptions = {}) {
     const resolvedPath = path7.resolve(filePath);
-    const content = await fs4.readFile(resolvedPath, "utf-8");
+    const content = await fs5.readFile(resolvedPath, "utf-8");
     const packageDir = resolvePackageDir(resolvedPath);
     const spec = await extractPackageSpec(resolvedPath, packageDir, content, this.options);
     return this.applySpecFilters(spec, analyzeOptions.filters).spec;
@@ -710,14 +688,15 @@ class DocCov {
         const filterOutcome2 = this.applySpecFilters(cacheResult.spec, analyzeOptions.filters);
         return {
           spec: filterOutcome2.spec,
-          diagnostics: filterOutcome2.diagnostics,
+          diagnostics: [...cacheResult.specDiagnostics ?? [], ...filterOutcome2.diagnostics],
           metadata: cacheResult.metadata,
           fromCache: true,
-          cacheStatus: { valid: true }
+          cacheStatus: { valid: true },
+          forgottenExports: cacheResult.forgottenExports
         };
       }
     }
-    const content = await fs4.readFile(resolvedPath, "utf-8");
+    const content = await fs5.readFile(resolvedPath, "utf-8");
     const detectedSchemas = await this.detectSchemas(resolvedPath, packageDir);
     const analysis = await runAnalysis({
       entryFile: resolvedPath,
@@ -740,7 +719,7 @@ class DocCov {
       forgottenExports: analysis.forgottenExports
     };
     if (useCache) {
-      this.saveToCache(result, resolvedPath, analysis.metadata);
+      this.saveToCache(result, resolvedPath, analysis.metadata, analysis.specDiagnostics, analysis.forgottenExports);
     }
     return result;
   }
@@ -780,18 +759,20 @@ class DocCov {
         hasNodeModules: true,
         resolveExternalTypes: cache.config.resolveExternalTypes,
         sourceFiles: cachedSourceFiles
-      }
+      },
+      specDiagnostics: cache.specDiagnostics,
+      forgottenExports: cache.forgottenExports
     };
   }
   getCurrentSourceFiles(entryFile, baseDir) {
     try {
-      const { program } = createProgram({ entryFile, baseDir });
+      const { program } = createProgram2({ entryFile, baseDir });
       return program.getSourceFiles().filter((sf) => !sf.isDeclarationFile && sf.fileName.startsWith(baseDir)).map((sf) => sf.fileName);
     } catch {
       return [];
     }
   }
-  saveToCache(result, entryFile, metadata) {
+  saveToCache(result, entryFile, metadata, specDiagnostics, forgottenExports) {
     const { cwd } = this.options;
     if (!metadata.packageJsonPath) {
       return;
@@ -804,7 +785,9 @@ class DocCov {
       config: {
         resolveExternalTypes: metadata.resolveExternalTypes
       },
-      cwd
+      cwd,
+      specDiagnostics,
+      forgottenExports
     };
     try {
       saveSpecCache(result.spec, cacheContext);
@@ -14553,19 +14536,19 @@ function defineConfig(config2) {
   return config2;
 }
 // src/detect/utils.ts
-async function safeParseJson(fs5, path8) {
+async function safeParseJson(fs6, path8) {
   try {
-    if (!await fs5.exists(path8))
+    if (!await fs6.exists(path8))
       return null;
-    const content = await fs5.readFile(path8);
+    const content = await fs6.readFile(path8);
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
-async function readPackageJson(fs5, dir) {
+async function readPackageJson(fs6, dir) {
   const path8 = dir === "." ? "package.json" : `${dir}/package.json`;
-  return safeParseJson(fs5, path8);
+  return safeParseJson(fs6, path8);
 }
 
 // src/detect/build.ts
@@ -14595,8 +14578,8 @@ var BUILD_TOOL_PATTERNS = [
   "babel",
   "ncc build"
 ];
-async function detectBuildInfo(fs5, packagePath = ".") {
-  const pkgJson = await readPackageJson(fs5, packagePath);
+async function detectBuildInfo(fs6, packagePath = ".") {
+  const pkgJson = await readPackageJson(fs6, packagePath);
   const scripts = pkgJson?.scripts ?? {};
   const scriptNames = Object.keys(scripts);
   const buildScriptsByName = scriptNames.filter((name) => BUILD_SCRIPT_NAMES.has(name) || BUILD_SCRIPT_PREFIXES.some((prefix) => name.startsWith(prefix)));
@@ -14608,10 +14591,10 @@ async function detectBuildInfo(fs5, packagePath = ".") {
   });
   const buildScripts = [...new Set([...buildScriptsByName, ...buildScriptsByContent])];
   const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
-  const hasTsConfig = await fs5.exists(tsconfigPath);
+  const hasTsConfig = await fs6.exists(tsconfigPath);
   const hasTsDep = pkgJson?.devDependencies?.typescript !== undefined || pkgJson?.dependencies?.typescript !== undefined;
   const hasTypeScript = hasTsConfig || hasTsDep;
-  const wasm = await detectWasmProject(fs5, packagePath, pkgJson);
+  const wasm = await detectWasmProject(fs6, packagePath, pkgJson);
   const napi = detectNapiProject(pkgJson);
   return {
     scripts: buildScripts,
@@ -14628,11 +14611,11 @@ var WASM_PACKAGES = new Set([
   "wasm-bindgen",
   "@aspect/aspect-cli"
 ]);
-async function detectWasmProject(fs5, packagePath, pkgJson) {
+async function detectWasmProject(fs6, packagePath, pkgJson) {
   const pkgCargoPath = packagePath === "." ? "Cargo.toml" : `${packagePath}/Cargo.toml`;
-  if (await fs5.exists(pkgCargoPath))
+  if (await fs6.exists(pkgCargoPath))
     return true;
-  if (packagePath !== "." && await fs5.exists("Cargo.toml"))
+  if (packagePath !== "." && await fs6.exists("Cargo.toml"))
     return true;
   if (pkgJson) {
     const deps = Object.keys({
@@ -14673,15 +14656,15 @@ function getPrimaryBuildScript(buildInfo) {
   return buildInfo.scripts[0] ?? null;
 }
 // src/detect/entry-point.ts
-async function detectEntryPoint(fs5, packagePath = ".") {
-  const pkgJson = await readPackageJson(fs5, packagePath);
+async function detectEntryPoint(fs6, packagePath = ".") {
+  const pkgJson = await readPackageJson(fs6, packagePath);
   if (!pkgJson) {
     throw new Error("No package.json found - not a valid npm package");
   }
-  const tsConfig = await parseTsConfig(fs5, packagePath);
+  const tsConfig = await parseTsConfig(fs6, packagePath);
   const typesField = pkgJson.types || pkgJson.typings;
   if (typesField && typeof typesField === "string") {
-    const resolved = await resolveToSource(fs5, packagePath, typesField, tsConfig);
+    const resolved = await resolveToSource(fs6, packagePath, typesField, tsConfig);
     if (resolved) {
       return { ...resolved, source: "types" };
     }
@@ -14691,7 +14674,7 @@ async function detectEntryPoint(fs5, packagePath = ".") {
     if (dotExport && typeof dotExport === "object" && "types" in dotExport) {
       const typesPath = dotExport.types;
       if (typesPath && typeof typesPath === "string") {
-        const resolved = await resolveToSource(fs5, packagePath, typesPath, tsConfig);
+        const resolved = await resolveToSource(fs6, packagePath, typesPath, tsConfig);
         if (resolved) {
           return { ...resolved, source: "exports" };
         }
@@ -14699,13 +14682,13 @@ async function detectEntryPoint(fs5, packagePath = ".") {
     }
   }
   if (pkgJson.main && typeof pkgJson.main === "string") {
-    const resolved = await resolveToSource(fs5, packagePath, pkgJson.main, tsConfig);
+    const resolved = await resolveToSource(fs6, packagePath, pkgJson.main, tsConfig);
     if (resolved) {
       return { ...resolved, source: "main" };
     }
   }
   if (pkgJson.module && typeof pkgJson.module === "string") {
-    const resolved = await resolveToSource(fs5, packagePath, pkgJson.module, tsConfig);
+    const resolved = await resolveToSource(fs6, packagePath, pkgJson.module, tsConfig);
     if (resolved) {
       return { ...resolved, source: "module" };
     }
@@ -14723,27 +14706,27 @@ async function detectEntryPoint(fs5, packagePath = ".") {
   ];
   for (const fallback of fallbacks) {
     const checkPath = packagePath === "." ? fallback : `${packagePath}/${fallback}`;
-    if (await fs5.exists(checkPath)) {
+    if (await fs6.exists(checkPath)) {
       return { path: fallback, source: "fallback", isDeclarationOnly: false };
     }
   }
   throw new Error("Could not detect TypeScript entry point. No types field in package.json and no common entry paths found.");
 }
-async function parseTsConfig(fs5, packagePath) {
+async function parseTsConfig(fs6, packagePath) {
   const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
-  const tsconfig = await safeParseJson(fs5, tsconfigPath);
+  const tsconfig = await safeParseJson(fs6, tsconfigPath);
   if (!tsconfig?.compilerOptions) {
     return null;
   }
   const { outDir, rootDir, baseUrl, paths } = tsconfig.compilerOptions;
   return { outDir, rootDir, baseUrl, paths };
 }
-async function resolveToSource(fs5, basePath, filePath, tsConfig) {
+async function resolveToSource(fs6, basePath, filePath, tsConfig) {
   const normalized = filePath.replace(/^\.\//, "");
   const checkPath = (p) => basePath === "." ? p : `${basePath}/${p}`;
   const isSourceTs = normalized.endsWith(".ts") && !normalized.endsWith(".d.ts") || normalized.endsWith(".tsx");
   if (isSourceTs) {
-    if (await fs5.exists(checkPath(normalized))) {
+    if (await fs6.exists(checkPath(normalized))) {
       return { path: normalized, isDeclarationOnly: false };
     }
   }
@@ -14785,19 +14768,19 @@ async function resolveToSource(fs5, basePath, filePath, tsConfig) {
   for (const candidate of candidates) {
     if (candidate.endsWith(".d.ts"))
       continue;
-    if (await fs5.exists(checkPath(candidate))) {
+    if (await fs6.exists(checkPath(candidate))) {
       return { path: candidate, isDeclarationOnly: false };
     }
   }
   if (normalized.endsWith(".d.ts")) {
-    if (await fs5.exists(checkPath(normalized))) {
+    if (await fs6.exists(checkPath(normalized))) {
       return { path: normalized, isDeclarationOnly: true };
     }
   }
   return null;
 }
 // src/detect/filesystem.ts
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 import * as nodePath from "node:path";
 import { Writable } from "node:stream";
 
@@ -14810,19 +14793,19 @@ class NodeFileSystem {
     return nodePath.join(this.basePath, relativePath);
   }
   async exists(relativePath) {
-    return fs5.existsSync(this.resolve(relativePath));
+    return fs6.existsSync(this.resolve(relativePath));
   }
   async readFile(relativePath) {
-    return fs5.readFileSync(this.resolve(relativePath), "utf-8");
+    return fs6.readFileSync(this.resolve(relativePath), "utf-8");
   }
   async readDir(relativePath) {
-    return fs5.readdirSync(this.resolve(relativePath));
+    return fs6.readdirSync(this.resolve(relativePath));
   }
   async isDirectory(relativePath) {
     const fullPath = this.resolve(relativePath);
-    if (!fs5.existsSync(fullPath))
+    if (!fs6.existsSync(fullPath))
       return false;
-    return fs5.statSync(fullPath).isDirectory();
+    return fs6.statSync(fullPath).isDirectory();
   }
 }
 function createCaptureStream() {
@@ -14895,11 +14878,11 @@ class SandboxFileSystem {
   }
 }
 // src/detect/monorepo.ts
-async function detectMonorepo(fs6) {
-  const pkgJson = await readPackageJson(fs6, ".");
+async function detectMonorepo(fs7) {
+  const pkgJson = await readPackageJson(fs7, ".");
   if (pkgJson?.workspaces) {
     const patterns = extractWorkspacePatterns(pkgJson.workspaces);
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson.name, pkgJson.private);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson.name, pkgJson.private);
     return {
       isMonorepo: packages.length > 0,
       type: "npm-workspaces",
@@ -14907,10 +14890,10 @@ async function detectMonorepo(fs6) {
       packages
     };
   }
-  if (await fs6.exists("pnpm-workspace.yaml")) {
-    const content = await fs6.readFile("pnpm-workspace.yaml");
+  if (await fs7.exists("pnpm-workspace.yaml")) {
+    const content = await fs7.readFile("pnpm-workspace.yaml");
     const patterns = parsePnpmWorkspace(content);
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "pnpm-workspaces",
@@ -14918,10 +14901,10 @@ async function detectMonorepo(fs6) {
       packages
     };
   }
-  if (await fs6.exists("lerna.json")) {
-    const lerna = await safeParseJson(fs6, "lerna.json");
+  if (await fs7.exists("lerna.json")) {
+    const lerna = await safeParseJson(fs7, "lerna.json");
     const patterns = lerna?.packages ?? ["packages/*"];
-    const packages = await resolveWorkspacePackages(fs6, patterns, pkgJson?.name, pkgJson?.private);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson?.name, pkgJson?.private);
     return {
       isMonorepo: packages.length > 0,
       type: "lerna",
@@ -14995,7 +14978,7 @@ function parsePnpmWorkspace(content) {
   }
   return patterns.length > 0 ? patterns : ["packages/*"];
 }
-async function resolveWorkspacePackages(fs6, patterns, rootPackageName, rootIsPrivate) {
+async function resolveWorkspacePackages(fs7, patterns, rootPackageName, rootIsPrivate) {
   const packages = [];
   const seen = new Set;
   if (rootPackageName && !rootIsPrivate && rootPackageName !== "root") {
@@ -15017,18 +15000,18 @@ async function resolveWorkspacePackages(fs6, patterns, rootPackageName, rootIsPr
   }
   dirsToScan.add("packages");
   for (const dir of dirsToScan) {
-    if (!await fs6.exists(dir))
+    if (!await fs7.exists(dir))
       continue;
-    if (!await fs6.isDirectory(dir))
+    if (!await fs7.isDirectory(dir))
       continue;
-    const subdirs = await fs6.readDir(dir);
+    const subdirs = await fs7.readDir(dir);
     for (const subdir of subdirs) {
       const pkgPath = `${dir}/${subdir}`;
       const pkgJsonPath = `${pkgPath}/package.json`;
-      if (!await fs6.exists(pkgJsonPath))
+      if (!await fs7.exists(pkgJsonPath))
         continue;
       try {
-        const content = await fs6.readFile(pkgJsonPath);
+        const content = await fs7.readFile(pkgJsonPath);
         const pkg = JSON.parse(content);
         if (pkg.name && !seen.has(pkg.name)) {
           seen.add(pkg.name);
@@ -15100,14 +15083,14 @@ var DEFAULT_PM = {
   installArgs: ["install", "--legacy-peer-deps"],
   runPrefix: ["npm", "run"]
 };
-async function detectPackageManager(fs6) {
-  const pkgJson = await safeParseJson(fs6, "package.json");
+async function detectPackageManager(fs7) {
+  const pkgJson = await safeParseJson(fs7, "package.json");
   if (pkgJson?.packageManager) {
     const pmName = parsePackageManagerField(pkgJson.packageManager);
     if (pmName && PM_CONFIGS[pmName]) {
       const config2 = PM_CONFIGS[pmName];
       for (const lockfile of config2.lockfiles) {
-        if (await fs6.exists(lockfile)) {
+        if (await fs7.exists(lockfile)) {
           return { ...config2.info, lockfile };
         }
       }
@@ -15117,7 +15100,7 @@ async function detectPackageManager(fs6) {
   const foundLockfiles = [];
   for (const [pmName, config2] of Object.entries(PM_CONFIGS)) {
     for (const lockfile of config2.lockfiles) {
-      if (await fs6.exists(lockfile)) {
+      if (await fs7.exists(lockfile)) {
         foundLockfiles.push({ lockfile, pm: pmName });
       }
     }
@@ -15149,10 +15132,10 @@ function getRunCommand(pm, script) {
   return [...pm.runPrefix, script];
 }
 // src/detect/index.ts
-async function analyzeProject(fs6, options = {}) {
+async function analyzeProject(fs7, options = {}) {
   const [packageManager, monorepo] = await Promise.all([
-    detectPackageManager(fs6),
-    detectMonorepo(fs6)
+    detectPackageManager(fs7),
+    detectMonorepo(fs7)
   ]);
   let targetPath = ".";
   if (monorepo.isMonorepo) {
@@ -15169,18 +15152,18 @@ async function analyzeProject(fs6, options = {}) {
     targetPath = pkg.path;
   }
   const [entryPoint, build] = await Promise.all([
-    detectEntryPoint(fs6, targetPath),
-    detectBuildInfo(fs6, targetPath)
+    detectEntryPoint(fs7, targetPath),
+    detectBuildInfo(fs7, targetPath)
   ]);
   return { packageManager, monorepo, entryPoint, build };
 }
 // src/resolve/index.ts
 import * as path8 from "node:path";
-async function resolveTarget(fs6, options) {
+async function resolveTarget(fs7, options) {
   let targetDir = options.cwd;
   let packageInfo;
   if (options.package) {
-    const mono = await detectMonorepo(fs6);
+    const mono = await detectMonorepo(fs7);
     if (!mono.isMonorepo) {
       throw new Error("Not a monorepo. Remove --package flag for single-package repos.");
     }
@@ -15195,14 +15178,14 @@ async function resolveTarget(fs6, options) {
   let entryFile;
   let entryPointInfo;
   if (!options.entry) {
-    entryPointInfo = await detectEntryPoint(fs6, getRelativePath(options.cwd, targetDir));
+    entryPointInfo = await detectEntryPoint(fs7, getRelativePath(options.cwd, targetDir));
     entryFile = path8.join(targetDir, entryPointInfo.path);
   } else {
     const explicitPath = path8.resolve(targetDir, options.entry);
-    const isDirectory = await isDir(fs6, getRelativePath(options.cwd, explicitPath));
+    const isDirectory = await isDir(fs7, getRelativePath(options.cwd, explicitPath));
     if (isDirectory) {
       targetDir = explicitPath;
-      entryPointInfo = await detectEntryPoint(fs6, getRelativePath(options.cwd, explicitPath));
+      entryPointInfo = await detectEntryPoint(fs7, getRelativePath(options.cwd, explicitPath));
       entryFile = path8.join(explicitPath, entryPointInfo.path);
     } else {
       entryFile = explicitPath;
@@ -15226,13 +15209,13 @@ function getRelativePath(base, target) {
   const rel = path8.relative(base, target);
   return rel || ".";
 }
-async function isDir(fs6, relativePath) {
-  const hasPackageJson = await fs6.exists(path8.join(relativePath, "package.json"));
+async function isDir(fs7, relativePath) {
+  const hasPackageJson = await fs7.exists(path8.join(relativePath, "package.json"));
   if (hasPackageJson)
     return true;
   const commonEntryFiles = ["index.ts", "index.tsx", "src/index.ts", "main.ts"];
   for (const entry of commonEntryFiles) {
-    if (await fs6.exists(path8.join(relativePath, entry))) {
+    if (await fs7.exists(path8.join(relativePath, entry))) {
       return true;
     }
   }
@@ -15278,7 +15261,7 @@ function shouldValidate(validations, check2) {
   return validations.includes(check2);
 }
 // src/typecheck/example-typechecker.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as path9 from "node:path";
 import ts2 from "typescript";
 function stripCodeBlockMarkers(code) {
@@ -15286,9 +15269,9 @@ function stripCodeBlockMarkers(code) {
 }
 function getPackageName(packagePath) {
   const pkgJsonPath = path9.join(packagePath, "package.json");
-  if (fs6.existsSync(pkgJsonPath)) {
+  if (fs7.existsSync(pkgJsonPath)) {
     try {
-      const pkgJson = JSON.parse(fs6.readFileSync(pkgJsonPath, "utf-8"));
+      const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
       return pkgJson.name;
     } catch {
       return;
@@ -15300,7 +15283,7 @@ function findTsConfig(packagePath) {
   let dir = packagePath;
   while (dir !== path9.dirname(dir)) {
     const tsConfigPath = path9.join(dir, "tsconfig.json");
-    if (fs6.existsSync(tsConfigPath)) {
+    if (fs7.existsSync(tsConfigPath)) {
       return tsConfigPath;
     }
     dir = path9.dirname(dir);
@@ -15323,7 +15306,7 @@ function createVirtualSource(example, packageName, exportNames) {
 `);
 }
 function getCompilerOptions(tsconfigPath) {
-  if (tsconfigPath && fs6.existsSync(tsconfigPath)) {
+  if (tsconfigPath && fs7.existsSync(tsconfigPath)) {
     const configFile = ts2.readConfigFile(tsconfigPath, ts2.sys.readFile);
     if (!configFile.error) {
       const parsed = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path9.dirname(tsconfigPath));
@@ -15424,7 +15407,7 @@ function typecheckExamples(examples, packagePath, options = {}) {
 
 // src/utils/example-runner.ts
 import { spawn } from "node:child_process";
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os from "node:os";
 import * as path10 from "node:path";
 function stripCodeBlockMarkers2(code) {
@@ -15435,7 +15418,7 @@ async function runExample(code, options = {}) {
   const cleanCode = stripCodeBlockMarkers2(code);
   const tmpFile = path10.join(cwd, `doccov-example-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`);
   try {
-    fs7.writeFileSync(tmpFile, cleanCode, "utf-8");
+    fs8.writeFileSync(tmpFile, cleanCode, "utf-8");
     const startTime = Date.now();
     return await new Promise((resolve5) => {
       let stdout = "";
@@ -15490,7 +15473,7 @@ async function runExample(code, options = {}) {
     });
   } finally {
     try {
-      fs7.unlinkSync(tmpFile);
+      fs8.unlinkSync(tmpFile);
     } catch {}
   }
 }
@@ -15505,15 +15488,15 @@ async function runExamples(examples, options = {}) {
   return results;
 }
 function detectPackageManager2(cwd) {
-  if (fs7.existsSync(path10.join(cwd, "bun.lockb")))
+  if (fs8.existsSync(path10.join(cwd, "bun.lockb")))
     return "bun";
-  if (fs7.existsSync(path10.join(cwd, "bun.lock")))
+  if (fs8.existsSync(path10.join(cwd, "bun.lock")))
     return "bun";
-  if (fs7.existsSync(path10.join(cwd, "pnpm-lock.yaml")))
+  if (fs8.existsSync(path10.join(cwd, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs7.existsSync(path10.join(cwd, "yarn.lock")))
+  if (fs8.existsSync(path10.join(cwd, "yarn.lock")))
     return "yarn";
-  if (fs7.existsSync(path10.join(cwd, "package-lock.json")))
+  if (fs8.existsSync(path10.join(cwd, "package-lock.json")))
     return "npm";
   return "npm";
 }
@@ -15584,9 +15567,9 @@ async function runExamplesWithPackage(examples, options) {
   const absolutePackagePath = path10.resolve(packagePath);
   const workDir = path10.join(os.tmpdir(), `doccov-examples-${Date.now()}-${Math.random().toString(36).slice(2)}`);
   try {
-    fs7.mkdirSync(workDir, { recursive: true });
+    fs8.mkdirSync(workDir, { recursive: true });
     const pkgJson = { name: "doccov-example-runner", type: "module" };
-    fs7.writeFileSync(path10.join(workDir, "package.json"), JSON.stringify(pkgJson, null, 2));
+    fs8.writeFileSync(path10.join(workDir, "package.json"), JSON.stringify(pkgJson, null, 2));
     const pm = packageManager ?? detectPackageManager2(options.cwd ?? process.cwd());
     const { cmd, args } = getInstallCommand2(pm, absolutePackagePath);
     const installResult = await runCommand(cmd, args, {
@@ -15614,7 +15597,7 @@ async function runExamplesWithPackage(examples, options) {
     };
   } finally {
     try {
-      fs7.rmSync(workDir, { recursive: true, force: true });
+      fs8.rmSync(workDir, { recursive: true, force: true });
     } catch {}
   }
 }
@@ -16722,11 +16705,11 @@ async function fetchSpecFromGitHubWithPath(parsed, specPath = "openpkg.json") {
 }
 // src/install/index.ts
 var DEFAULT_FALLBACK_ORDER = ["bun", "npm"];
-async function installDependencies(fs8, cwd, runCommand2, options = {}) {
+async function installDependencies(fs9, cwd, runCommand2, options = {}) {
   const { timeout = 180000, fallbackOrder = DEFAULT_FALLBACK_ORDER, onProgress } = options;
   const errors3 = [];
   onProgress?.({ stage: "installing", message: "Detecting package manager..." });
-  const pmInfo = await detectPackageManager(fs8);
+  const pmInfo = await detectPackageManager(fs9);
   if (pmInfo.lockfile) {
     onProgress?.({
       stage: "installing",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/sdk",
-  "version": "0.29.0",
+  "version": "0.29.4",
   "description": "DocCov SDK - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",