@doccov/sdk 0.3.2 → 0.3.4

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";
@@ -1317,6 +1618,20 @@ function withDescription(schema, description) {
     description
   };
 }
+function getPropertyType(prop, parentType, typeChecker) {
+  if (prop.valueDeclaration) {
+    return typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+  }
+  const propType = typeChecker.getTypeOfPropertyOfType(parentType, prop.getName());
+  if (propType) {
+    return propType;
+  }
+  const decl = prop.declarations?.[0];
+  if (decl) {
+    return typeChecker.getTypeOfSymbolAtLocation(prop, decl);
+  }
+  return typeChecker.getAnyType();
+}
 function propertiesToSchema(properties, description) {
   const schema = {
     type: "object",
@@ -1657,7 +1972,7 @@ function formatTypeReference(type, typeChecker, typeRefs, referencedTypes, visit
             };
             const required = [];
             for (const prop of properties) {
-              const propType = typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+              const propType = getPropertyType(prop, type, typeChecker);
               const propName = prop.getName();
               objSchema.properties[propName] = formatTypeReference(propType, typeChecker, typeRefs, referencedTypes, visited);
               if (!(prop.flags & ts2.SymbolFlags.Optional)) {
@@ -1742,7 +2057,7 @@ function structureParameter(param, paramDecl, paramType, typeChecker, typeRefs,
       const isAnonymousObject = isObjectLiteralType(subType) || symbol2?.getName().startsWith("__");
       if (isAnonymousObject) {
         for (const prop of subType.getProperties()) {
-          const propType = typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+          const propType = getPropertyType(prop, subType, typeChecker);
           let description = "";
           if (functionDoc) {
             const propName = prop.getName();
@@ -1762,7 +2077,7 @@ function structureParameter(param, paramDecl, paramType, typeChecker, typeRefs,
         const _symbolName = symbol2.getName();
         if (!isBuiltInType(_symbolName)) {
           for (const prop of subType.getProperties()) {
-            const propType = typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+            const propType = getPropertyType(prop, subType, typeChecker);
             properties.push({
               name: prop.getName(),
               type: formatTypeReference(propType, typeChecker, typeRefs, referencedTypes),
@@ -1793,7 +2108,7 @@ function structureParameter(param, paramDecl, paramType, typeChecker, typeRefs,
       if (isObjectLiteralType(subType) || symbol2?.getName().startsWith("__")) {
         const properties = [];
         for (const prop of subType.getProperties()) {
-          const propType = typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+          const propType = getPropertyType(prop, subType, typeChecker);
           properties.push({
             name: prop.getName(),
             type: formatTypeReference(propType, typeChecker, typeRefs, referencedTypes),
@@ -1827,7 +2142,7 @@ function structureParameter(param, paramDecl, paramType, typeChecker, typeRefs,
   if ((symbol?.getName().startsWith("__") || isObjectLiteralType(paramType)) && paramType.getProperties().length > 0) {
     const properties = [];
     for (const prop of paramType.getProperties()) {
-      const propType = typeChecker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
+      const propType = getPropertyType(prop, paramType, typeChecker);
       properties.push({
         name: prop.getName(),
         type: formatTypeReference(propType, typeChecker, typeRefs, referencedTypes),
@@ -2524,7 +2839,8 @@ function serializeCallSignatures(signatures, symbol, context, parsedDoc) {
   return signatures.map((signature) => {
     const parameters = signature.getParameters().map((param) => {
       const paramDecl = param.declarations?.find(ts2.isParameter);
-      const paramType = paramDecl ? paramDecl.type != null ? checker.getTypeFromTypeNode(paramDecl.type) : checker.getTypeAtLocation(paramDecl) : checker.getTypeOfSymbolAtLocation(param, symbol?.declarations?.[0] ?? signature.declaration ?? param.declarations?.[0] ?? param.valueDeclaration);
+      const location = symbol?.declarations?.[0] ?? signature.declaration ?? param.declarations?.[0] ?? param.valueDeclaration;
+      const paramType = paramDecl ? paramDecl.type != null ? checker.getTypeFromTypeNode(paramDecl.type) : checker.getTypeAtLocation(paramDecl) : location ? checker.getTypeOfSymbolAtLocation(param, location) : checker.getAnyType();
       collectReferencedTypes(paramType, checker, referencedTypes);
       if (paramDecl?.type) {
         collectReferencedTypesFromNode(paramDecl.type, checker, referencedTypes);
@@ -4083,7 +4399,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 +4422,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 +4976,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
 };