@doccov/sdk 0.3.2 → 0.3.3

package/dist/index.d.ts

@@ -69,6 +69,214 @@ declare function hasNonAssertionComments(code: string): boolean;
 * Detect assertion failures by comparing stdout to expected values.
 */
 declare function detectExampleAssertionFailures(entry: SpecExport, runtimeResults: Map<number, ExampleRunResult>): SpecDocDrift[];
+/**
+* Markdown/MDX documentation analysis types
+*/
+/**
+* A code block extracted from a markdown file
+*/
+interface MarkdownCodeBlock {
+	/** Language tag (ts, typescript, js, javascript, tsx, jsx) */
+	lang: string;
+	/** The code content */
+	code: string;
+	/** Raw meta string from code fence (e.g., "title=example.ts") */
+	meta?: string;
+	/** Starting line number in the markdown file */
+	lineStart: number;
+	/** Ending line number in the markdown file */
+	lineEnd: number;
+}
+/**
+* A parsed markdown documentation file
+*/
+interface MarkdownDocFile {
+	/** File path relative to project root */
+	path: string;
+	/** All executable code blocks found */
+	codeBlocks: MarkdownCodeBlock[];
+}
+/**
+* A reference to an found in markdown
+*/
+interface ExportReference {
+	/** The name of the being referenced */
+	exportName: string;
+	/** File path where the reference was found */
+	file: string;
+	/** Line number in the file */
+	line: number;
+	/** Surrounding code/text for context */
+	context: string;
+	/** Whether this reference is inside a code block */
+	inCodeBlock: boolean;
+	/** The code block index if inside a code block */
+	blockIndex?: number;
+}
+/**
+* Change type for an impacted reference
+*/
+type DocsChangeType = "signature-changed" | "removed" | "deprecated";
+/**
+* An impacted reference in a documentation file
+*/
+interface DocsImpactReference {
+	/** The name that was changed */
+	exportName: string;
+	/** Line number in the file */
+	line: number;
+	/** Type of change affecting this reference */
+	changeType: DocsChangeType;
+	/** Suggested fix (AI-generated or deterministic) */
+	suggestion?: string;
+	/** Context around the reference */
+	context?: string;
+}
+/**
+* Documentation file impact summary
+*/
+interface DocsImpact {
+	/** File path */
+	file: string;
+	/** All impacted references in this file */
+	references: DocsImpactReference[];
+}
+/**
+* Complete docs impact analysis result
+*/
+interface DocsImpactResult {
+	/** Files with impacted references */
+	impactedFiles: DocsImpact[];
+	/** New exports that have no documentation */
+	missingDocs: string[];
+	/** Statistics */
+	stats: {
+		/** Total markdown files scanned */
+		filesScanned: number;
+		/** Total code blocks found */
+		codeBlocksFound: number;
+		/** Total references found */
+		referencesFound: number;
+		/** References impacted by changes */
+		impactedReferences: number;
+	};
+}
+/**
+* Check if a language tag represents executable code
+*/
+declare function isExecutableLang(lang: string | null | undefined): boolean;
+/**
+* Parse a markdown file and extract code blocks
+*/
+declare function parseMarkdownFile(content: string, filePath: string): MarkdownDocFile;
+/**
+* Parse multiple markdown files
+*/
+declare function parseMarkdownFiles(files: Array<{
+	path: string;
+	content: string;
+}>): MarkdownDocFile[];
+/**
+* Extract import statements from code
+* Finds named imports: import { X, Y } from 'pkg'
+*/
+declare function extractImports(code: string): Array<{
+	name: string;
+	from: string;
+}>;
+/**
+* Extract function calls from code
+* Finds: functionName( or functionName<
+*/
+declare function extractFunctionCalls(code: string): string[];
+/**
+* Find all references to given names in markdown files
+*/
+declare function findExportReferences(files: MarkdownDocFile[], exportNames: string[]): ExportReference[];
+/**
+* Check if a code block references any of the given names
+*/
+declare function blockReferencesExport(block: MarkdownCodeBlock, exportName: string): boolean;
+import { SpecDiff } from "@openpkg-ts/spec";
+/**
+* Analyze docs impact from a spec diff
+*
+* @param diff - The spec diff result
+* @param markdownFiles - Parsed markdown files
+* @param newExportNames - All names in the new spec (for missing docs detection)
+*/
+declare function analyzeDocsImpact(diff: SpecDiff, markdownFiles: MarkdownDocFile[], newExportNames?: string[]): DocsImpactResult;
+/**
+* Find references to deprecated exports
+*/
+declare function findDeprecatedReferences(markdownFiles: MarkdownDocFile[], deprecatedExports: string[]): ExportReference[];
+/**
+* Find references to removed exports
+*/
+declare function findRemovedReferences(markdownFiles: MarkdownDocFile[], removedExports: string[]): ExportReference[];
+/**
+* Check if any docs reference a specific */
+declare function hasDocsForExport(markdownFiles: MarkdownDocFile[], exportName: string): boolean;
+/**
+* Get all exports that have documentation
+*/
+declare function getDocumentedExports(markdownFiles: MarkdownDocFile[], exportNames: string[]): string[];
+/**
+* Get all exports that lack documentation
+*/
+declare function getUndocumentedExports(markdownFiles: MarkdownDocFile[], exportNames: string[]): string[];
+import { OpenPkg as OpenPkg2, SpecDiff as SpecDiff2 } from "@openpkg-ts/spec";
+/**
+* Extended spec diff result with docs impact
+*/
+interface SpecDiffWithDocs extends SpecDiff2 {
+	/** Docs impact analysis (only present if markdown files provided) */
+	docsImpact?: DocsImpactResult;
+}
+/**
+* Options for diffSpecWithDocs
+*/
+interface DiffWithDocsOptions {
+	/** Parsed markdown documentation files */
+	markdownFiles?: MarkdownDocFile[];
+}
+/**
+* Compute spec diff with optional docs impact analysis
+*
+* @param oldSpec - Previous version of the spec
+* @param newSpec - Current version of the spec
+* @param options - Options including markdown files to analyze
+* @returns Extended diff result with docs impact
+*
+* @example
+* ```ts
+* import { diffSpecWithDocs, parseMarkdownFiles } from '@doccov/sdk';
+*
+* const markdownFiles = parseMarkdownFiles([
+*   { path: 'docs/guide.md', content: '...' },
+* ]);
+*
+* const diff = diffSpecWithDocs(oldSpec, newSpec, { markdownFiles });
+*
+* if (diff.docsImpact?.impactedFiles.length) {
+*   console.log('Docs need updating!');
+* }
+* ```
+*/
+declare function diffSpecWithDocs(oldSpec: OpenPkg2, newSpec: OpenPkg2, options?: DiffWithDocsOptions): SpecDiffWithDocs;
+/**
+* Check if a diff has any docs impact
+*/
+declare function hasDocsImpact(diff: SpecDiffWithDocs): boolean;
+/**
+* Get summary of docs impact for display
+*/
+declare function getDocsImpactSummary(diff: SpecDiffWithDocs): {
+	impactedFileCount: number;
+	impactedReferenceCount: number;
+	missingDocsCount: number;
+	totalIssues: number;
+};
 interface DocCovOptions {
 	includePrivate?: boolean;
 	followImports?: boolean;
@@ -258,5 +466,261 @@ declare class DocCov {
 declare function analyze(code: string, options?: AnalyzeOptions): Promise<OpenPkgSpec>;
 declare function analyzeFile(filePath: string, options?: AnalyzeOptions): Promise<OpenPkgSpec>;
 /** @deprecated Use DocCov instead */
-declare const OpenPkg2: typeof DocCov;
-export { serializeJSDoc, runExamplesWithPackage, runExamples, runExample, parseJSDocToPatch, parseAssertions, mergeFixes, isFixableDrift, hasNonAssertionComments, generateFixesForExport, generateFix, findJSDocLocation, extractPackageSpec, detectExampleRuntimeErrors, detectExampleAssertionFailures, createSourceFile, categorizeDrifts, applyPatchToJSDoc, applyEdits, analyzeFile, analyze, RunExamplesWithPackageResult, RunExamplesWithPackageOptions, RunExampleOptions, OpenPkgSpec, OpenPkgOptions, OpenPkg2 as OpenPkg, JSDocTag, JSDocReturn, JSDocPatch, JSDocParam, JSDocEdit, FixType, FixSuggestion, FilterOptions, ExampleRunResult, DocCovOptions, DocCov, Diagnostic, ApplyEditsResult, AnalyzeOptions, AnalysisResult };
+declare const OpenPkg3: typeof DocCov;
+/**
+* Project detection types for I/O-agnostic project analysis.
+* Used by both CLI (NodeFileSystem) and API (SandboxFileSystem).
+*/
+/**
+* Minimal filesystem interface for I/O-agnostic detection.
+* Implementations: NodeFileSystem (CLI), SandboxFileSystem (API)
+*/
+interface FileSystem {
+	/** Check if a file or directory exists */
+	exists(path: string): Promise<boolean>;
+	/** Read file contents as string */
+	readFile(path: string): Promise<string>;
+	/** List directory contents (file/folder names only) */
+	readDir(path: string): Promise<string[]>;
+	/** Check if path is a directory */
+	isDirectory(path: string): Promise<boolean>;
+}
+/** Supported package managers */
+type PackageManager = "npm" | "yarn" | "pnpm" | "bun";
+/** Package manager detection result with install/run commands */
+interface PackageManagerInfo {
+	/** Package manager name */
+	name: PackageManager;
+	/** Lockfile that was detected (null if none found) */
+	lockfile: string | null;
+	/** Arguments for install command, e.g. ['install', '--frozen-lockfile'] */
+	installArgs: string[];
+	/** Prefix for running scripts, e.g. ['npm', 'run'] or ['pnpm'] */
+	runPrefix: string[];
+}
+/** Monorepo type based on configuration */
+type MonorepoType = "npm-workspaces" | "pnpm-workspaces" | "lerna" | "none";
+/** Monorepo detection result */
+interface MonorepoInfo {
+	/** Whether this is a monorepo */
+	isMonorepo: boolean;
+	/** Type of monorepo configuration */
+	type: MonorepoType;
+	/** Workspace patterns from config (e.g. ['packages/*']) */
+	patterns: string[];
+	/** Resolved workspace packages */
+	packages: WorkspacePackage[];
+}
+/** A package within a monorepo workspace */
+interface WorkspacePackage {
+	/** Package name from package.json */
+	name: string;
+	/** Relative path to package directory */
+	path: string;
+	/** Whether the package is marked as private */
+	private: boolean;
+}
+/** Entry point source - where the entry was detected from */
+type EntryPointSource = "types" | "exports" | "main" | "module" | "fallback";
+/** Entry point detection result */
+interface EntryPointInfo {
+	/** Path to entry file (relative to package root) */
+	path: string;
+	/** Where the entry point was detected from */
+	source: EntryPointSource;
+	/** Whether this is a .d.ts file (no source available) */
+	isDeclarationOnly: boolean;
+}
+/** Build configuration detection result */
+interface BuildInfo {
+	/** Build-related script names found (e.g. ['build', 'build:types']) */
+	scripts: string[];
+	/** Whether any build script was found */
+	hasBuildScript: boolean;
+	/** Whether TypeScript is configured/installed */
+	hasTypeScript: boolean;
+	/** Indicators for exotic project types */
+	exoticIndicators: {
+		/** WASM project (Cargo.toml or wasm-pack scripts) */
+		wasm: boolean;
+		/** napi-rs native addon project */
+		napi: boolean;
+	};
+}
+/** Complete project analysis result */
+interface ProjectInfo {
+	/** Package manager info */
+	packageManager: PackageManagerInfo;
+	/** Monorepo info */
+	monorepo: MonorepoInfo;
+	/** Entry point info */
+	entryPoint: EntryPointInfo;
+	/** Build info */
+	build: BuildInfo;
+}
+/** Options for analyzeProject() */
+interface AnalyzeProjectOptions {
+	/** Target package name for monorepos */
+	targetPackage?: string;
+}
+import { Sandbox } from "@vercel/sandbox";
+/**
+* Node.js filesystem implementation for CLI usage.
+* Wraps Node.js fs module with a base path.
+*/
+declare class NodeFileSystem implements FileSystem {
+	private basePath;
+	constructor(basePath: string);
+	private resolve;
+	exists(relativePath: string): Promise<boolean>;
+	readFile(relativePath: string): Promise<string>;
+	readDir(relativePath: string): Promise<string[]>;
+	isDirectory(relativePath: string): Promise<boolean>;
+}
+/**
+* Vercel Sandbox filesystem implementation for API usage.
+* Uses sandbox.runCommand() with shell commands.
+*/
+declare class SandboxFileSystem implements FileSystem {
+	private sandbox;
+	constructor(sandbox: Sandbox);
+	exists(path: string): Promise<boolean>;
+	readFile(path: string): Promise<string>;
+	readDir(path: string): Promise<string[]>;
+	isDirectory(path: string): Promise<boolean>;
+}
+/**
+* Detect package manager based on lockfile presence.
+*
+* Priority order:
+* 1. pnpm-lock.yaml
+* 2. bun.lock / bun.lockb
+* 3. yarn.lock
+* 4. package-lock.json
+* 5. Default to npm
+*/
+declare function detectPackageManager(fs: FileSystem): Promise<PackageManagerInfo>;
+/**
+* Get install command for a package manager.
+* Returns [command, ...args] array.
+*/
+declare function getInstallCommand(pm: PackageManagerInfo): string[];
+/**
+* Get run command for a package manager script.
+* Returns [command, ...args, scriptName] array.
+*/
+declare function getRunCommand(pm: PackageManagerInfo, script: string): string[];
+/**
+* Detect if a project is a monorepo and list its packages.
+*
+* Detection triggers (in order):
+* 1. package.json has workspaces field (npm/yarn)
+* 2. pnpm-workspace.yaml exists
+* 3. lerna.json exists
+*/
+declare function detectMonorepo(fs: FileSystem): Promise<MonorepoInfo>;
+/**
+* Find a package by name or path in a list of workspace packages.
+*/
+declare function findPackageByName(packages: WorkspacePackage[], nameOrPath: string): WorkspacePackage | undefined;
+/**
+* Format package list for display in error messages.
+*/
+declare function formatPackageList(packages: WorkspacePackage[], limit?: number): string;
+/**
+* Detect the TypeScript entry point for a package.
+*
+* Priority order:
+* 1. package.json -> types or typings field
+* 2. package.json -> exports["."].types
+* 3. package.json -> main field (resolve to .ts)
+* 4. package.json -> module field (resolve to .ts)
+* 5. Common fallback paths
+*
+* @param fs - FileSystem implementation
+* @param packagePath - Path to package directory (default: ".")
+* @returns Entry point info
+* @throws Error if no entry point can be found
+*/
+declare function detectEntryPoint(fs: FileSystem, packagePath?: string): Promise<EntryPointInfo>;
+/**
+* Detect build configuration and exotic project indicators.
+*
+* @param fs - FileSystem implementation
+* @param packagePath - Path to package directory (default: ".")
+* @returns Build info including scripts and exotic indicators
+*/
+declare function detectBuildInfo(fs: FileSystem, packagePath?: string): Promise<BuildInfo>;
+/**
+* Get the primary build script name to run.
+* Prefers 'build' over 'compile' over 'tsc'.
+*/
+declare function getPrimaryBuildScript(buildInfo: BuildInfo): string | null;
+/**
+* Safely parse a JSON file, returning null on any error.
+*/
+declare function safeParseJson<T = Record<string, unknown>>(fs: FileSystem, path: string): Promise<T | null>;
+/**
+* Standard package.json structure for detection purposes.
+*/
+interface PackageJson {
+	name?: string;
+	version?: string;
+	private?: boolean;
+	main?: string;
+	module?: string;
+	types?: string;
+	typings?: string;
+	exports?: PackageExports;
+	workspaces?: string[] | {
+		packages: string[];
+	};
+	scripts?: Record<string, string>;
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+}
+/**
+* Package.json exports field structure.
+*/
+type PackageExports = string | {
+	"."?: string | {
+		types?: string;
+		import?: string;
+		require?: string;
+		default?: string;
+	};
+	[key: string]: unknown;
+};
+/**
+* Read and parse package.json from a directory.
+*/
+declare function readPackageJson(fs: FileSystem, dir: string): Promise<PackageJson | null>;
+/**
+* Analyze a project's structure for scanning.
+*
+* This is the main entry point for project detection. It combines all
+* detection functions into a single call that returns complete project info.
+*
+* For monorepos, you must specify the target package via options.targetPackage.
+* If not specified and a monorepo is detected, an error is thrown with the
+* list of available packages.
+*
+* @param fs - FileSystem implementation (NodeFileSystem or SandboxFileSystem)
+* @param options - Options including targetPackage for monorepos
+* @returns Complete project info
+* @throws Error if monorepo detected without targetPackage specified
+* @throws Error if targetPackage not found in monorepo
+*
+* @example
+* ```typescript
+* // Single package
+* const fs = new NodeFileSystem('/path/to/package');
+* const project = await analyzeProject(fs);
+*
+* // Monorepo with target package
+* const fs = new NodeFileSystem('/path/to/monorepo');
+* const project = await analyzeProject(fs, { targetPackage: '@scope/core' });
+* ```
+*/
+declare function analyzeProject2(fs: FileSystem, options?: AnalyzeProjectOptions): Promise<ProjectInfo>;
+export { serializeJSDoc, safeParseJson, runExamplesWithPackage, runExamples, runExample, readPackageJson, parseMarkdownFiles, parseMarkdownFile, parseJSDocToPatch, parseAssertions, mergeFixes, isFixableDrift, isExecutableLang, hasNonAssertionComments, hasDocsImpact, hasDocsForExport, getUndocumentedExports, getRunCommand, getPrimaryBuildScript, getInstallCommand, getDocumentedExports, getDocsImpactSummary, generateFixesForExport, generateFix, formatPackageList, findRemovedReferences, findPackageByName, findJSDocLocation, findExportReferences, findDeprecatedReferences, extractPackageSpec, extractImports, extractFunctionCalls, diffSpecWithDocs, detectPackageManager, detectMonorepo, detectExampleRuntimeErrors, detectExampleAssertionFailures, detectEntryPoint, detectBuildInfo, createSourceFile, categorizeDrifts, blockReferencesExport, applyPatchToJSDoc, applyEdits, analyzeProject2 as analyzeProject, analyzeFile, analyzeDocsImpact, analyze, WorkspacePackage, SpecDiffWithDocs, SandboxFileSystem, RunExamplesWithPackageResult, RunExamplesWithPackageOptions, RunExampleOptions, ProjectInfo, PackageManagerInfo, PackageManager, PackageJson, PackageExports, OpenPkgSpec, OpenPkgOptions, OpenPkg3 as OpenPkg, NodeFileSystem, MonorepoType, MonorepoInfo, MarkdownDocFile, MarkdownCodeBlock, JSDocTag, JSDocReturn, JSDocPatch, JSDocParam, JSDocEdit, FixType, FixSuggestion, FilterOptions, FileSystem, ExportReference, ExampleRunResult, EntryPointSource, EntryPointInfo, DocsImpactResult, DocsImpactReference, DocsImpact, DocsChangeType, DocCovOptions, DocCov, DiffWithDocsOptions, Diagnostic, BuildInfo, ApplyEditsResult, AnalyzeProjectOptions, AnalyzeOptions, AnalysisResult };

package/dist/index.js

@@ -669,22 +669,31 @@ function levenshtein(a, b) {
   return matrix[b.length][a.length];
 }
 function detectExampleDrift(entry, exportRegistry) {
-  if (!exportRegistry || !entry.examples || entry.examples.length === 0) {
+  if (!exportRegistry || !entry.examples?.length)
     return [];
-  }
   const drifts = [];
-  const identifierPattern = /\b([A-Z][a-zA-Z0-9]*)\b/g;
   for (const example of entry.examples) {
-    if (typeof example !== "string") {
+    let visit = function(node) {
+      if (ts.isIdentifier(node) && isPascalCase(node.text)) {
+        if (isLocalDeclaration(node)) {
+          localDeclarations.add(node.text);
+        } else if (isIdentifierReference(node) && !isBuiltInIdentifier(node.text)) {
+          referencedIdentifiers.add(node.text);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    if (typeof example !== "string")
       continue;
-    }
-    const matches = example.matchAll(identifierPattern);
+    const codeContent = example.replace(/^```(?:ts|typescript|js|javascript)?\n?/i, "").replace(/\n?```$/i, "").trim();
+    if (!codeContent)
+      continue;
+    const sourceFile = ts.createSourceFile("example.ts", codeContent, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const localDeclarations = new Set;
     const referencedIdentifiers = new Set;
-    for (const match of matches) {
-      const identifier = match[1];
-      if (identifier && !isBuiltInIdentifier(identifier)) {
-        referencedIdentifiers.add(identifier);
-      }
+    visit(sourceFile);
+    for (const local of localDeclarations) {
+      referencedIdentifiers.delete(local);
     }
     for (const identifier of referencedIdentifiers) {
       if (!exportRegistry.has(identifier)) {
@@ -757,6 +766,37 @@ function isBuiltInIdentifier(identifier) {
   ]);
   return builtIns.has(identifier);
 }
+function isPascalCase(text) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(text);
+}
+function isLocalDeclaration(node) {
+  const parent = node.parent;
+  if (!parent)
+    return false;
+  if (ts.isClassDeclaration(parent) && parent.name === node)
+    return true;
+  if (ts.isFunctionDeclaration(parent) && parent.name === node)
+    return true;
+  if (ts.isVariableDeclaration(parent) && parent.name === node)
+    return true;
+  return false;
+}
+function isIdentifierReference(node) {
+  const parent = node.parent;
+  if (!parent)
+    return false;
+  if (ts.isClassDeclaration(parent) && parent.name === node)
+    return false;
+  if (ts.isFunctionDeclaration(parent) && parent.name === node)
+    return false;
+  if (ts.isVariableDeclaration(parent) && parent.name === node)
+    return false;
+  if (ts.isMethodDeclaration(parent) && parent.name === node)
+    return false;
+  if (ts.isPropertyDeclaration(parent) && parent.name === node)
+    return false;
+  return true;
+}
 function detectBrokenLinks(entry, exportRegistry) {
   if (!exportRegistry) {
     return [];
@@ -983,6 +1023,267 @@ function detectExampleAssertionFailures(entry, runtimeResults) {
   }
   return drifts;
 }
+// src/markdown/parser.ts
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+var EXECUTABLE_LANGS = new Set([
+  "ts",
+  "typescript",
+  "js",
+  "javascript",
+  "tsx",
+  "jsx"
+]);
+function isExecutableLang(lang) {
+  if (!lang)
+    return false;
+  return EXECUTABLE_LANGS.has(lang.toLowerCase());
+}
+function parseMarkdownFile(content, filePath) {
+  const processor = unified().use(remarkParse).use(remarkMdx);
+  const tree = processor.parse(content);
+  const codeBlocks = [];
+  visit(tree, "code", (node) => {
+    if (isExecutableLang(node.lang)) {
+      codeBlocks.push({
+        lang: node.lang ?? "ts",
+        code: node.value,
+        meta: node.meta ?? undefined,
+        lineStart: node.position?.start.line ?? 0,
+        lineEnd: node.position?.end.line ?? 0
+      });
+    }
+  });
+  return { path: filePath, codeBlocks };
+}
+function parseMarkdownFiles(files) {
+  return files.map((f) => parseMarkdownFile(f.content, f.path));
+}
+function extractImports(code) {
+  const imports = [];
+  const importRegex = /import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(code)) !== null) {
+    const names = match[1];
+    const from = match[2];
+    const namedImports = names.split(",").map((n) => n.trim().split(/\s+as\s+/)[0].trim());
+    for (const name of namedImports) {
+      if (name) {
+        imports.push({ name, from });
+      }
+    }
+  }
+  return imports;
+}
+function extractFunctionCalls(code) {
+  const calls = new Set;
+  const callRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[(<]/g;
+  const keywords = new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "function",
+    "class",
+    "interface",
+    "type",
+    "import",
+    "export",
+    "return",
+    "throw",
+    "new",
+    "typeof",
+    "instanceof"
+  ]);
+  let match;
+  while ((match = callRegex.exec(code)) !== null) {
+    const name = match[1];
+    if (!keywords.has(name)) {
+      calls.add(name);
+    }
+  }
+  return Array.from(calls);
+}
+function findExportReferences(files, exportNames) {
+  const references = [];
+  const exportSet = new Set(exportNames);
+  for (const file of files) {
+    for (let blockIndex = 0;blockIndex < file.codeBlocks.length; blockIndex++) {
+      const block = file.codeBlocks[blockIndex];
+      const imports = extractImports(block.code);
+      for (const imp of imports) {
+        if (exportSet.has(imp.name)) {
+          references.push({
+            exportName: imp.name,
+            file: file.path,
+            line: block.lineStart,
+            context: getContextFromCode(block.code, imp.name),
+            inCodeBlock: true,
+            blockIndex
+          });
+        }
+      }
+      const calls = extractFunctionCalls(block.code);
+      for (const call of calls) {
+        if (exportSet.has(call)) {
+          const alreadyFound = references.some((r) => r.exportName === call && r.file === file.path && r.blockIndex === blockIndex);
+          if (!alreadyFound) {
+            references.push({
+              exportName: call,
+              file: file.path,
+              line: block.lineStart,
+              context: getContextFromCode(block.code, call),
+              inCodeBlock: true,
+              blockIndex
+            });
+          }
+        }
+      }
+    }
+  }
+  return references;
+}
+function getContextFromCode(code, name) {
+  const lines = code.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    if (lines[i].includes(name)) {
+      const start = Math.max(0, i - 1);
+      const end = Math.min(lines.length, i + 2);
+      return lines.slice(start, end).join(`
+`);
+    }
+  }
+  return code.slice(0, 100);
+}
+function blockReferencesExport(block, exportName) {
+  const imports = extractImports(block.code);
+  if (imports.some((i) => i.name === exportName)) {
+    return true;
+  }
+  const calls = extractFunctionCalls(block.code);
+  return calls.includes(exportName);
+}
+// src/markdown/analyzer.ts
+function getChangeType(exportName, diff) {
+  if (diff.breaking.includes(exportName)) {
+    return "signature-changed";
+  }
+  return null;
+}
+function analyzeDocsImpact(diff, markdownFiles, newExportNames = []) {
+  const changedExports = [
+    ...diff.breaking
+  ];
+  const references = findExportReferences(markdownFiles, changedExports);
+  const impactByFile = new Map;
+  for (const ref of references) {
+    const changeType = getChangeType(ref.exportName, diff);
+    if (!changeType)
+      continue;
+    let impact = impactByFile.get(ref.file);
+    if (!impact) {
+      impact = { file: ref.file, references: [] };
+      impactByFile.set(ref.file, impact);
+    }
+    impact.references.push({
+      exportName: ref.exportName,
+      line: ref.line,
+      changeType,
+      context: ref.context
+    });
+  }
+  const documentedExports = new Set;
+  for (const file of markdownFiles) {
+    for (const block of file.codeBlocks) {
+      for (const exportName of newExportNames) {
+        if (block.code.includes(exportName)) {
+          documentedExports.add(exportName);
+        }
+      }
+    }
+  }
+  const missingDocs = diff.nonBreaking.filter((name) => !documentedExports.has(name));
+  const totalCodeBlocks = markdownFiles.reduce((sum, f) => sum + f.codeBlocks.length, 0);
+  const allReferences = findExportReferences(markdownFiles, [
+    ...changedExports,
+    ...diff.nonBreaking
+  ]);
+  return {
+    impactedFiles: Array.from(impactByFile.values()),
+    missingDocs,
+    stats: {
+      filesScanned: markdownFiles.length,
+      codeBlocksFound: totalCodeBlocks,
+      referencesFound: allReferences.length,
+      impactedReferences: references.length
+    }
+  };
+}
+function findDeprecatedReferences(markdownFiles, deprecatedExports) {
+  return findExportReferences(markdownFiles, deprecatedExports);
+}
+function findRemovedReferences(markdownFiles, removedExports) {
+  return findExportReferences(markdownFiles, removedExports);
+}
+function hasDocsForExport(markdownFiles, exportName) {
+  const refs = findExportReferences(markdownFiles, [exportName]);
+  return refs.length > 0;
+}
+function getDocumentedExports(markdownFiles, exportNames) {
+  const documented = [];
+  for (const name of exportNames) {
+    if (hasDocsForExport(markdownFiles, name)) {
+      documented.push(name);
+    }
+  }
+  return documented;
+}
+function getUndocumentedExports(markdownFiles, exportNames) {
+  const documented = new Set(getDocumentedExports(markdownFiles, exportNames));
+  return exportNames.filter((name) => !documented.has(name));
+}
+// src/markdown/diff-with-docs.ts
+import { diffSpec } from "@openpkg-ts/spec";
+function diffSpecWithDocs(oldSpec, newSpec, options = {}) {
+  const baseDiff = diffSpec(oldSpec, newSpec);
+  if (!options.markdownFiles?.length) {
+    return baseDiff;
+  }
+  const newExportNames = newSpec.exports?.map((e) => e.name) ?? [];
+  const docsImpact = analyzeDocsImpact(baseDiff, options.markdownFiles, newExportNames);
+  return {
+    ...baseDiff,
+    docsImpact
+  };
+}
+function hasDocsImpact(diff) {
+  if (!diff.docsImpact)
+    return false;
+  return diff.docsImpact.impactedFiles.length > 0 || diff.docsImpact.missingDocs.length > 0;
+}
+function getDocsImpactSummary(diff) {
+  if (!diff.docsImpact) {
+    return {
+      impactedFileCount: 0,
+      impactedReferenceCount: 0,
+      missingDocsCount: 0,
+      totalIssues: 0
+    };
+  }
+  const impactedFileCount = diff.docsImpact.impactedFiles.length;
+  const impactedReferenceCount = diff.docsImpact.impactedFiles.reduce((sum, f) => sum + f.references.length, 0);
+  const missingDocsCount = diff.docsImpact.missingDocs.length;
+  return {
+    impactedFileCount,
+    impactedReferenceCount,
+    missingDocsCount,
+    totalIssues: impactedReferenceCount + missingDocsCount
+  };
+}
 // src/analysis/run-analysis.ts
 import * as fs2 from "node:fs";
 import * as path4 from "node:path";
@@ -4083,7 +4384,7 @@ function findJSDocLocation(sourceFile, symbolName, approximateLine) {
       };
     }
   }
-  function visit(node) {
+  function visit2(node) {
     if (ts2.isFunctionDeclaration(node) && node.name) {
       processNode(node, node.name.getText(sourceFile));
     }
@@ -4106,9 +4407,9 @@ function findJSDocLocation(sourceFile, symbolName, approximateLine) {
     if (ts2.isMethodDeclaration(node) && node.name) {
       processNode(node, node.name.getText(sourceFile));
     }
-    ts2.forEachChild(node, visit);
+    ts2.forEachChild(node, visit2);
   }
-  visit(sourceFile);
+  visit2(sourceFile);
   return result;
 }
 async function applyEdits(edits) {
@@ -4660,28 +4961,530 @@ async function runExamplesWithPackage(examples, options) {
     } catch {}
   }
 }
+// src/detect/filesystem.ts
+import * as fs6 from "node:fs";
+import * as nodePath from "node:path";
+import { Writable } from "node:stream";
+
+class NodeFileSystem {
+  basePath;
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  resolve(relativePath) {
+    return nodePath.join(this.basePath, relativePath);
+  }
+  async exists(relativePath) {
+    return fs6.existsSync(this.resolve(relativePath));
+  }
+  async readFile(relativePath) {
+    return fs6.readFileSync(this.resolve(relativePath), "utf-8");
+  }
+  async readDir(relativePath) {
+    return fs6.readdirSync(this.resolve(relativePath));
+  }
+  async isDirectory(relativePath) {
+    const fullPath = this.resolve(relativePath);
+    if (!fs6.existsSync(fullPath))
+      return false;
+    return fs6.statSync(fullPath).isDirectory();
+  }
+}
+function createCaptureStream() {
+  let output = "";
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      output += chunk.toString();
+      callback();
+    }
+  });
+  return { stream, getOutput: () => output };
+}
+
+class SandboxFileSystem {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  async exists(path8) {
+    const result = await this.sandbox.runCommand({
+      cmd: "test",
+      args: ["-e", path8]
+    });
+    return result.exitCode === 0;
+  }
+  async readFile(path8) {
+    const capture = createCaptureStream();
+    await this.sandbox.runCommand({
+      cmd: "cat",
+      args: [path8],
+      stdout: capture.stream
+    });
+    return capture.getOutput();
+  }
+  async readDir(path8) {
+    const capture = createCaptureStream();
+    await this.sandbox.runCommand({
+      cmd: "ls",
+      args: ["-1", path8],
+      stdout: capture.stream
+    });
+    return capture.getOutput().split(`
+`).filter(Boolean);
+  }
+  async isDirectory(path8) {
+    const result = await this.sandbox.runCommand({
+      cmd: "test",
+      args: ["-d", path8]
+    });
+    return result.exitCode === 0;
+  }
+}
+// src/detect/package-manager.ts
+var PM_CONFIGS = [
+  {
+    lockfile: "pnpm-lock.yaml",
+    info: {
+      name: "pnpm",
+      lockfile: "pnpm-lock.yaml",
+      installArgs: ["install", "--frozen-lockfile"],
+      runPrefix: ["pnpm"]
+    }
+  },
+  {
+    lockfile: "bun.lock",
+    info: {
+      name: "bun",
+      lockfile: "bun.lock",
+      installArgs: ["install", "--frozen-lockfile"],
+      runPrefix: ["bun"]
+    }
+  },
+  {
+    lockfile: "bun.lockb",
+    info: {
+      name: "bun",
+      lockfile: "bun.lockb",
+      installArgs: ["install", "--frozen-lockfile"],
+      runPrefix: ["bun"]
+    }
+  },
+  {
+    lockfile: "yarn.lock",
+    info: {
+      name: "yarn",
+      lockfile: "yarn.lock",
+      installArgs: ["install", "--frozen-lockfile"],
+      runPrefix: ["yarn"]
+    }
+  },
+  {
+    lockfile: "package-lock.json",
+    info: {
+      name: "npm",
+      lockfile: "package-lock.json",
+      installArgs: ["install", "--legacy-peer-deps"],
+      runPrefix: ["npm", "run"]
+    }
+  }
+];
+var DEFAULT_PM = {
+  name: "npm",
+  lockfile: null,
+  installArgs: ["install", "--legacy-peer-deps"],
+  runPrefix: ["npm", "run"]
+};
+async function detectPackageManager2(fs7) {
+  for (const { lockfile, info } of PM_CONFIGS) {
+    if (await fs7.exists(lockfile)) {
+      return info;
+    }
+  }
+  return DEFAULT_PM;
+}
+function getInstallCommand2(pm) {
+  return [pm.name, ...pm.installArgs];
+}
+function getRunCommand(pm, script) {
+  return [...pm.runPrefix, script];
+}
+// src/detect/utils.ts
+async function safeParseJson(fs7, path8) {
+  try {
+    if (!await fs7.exists(path8))
+      return null;
+    const content = await fs7.readFile(path8);
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function readPackageJson(fs7, dir) {
+  const path8 = dir === "." ? "package.json" : `${dir}/package.json`;
+  return safeParseJson(fs7, path8);
+}
+
+// src/detect/monorepo.ts
+async function detectMonorepo(fs7) {
+  const pkgJson = await readPackageJson(fs7, ".");
+  if (pkgJson?.workspaces) {
+    const patterns = extractWorkspacePatterns(pkgJson.workspaces);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson.name, pkgJson.private);
+    return {
+      isMonorepo: packages.length > 0,
+      type: "npm-workspaces",
+      patterns,
+      packages
+    };
+  }
+  if (await fs7.exists("pnpm-workspace.yaml")) {
+    const content = await fs7.readFile("pnpm-workspace.yaml");
+    const patterns = parsePnpmWorkspace(content);
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson?.name, pkgJson?.private);
+    return {
+      isMonorepo: packages.length > 0,
+      type: "pnpm-workspaces",
+      patterns,
+      packages
+    };
+  }
+  if (await fs7.exists("lerna.json")) {
+    const lerna = await safeParseJson(fs7, "lerna.json");
+    const patterns = lerna?.packages ?? ["packages/*"];
+    const packages = await resolveWorkspacePackages(fs7, patterns, pkgJson?.name, pkgJson?.private);
+    return {
+      isMonorepo: packages.length > 0,
+      type: "lerna",
+      patterns,
+      packages
+    };
+  }
+  return { isMonorepo: false, type: "none", patterns: [], packages: [] };
+}
+function extractWorkspacePatterns(workspaces) {
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((w) => typeof w === "string");
+  }
+  if (typeof workspaces === "object" && workspaces !== null) {
+    if (Array.isArray(workspaces.packages)) {
+      return workspaces.packages.filter((w) => typeof w === "string");
+    }
+  }
+  return [];
+}
+function parsePnpmWorkspace(content) {
+  const lines = content.split(`
+`);
+  const patterns = [];
+  let inPackages = false;
+  for (const line of lines) {
+    if (line.match(/^packages:/i)) {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      if (line.match(/^\w+:/) && !line.startsWith(" ") && !line.startsWith("\t")) {
+        break;
+      }
+      const match = line.match(/^\s*-\s*['"]?([^'"]+)['"]?\s*$/);
+      if (match) {
+        patterns.push(match[1].trim());
+      }
+    }
+  }
+  return patterns.length > 0 ? patterns : ["packages/*"];
+}
+async function resolveWorkspacePackages(fs7, patterns, rootPackageName, rootIsPrivate) {
+  const packages = [];
+  const seen = new Set;
+  if (rootPackageName && !rootIsPrivate && rootPackageName !== "root") {
+    packages.push({
+      name: rootPackageName,
+      path: ".",
+      private: false
+    });
+    seen.add(rootPackageName);
+  }
+  const dirsToScan = new Set;
+  for (const pattern of patterns) {
+    if (pattern.startsWith("!"))
+      continue;
+    const dir = pattern.replace(/\/?\*\*?$/, "");
+    if (dir && !dir.includes("*")) {
+      dirsToScan.add(dir);
+    }
+  }
+  dirsToScan.add("packages");
+  for (const dir of dirsToScan) {
+    if (!await fs7.exists(dir))
+      continue;
+    if (!await fs7.isDirectory(dir))
+      continue;
+    const subdirs = await fs7.readDir(dir);
+    for (const subdir of subdirs) {
+      const pkgPath = `${dir}/${subdir}`;
+      const pkgJsonPath = `${pkgPath}/package.json`;
+      if (!await fs7.exists(pkgJsonPath))
+        continue;
+      try {
+        const content = await fs7.readFile(pkgJsonPath);
+        if (content.includes("No such file"))
+          continue;
+        const pkg = JSON.parse(content);
+        if (pkg.name && !seen.has(pkg.name)) {
+          seen.add(pkg.name);
+          packages.push({
+            name: pkg.name,
+            path: pkgPath,
+            private: pkg.private ?? false
+          });
+        }
+      } catch {}
+    }
+  }
+  return packages.sort((a, b) => a.name.localeCompare(b.name));
+}
+function findPackageByName(packages, nameOrPath) {
+  return packages.find((p) => p.name === nameOrPath || p.path === nameOrPath);
+}
+function formatPackageList(packages, limit = 10) {
+  const publicPackages = packages.filter((p) => !p.private);
+  const lines = publicPackages.slice(0, limit).map((pkg) => `  --package ${pkg.name}`);
+  if (publicPackages.length > limit) {
+    lines.push(`  ... and ${publicPackages.length - limit} more`);
+  }
+  return lines.join(`
+`);
+}
+// src/detect/entry-point.ts
+async function detectEntryPoint(fs7, packagePath = ".") {
+  const pkgJson = await readPackageJson(fs7, packagePath);
+  if (!pkgJson) {
+    throw new Error("No package.json found - not a valid npm package");
+  }
+  const typesField = pkgJson.types || pkgJson.typings;
+  if (typesField && typeof typesField === "string") {
+    const resolved = await resolveToSource(fs7, packagePath, typesField);
+    if (resolved) {
+      return { ...resolved, source: "types" };
+    }
+  }
+  if (pkgJson.exports && typeof pkgJson.exports === "object") {
+    const dotExport = pkgJson.exports["."];
+    if (dotExport && typeof dotExport === "object" && "types" in dotExport) {
+      const typesPath = dotExport.types;
+      if (typesPath && typeof typesPath === "string") {
+        const resolved = await resolveToSource(fs7, packagePath, typesPath);
+        if (resolved) {
+          return { ...resolved, source: "exports" };
+        }
+      }
+    }
+  }
+  if (pkgJson.main && typeof pkgJson.main === "string") {
+    const resolved = await resolveToSource(fs7, packagePath, pkgJson.main);
+    if (resolved) {
+      return { ...resolved, source: "main" };
+    }
+  }
+  if (pkgJson.module && typeof pkgJson.module === "string") {
+    const resolved = await resolveToSource(fs7, packagePath, pkgJson.module);
+    if (resolved) {
+      return { ...resolved, source: "module" };
+    }
+  }
+  const fallbacks = [
+    "src/index.ts",
+    "src/index.tsx",
+    "src/main.ts",
+    "index.ts",
+    "lib/index.ts",
+    "source/index.ts"
+  ];
+  for (const fallback of fallbacks) {
+    const fullPath = packagePath === "." ? fallback : `${packagePath}/${fallback}`;
+    if (await fs7.exists(fullPath)) {
+      return { path: fullPath, 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 resolveToSource(fs7, basePath, filePath) {
+  const normalized = filePath.replace(/^\.\//, "");
+  const fullPath = (p) => basePath === "." ? p : `${basePath}/${p}`;
+  const isSourceTs = normalized.endsWith(".ts") && !normalized.endsWith(".d.ts") || normalized.endsWith(".tsx");
+  if (isSourceTs) {
+    const path8 = fullPath(normalized);
+    if (await fs7.exists(path8)) {
+      return { path: path8, isDeclarationOnly: false };
+    }
+  }
+  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 = normalized.replace(/\.d\.ts$/, "").split("/").pop();
+    if (baseName) {
+      candidates.push(`src/${baseName}.ts`);
+    }
+  }
+  for (const candidate of candidates) {
+    if (candidate.endsWith(".d.ts"))
+      continue;
+    const path8 = fullPath(candidate);
+    if (await fs7.exists(path8)) {
+      return { path: path8, isDeclarationOnly: false };
+    }
+  }
+  if (normalized.endsWith(".d.ts")) {
+    const path8 = fullPath(normalized);
+    if (await fs7.exists(path8)) {
+      return { path: path8, isDeclarationOnly: true };
+    }
+  }
+  return null;
+}
+// src/detect/build.ts
+async function detectBuildInfo(fs7, packagePath = ".") {
+  const pkgJson = await readPackageJson(fs7, packagePath);
+  const scripts = pkgJson?.scripts ?? {};
+  const scriptNames = Object.keys(scripts);
+  const buildScripts = scriptNames.filter((name) => name === "build" || name === "compile" || name === "tsc" || name.startsWith("build:") || name.startsWith("compile:"));
+  const tsconfigPath = packagePath === "." ? "tsconfig.json" : `${packagePath}/tsconfig.json`;
+  const hasTsConfig = await fs7.exists(tsconfigPath);
+  const hasTsDep = pkgJson?.devDependencies?.typescript !== undefined || pkgJson?.dependencies?.typescript !== undefined;
+  const hasTypeScript = hasTsConfig || hasTsDep;
+  const wasm = await detectWasmProject(fs7, packagePath, scripts);
+  const napi = detectNapiProject(pkgJson);
+  return {
+    scripts: buildScripts,
+    hasBuildScript: buildScripts.length > 0,
+    hasTypeScript,
+    exoticIndicators: { wasm, napi }
+  };
+}
+async function detectWasmProject(fs7, packagePath, scripts) {
+  const pkgCargoPath = packagePath === "." ? "Cargo.toml" : `${packagePath}/Cargo.toml`;
+  if (await fs7.exists(pkgCargoPath))
+    return true;
+  if (packagePath !== "." && await fs7.exists("Cargo.toml"))
+    return true;
+  const allScripts = Object.values(scripts).join(" ");
+  return allScripts.includes("wasm-pack") || allScripts.includes("wasm");
+}
+function detectNapiProject(pkgJson) {
+  if (!pkgJson)
+    return false;
+  const deps = {
+    ...pkgJson.dependencies ?? {},
+    ...pkgJson.devDependencies ?? {}
+  };
+  return Object.keys(deps).some((dep) => dep.includes("napi"));
+}
+function getPrimaryBuildScript(buildInfo) {
+  if (buildInfo.scripts.includes("build"))
+    return "build";
+  if (buildInfo.scripts.includes("compile"))
+    return "compile";
+  if (buildInfo.scripts.includes("tsc"))
+    return "tsc";
+  return buildInfo.scripts[0] ?? null;
+}
+// src/detect/index.ts
+async function analyzeProject(fs7, options = {}) {
+  const [packageManager, monorepo] = await Promise.all([
+    detectPackageManager2(fs7),
+    detectMonorepo(fs7)
+  ]);
+  let targetPath = ".";
+  if (monorepo.isMonorepo) {
+    if (!options.targetPackage) {
+      const publicPackages = monorepo.packages.filter((p) => !p.private);
+      const packageNames = publicPackages.map((p) => p.name).join(", ");
+      throw new Error(`Monorepo detected with ${publicPackages.length} packages. ` + `Specify target with --package. Available: ${packageNames}`);
+    }
+    const pkg = findPackageByName(monorepo.packages, options.targetPackage);
+    if (!pkg) {
+      const available = monorepo.packages.map((p) => p.name).join(", ");
+      throw new Error(`Package not found: ${options.targetPackage}. Available packages: ${available}`);
+    }
+    targetPath = pkg.path;
+  }
+  const [entryPoint, build] = await Promise.all([
+    detectEntryPoint(fs7, targetPath),
+    detectBuildInfo(fs7, targetPath)
+  ]);
+  return { packageManager, monorepo, entryPoint, build };
+}
 export {
   serializeJSDoc,
+  safeParseJson,
   runExamplesWithPackage,
   runExamples,
   runExample,
+  readPackageJson,
+  parseMarkdownFiles,
+  parseMarkdownFile,
   parseJSDocToPatch,
   parseAssertions,
   mergeFixes,
   isFixableDrift,
+  isExecutableLang,
   hasNonAssertionComments,
+  hasDocsImpact,
+  hasDocsForExport,
+  getUndocumentedExports,
+  getRunCommand,
+  getPrimaryBuildScript,
+  getInstallCommand2 as getInstallCommand,
+  getDocumentedExports,
+  getDocsImpactSummary,
   generateFixesForExport,
   generateFix,
+  formatPackageList,
+  findRemovedReferences,
+  findPackageByName,
   findJSDocLocation,
+  findExportReferences,
+  findDeprecatedReferences,
   extractPackageSpec,
+  extractImports,
+  extractFunctionCalls,
+  diffSpecWithDocs,
+  detectPackageManager2 as detectPackageManager,
+  detectMonorepo,
   detectExampleRuntimeErrors,
   detectExampleAssertionFailures,
+  detectEntryPoint,
+  detectBuildInfo,
   createSourceFile,
   categorizeDrifts,
+  blockReferencesExport,
   applyPatchToJSDoc,
   applyEdits,
+  analyzeProject,
   analyzeFile,
+  analyzeDocsImpact,
   analyze,
+  SandboxFileSystem,
   OpenPkg,
+  NodeFileSystem,
   DocCov
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccov/sdk",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "DocCov SDK - Documentation coverage and drift detection for TypeScript",
   "keywords": [
     "typescript",
@@ -40,7 +40,13 @@
   ],
   "dependencies": {
     "@openpkg-ts/spec": "^0.3.1",
-    "typescript": "^5.0.0"
+    "@vercel/sandbox": "^1.0.3",
+    "mdast": "^3.0.0",
+    "remark-mdx": "^3.1.0",
+    "remark-parse": "^11.0.0",
+    "typescript": "^5.0.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.0.0"
   },
   "devDependencies": {
     "@types/bun": "latest",