@doccov/sdk 0.3.6 → 0.5.6

package/dist/index.d.ts

@@ -116,7 +116,11 @@ interface ExportReference {
 /**
 * Change type for an impacted reference
 */
-type DocsChangeType = "signature-changed" | "removed" | "deprecated";
+type DocsChangeType = "signature-changed" | "removed" | "deprecated" | "method-removed" | "method-changed" | "method-deprecated";
+/**
+* Member-level change type
+*/
+type MemberChangeType = "added" | "removed" | "signature-changed";
 /**
 * An impacted reference in a documentation file
 */
@@ -131,6 +135,14 @@ interface DocsImpactReference {
 	suggestion?: string;
 	/** Context around the reference */
 	context?: string;
+	/** Member/method name if this is a member-level change */
+	memberName?: string;
+	/** Type of member change (added, removed, signature-changed) */
+	memberChangeType?: MemberChangeType;
+	/** Suggested replacement for removed/changed members */
+	replacementSuggestion?: string;
+	/** True if this is just a class instantiation (new ClassName()) */
+	isInstantiation?: boolean;
 }
 /**
 * Documentation file impact summary
@@ -198,14 +210,32 @@ declare function findExportReferences(files: MarkdownDocFile[], exportNames: str
 */
 declare function blockReferencesExport(block: MarkdownCodeBlock, exportName: string): boolean;
 import { SpecDiff } from "@openpkg-ts/spec";
+type MemberChangeType2 = "added" | "removed" | "signature-changed";
+interface MemberChange {
+	/** The class this member belongs to */
+	className: string;
+	/** The member name (e.g., "evaluateChainhook") */
+	memberName: string;
+	/** Kind of member */
+	memberKind: "method" | "property" | "accessor" | "constructor";
+	/** Type of change */
+	changeType: MemberChangeType2;
+	/** Old signature string (for signature changes) */
+	oldSignature?: string;
+	/** New signature string (for signature changes) */
+	newSignature?: string;
+	/** Suggested replacement (e.g., "Use replayChainhook instead") */
+	suggestion?: string;
+}
 /**
 * 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)
+* @param memberChanges - Optional member-level changes for granular detection
 */
-declare function analyzeDocsImpact(diff: SpecDiff, markdownFiles: MarkdownDocFile[], newExportNames?: string[]): DocsImpactResult;
+declare function analyzeDocsImpact(diff: SpecDiff, markdownFiles: MarkdownDocFile[], newExportNames?: string[], memberChanges?: MemberChange[]): DocsImpactResult;
 /**
 * Find references to deprecated exports
 */
@@ -225,13 +255,15 @@ declare function getDocumentedExports(markdownFiles: MarkdownDocFile[], exportNa
 * 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";
+import { OpenPkg as OpenPkg3, 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;
+	/** Member-level changes for classes (methods added/removed/changed) */
+	memberChanges?: MemberChange[];
 }
 /**
 * Options for diffSpecWithDocs
@@ -263,7 +295,7 @@ interface DiffWithDocsOptions {
 * }
 * ```
 */
-declare function diffSpecWithDocs(oldSpec: OpenPkg2, newSpec: OpenPkg2, options?: DiffWithDocsOptions): SpecDiffWithDocs;
+declare function diffSpecWithDocs(oldSpec: OpenPkg3, newSpec: OpenPkg3, options?: DiffWithDocsOptions): SpecDiffWithDocs;
 /**
 * Check if a diff has any docs impact
 */
@@ -276,6 +308,7 @@ declare function getDocsImpactSummary(diff: SpecDiffWithDocs): {
 	impactedReferenceCount: number;
 	missingDocsCount: number;
 	totalIssues: number;
+	memberChangesCount: number;
 };
 interface DocCovOptions {
 	includePrivate?: boolean;
@@ -466,7 +499,7 @@ 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 OpenPkg3: typeof DocCov;
+declare const OpenPkg4: typeof DocCov;
 /**
 * Project detection types for I/O-agnostic project analysis.
 * Used by both CLI (NodeFileSystem) and API (SandboxFileSystem).
@@ -723,4 +756,4 @@ declare function readPackageJson(fs: FileSystem, dir: string): Promise<PackageJs
 * ```
 */
 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 };
+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, OpenPkg4 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

@@ -1107,6 +1107,39 @@ function extractFunctionCalls(code) {
   }
   return Array.from(calls);
 }
+function extractMethodCalls(code) {
+  const calls = [];
+  const lines = code.split(`
+`);
+  const methodCallRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\.\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
+  const skipObjects = new Set(["console", "Math", "JSON", "Object", "Array", "String", "Number"]);
+  for (let lineIndex = 0;lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    let match;
+    methodCallRegex.lastIndex = 0;
+    while ((match = methodCallRegex.exec(line)) !== null) {
+      const objectName = match[1];
+      const methodName = match[2];
+      if (skipObjects.has(objectName)) {
+        continue;
+      }
+      calls.push({
+        objectName,
+        methodName,
+        line: lineIndex,
+        context: line.trim()
+      });
+    }
+  }
+  return calls;
+}
+function hasInstantiation(code, className) {
+  const regex = new RegExp(`\\bnew\\s+${escapeRegex(className)}\\s*\\(`, "g");
+  return regex.test(code);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function findExportReferences(files, exportNames) {
   const references = [];
   const exportSet = new Set(exportNames);
@@ -1174,27 +1207,99 @@ function getChangeType(exportName, diff) {
   }
   return null;
 }
-function analyzeDocsImpact(diff, markdownFiles, newExportNames = []) {
+function mapMemberChangeType(memberChangeType) {
+  switch (memberChangeType) {
+    case "removed":
+      return "method-removed";
+    case "signature-changed":
+      return "method-changed";
+    default:
+      return "signature-changed";
+  }
+}
+function analyzeDocsImpact(diff, markdownFiles, newExportNames = [], memberChanges) {
   const changedExports = [
     ...diff.breaking
   ];
-  const references = findExportReferences(markdownFiles, changedExports);
+  const memberChangesByMethod = new Map;
+  if (memberChanges) {
+    for (const mc of memberChanges) {
+      memberChangesByMethod.set(mc.memberName, mc);
+    }
+  }
+  const classesWithMemberChanges = new Set(memberChanges?.map((mc) => mc.className) ?? []);
   const impactByFile = new Map;
-  for (const ref of references) {
-    const changeType = getChangeType(ref.exportName, diff);
-    if (!changeType)
-      continue;
-    let impact = impactByFile.get(ref.file);
+  const addReference = (file, ref) => {
+    let impact = impactByFile.get(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
-    });
+      impact = { file, references: [] };
+      impactByFile.set(file, impact);
+    }
+    impact.references.push(ref);
+  };
+  for (const mdFile of markdownFiles) {
+    for (const block of mdFile.codeBlocks) {
+      const reportedRefs = new Set;
+      if (memberChanges && memberChanges.length > 0) {
+        const methodCalls = extractMethodCalls(block.code);
+        for (const call of methodCalls) {
+          const memberChange = memberChangesByMethod.get(call.methodName);
+          if (memberChange) {
+            const refKey = `${mdFile.path}:${block.lineStart + call.line}:${call.methodName}`;
+            if (!reportedRefs.has(refKey)) {
+              reportedRefs.add(refKey);
+              addReference(mdFile.path, {
+                exportName: memberChange.className,
+                memberName: call.methodName,
+                memberChangeType: memberChange.changeType,
+                changeType: mapMemberChangeType(memberChange.changeType),
+                replacementSuggestion: memberChange.suggestion,
+                line: block.lineStart + call.line,
+                context: call.context,
+                isInstantiation: false
+              });
+            }
+          }
+        }
+        for (const className of classesWithMemberChanges) {
+          if (hasInstantiation(block.code, className)) {
+            const refKey = `${mdFile.path}:${block.lineStart}:new ${className}`;
+            if (!reportedRefs.has(refKey)) {
+              const hasMethodRefs = Array.from(reportedRefs).some((key) => key.startsWith(`${mdFile.path}:`) && memberChanges.some((mc) => mc.className === className && key.includes(mc.memberName)));
+              if (!hasMethodRefs) {
+                reportedRefs.add(refKey);
+                addReference(mdFile.path, {
+                  exportName: className,
+                  line: block.lineStart,
+                  changeType: "signature-changed",
+                  context: `new ${className}(...)`,
+                  isInstantiation: true
+                });
+              }
+            }
+          }
+        }
+      }
+      const exportsWithoutMemberChanges = changedExports.filter((name) => !classesWithMemberChanges.has(name));
+      if (exportsWithoutMemberChanges.length > 0) {
+        const refs = findExportReferences([{ ...mdFile, codeBlocks: [block] }], exportsWithoutMemberChanges);
+        for (const ref of refs) {
+          const changeType = getChangeType(ref.exportName, diff);
+          if (!changeType)
+            continue;
+          const refKey = `${ref.file}:${ref.line}:${ref.exportName}`;
+          if (!reportedRefs.has(refKey)) {
+            reportedRefs.add(refKey);
+            addReference(ref.file, {
+              exportName: ref.exportName,
+              line: ref.line,
+              changeType,
+              context: ref.context
+            });
+          }
+        }
+      }
+    }
   }
   const documentedExports = new Set;
   for (const file of markdownFiles) {
@@ -1208,10 +1313,11 @@ function analyzeDocsImpact(diff, markdownFiles, newExportNames = []) {
   }
   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
-  ]);
+  const allReferences = findExportReferences(markdownFiles, [...changedExports, ...diff.nonBreaking]);
+  let impactedReferences = 0;
+  for (const impact of impactByFile.values()) {
+    impactedReferences += impact.references.length;
+  }
   return {
     impactedFiles: Array.from(impactByFile.values()),
     missingDocs,
@@ -1219,7 +1325,7 @@ function analyzeDocsImpact(diff, markdownFiles, newExportNames = []) {
       filesScanned: markdownFiles.length,
       codeBlocksFound: totalCodeBlocks,
       referencesFound: allReferences.length,
-      impactedReferences: references.length
+      impactedReferences
     }
   };
 }
@@ -1246,18 +1352,213 @@ function getUndocumentedExports(markdownFiles, exportNames) {
   const documented = new Set(getDocumentedExports(markdownFiles, exportNames));
   return exportNames.filter((name) => !documented.has(name));
 }
+// src/markdown/member-diff.ts
+function diffMemberChanges(oldSpec, newSpec, changedClassNames) {
+  const changes = [];
+  const oldExportMap = toExportMap(oldSpec.exports ?? []);
+  const newExportMap = toExportMap(newSpec.exports ?? []);
+  for (const className of changedClassNames) {
+    const oldExport = oldExportMap.get(className);
+    const newExport = newExportMap.get(className);
+    if (!oldExport?.members && !newExport?.members) {
+      continue;
+    }
+    const oldMembers = toMemberMap(oldExport?.members ?? []);
+    const newMembers = toMemberMap(newExport?.members ?? []);
+    const addedMemberNames = [];
+    for (const [memberName, newMember] of newMembers) {
+      if (!oldMembers.has(memberName)) {
+        addedMemberNames.push(memberName);
+        changes.push({
+          className,
+          memberName,
+          memberKind: getMemberKind(newMember),
+          changeType: "added",
+          newSignature: formatSignature(newMember)
+        });
+      }
+    }
+    for (const [memberName, oldMember] of oldMembers) {
+      if (!newMembers.has(memberName)) {
+        const suggestion = findSimilarMember(memberName, newMembers, addedMemberNames);
+        changes.push({
+          className,
+          memberName,
+          memberKind: getMemberKind(oldMember),
+          changeType: "removed",
+          oldSignature: formatSignature(oldMember),
+          suggestion
+        });
+      }
+    }
+    for (const [memberName, oldMember] of oldMembers) {
+      const newMember = newMembers.get(memberName);
+      if (newMember && hasSignatureChanged(oldMember, newMember)) {
+        changes.push({
+          className,
+          memberName,
+          memberKind: getMemberKind(newMember),
+          changeType: "signature-changed",
+          oldSignature: formatSignature(oldMember),
+          newSignature: formatSignature(newMember)
+        });
+      }
+    }
+  }
+  return changes;
+}
+function toExportMap(exports) {
+  const map = new Map;
+  for (const exp of exports) {
+    if (exp?.name) {
+      map.set(exp.name, exp);
+    }
+  }
+  return map;
+}
+function toMemberMap(members) {
+  const map = new Map;
+  for (const member of members) {
+    if (member?.name) {
+      map.set(member.name, member);
+    }
+  }
+  return map;
+}
+function getMemberKind(member) {
+  switch (member.kind) {
+    case "method":
+      return "method";
+    case "property":
+      return "property";
+    case "accessor":
+      return "accessor";
+    case "constructor":
+      return "constructor";
+    default:
+      return "method";
+  }
+}
+function formatSignature(member) {
+  if (!member.signatures?.length) {
+    return member.name ?? "";
+  }
+  const sig = member.signatures[0];
+  const params = sig.parameters?.map((p) => {
+    const optional = p.required === false ? "?" : "";
+    return `${p.name}${optional}`;
+  }) ?? [];
+  return `${member.name}(${params.join(", ")})`;
+}
+function hasSignatureChanged(oldMember, newMember) {
+  const oldSigs = oldMember.signatures ?? [];
+  const newSigs = newMember.signatures ?? [];
+  if (oldSigs.length !== newSigs.length) {
+    return true;
+  }
+  for (let i = 0;i < oldSigs.length; i++) {
+    if (!signaturesEqual(oldSigs[i], newSigs[i])) {
+      return true;
+    }
+  }
+  return false;
+}
+function signaturesEqual(a, b) {
+  const aParams = a.parameters ?? [];
+  const bParams = b.parameters ?? [];
+  if (aParams.length !== bParams.length) {
+    return false;
+  }
+  for (let i = 0;i < aParams.length; i++) {
+    const ap = aParams[i];
+    const bp = bParams[i];
+    if (ap.name !== bp.name)
+      return false;
+    if (ap.required !== bp.required)
+      return false;
+    if (JSON.stringify(ap.schema) !== JSON.stringify(bp.schema))
+      return false;
+  }
+  if (JSON.stringify(a.returns) !== JSON.stringify(b.returns)) {
+    return false;
+  }
+  return true;
+}
+function findSimilarMember(removedName, newMembers, addedMembers) {
+  const candidates = addedMembers.length > 0 ? addedMembers : Array.from(newMembers.keys());
+  let bestMatch;
+  let bestScore = 0;
+  for (const name of candidates) {
+    if (name === removedName)
+      continue;
+    const removedWords = splitCamelCase(removedName);
+    const newWords = splitCamelCase(name);
+    let matchingWords = 0;
+    let suffixMatch = false;
+    if (removedWords.length > 0 && newWords.length > 0) {
+      const removedSuffix = removedWords[removedWords.length - 1];
+      const newSuffix = newWords[newWords.length - 1];
+      if (removedSuffix === newSuffix) {
+        suffixMatch = true;
+        matchingWords += 2;
+      }
+    }
+    for (const word of removedWords) {
+      if (newWords.includes(word)) {
+        matchingWords++;
+      }
+    }
+    const wordScore = matchingWords / Math.max(removedWords.length, newWords.length);
+    const editDistance = levenshteinDistance(removedName.toLowerCase(), name.toLowerCase());
+    const maxLen = Math.max(removedName.length, name.length);
+    const levenScore = 1 - editDistance / maxLen;
+    const totalScore = suffixMatch ? wordScore * 1.5 + levenScore : wordScore + levenScore * 0.5;
+    if (totalScore > bestScore && totalScore >= 0.5) {
+      bestScore = totalScore;
+      bestMatch = name;
+    }
+  }
+  return bestMatch ? `Use ${bestMatch} instead` : undefined;
+}
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0;i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0;j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1;i <= b.length; i++) {
+    for (let j = 1;j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function splitCamelCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(" ");
+}
 // src/markdown/diff-with-docs.ts
 import { diffSpec } from "@openpkg-ts/spec";
 function diffSpecWithDocs(oldSpec, newSpec, options = {}) {
   const baseDiff = diffSpec(oldSpec, newSpec);
+  const memberChanges = diffMemberChanges(oldSpec, newSpec, baseDiff.breaking);
   if (!options.markdownFiles?.length) {
-    return baseDiff;
+    return {
+      ...baseDiff,
+      memberChanges: memberChanges.length > 0 ? memberChanges : undefined
+    };
   }
   const newExportNames = newSpec.exports?.map((e) => e.name) ?? [];
-  const docsImpact = analyzeDocsImpact(baseDiff, options.markdownFiles, newExportNames);
+  const docsImpact = analyzeDocsImpact(baseDiff, options.markdownFiles, newExportNames, memberChanges);
   return {
     ...baseDiff,
-    docsImpact
+    docsImpact,
+    memberChanges: memberChanges.length > 0 ? memberChanges : undefined
   };
 }
 function hasDocsImpact(diff) {
@@ -1271,7 +1572,8 @@ function getDocsImpactSummary(diff) {
       impactedFileCount: 0,
       impactedReferenceCount: 0,
       missingDocsCount: 0,
-      totalIssues: 0
+      totalIssues: 0,
+      memberChangesCount: diff.memberChanges?.length ?? 0
     };
   }
   const impactedFileCount = diff.docsImpact.impactedFiles.length;
@@ -1281,7 +1583,8 @@ function getDocsImpactSummary(diff) {
     impactedFileCount,
     impactedReferenceCount,
     missingDocsCount,
-    totalIssues: impactedReferenceCount + missingDocsCount
+    totalIssues: impactedReferenceCount + missingDocsCount,
+    memberChangesCount: diff.memberChanges?.length ?? 0
   };
 }
 // src/analysis/run-analysis.ts
@@ -1299,101 +1602,6 @@ var resolvedTypeScriptModule = (() => {
 })();
 var ts2 = resolvedTypeScriptModule;
 
-// src/analysis/context.ts
-import * as path2 from "node:path";
-
-// src/options.ts
-var DEFAULT_OPTIONS = {
-  includePrivate: false,
-  followImports: true
-};
-function normalizeDocCovOptions(options = {}) {
-  return {
-    ...DEFAULT_OPTIONS,
-    ...options
-  };
-}
-var normalizeOpenPkgOptions = normalizeDocCovOptions;
-
-// src/analysis/program.ts
-import * as path from "node:path";
-var DEFAULT_COMPILER_OPTIONS = {
-  target: ts2.ScriptTarget.Latest,
-  module: ts2.ModuleKind.CommonJS,
-  lib: ["lib.es2021.d.ts"],
-  declaration: true,
-  moduleResolution: ts2.ModuleResolutionKind.NodeJs
-};
-function createProgram({
-  entryFile,
-  baseDir = path.dirname(entryFile),
-  content
-}) {
-  const configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
-  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
-  if (configPath) {
-    const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
-    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.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 = ts2.createCompilerHost(compilerOptions, true);
-  let inMemorySource;
-  if (content !== undefined) {
-    inMemorySource = ts2.createSourceFile(entryFile, content, ts2.ScriptTarget.Latest, true, ts2.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 = ts2.createProgram([entryFile], compilerOptions, compilerHost);
-  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
-  return {
-    program,
-    compilerHost,
-    compilerOptions,
-    sourceFile,
-    configPath
-  };
-}
-
-// src/analysis/context.ts
-function createAnalysisContext({
-  entryFile,
-  packageDir,
-  content,
-  options
-}) {
-  const baseDir = packageDir ?? path2.dirname(entryFile);
-  const normalizedOptions = normalizeOpenPkgOptions(options);
-  const programResult = createProgram({ entryFile, baseDir, content });
-  if (!programResult.sourceFile) {
-    throw new Error(`Could not load ${entryFile}`);
-  }
-  return {
-    entryFile,
-    baseDir,
-    program: programResult.program,
-    checker: programResult.program.getTypeChecker(),
-    sourceFile: programResult.sourceFile,
-    compilerOptions: programResult.compilerOptions,
-    compilerHost: programResult.compilerHost,
-    options: normalizedOptions,
-    configPath: programResult.configPath
-  };
-}
-
-// src/analysis/spec-builder.ts
-import * as fs from "node:fs";
-import * as path3 from "node:path";
-import { SCHEMA_URL } from "@openpkg-ts/spec";
-
 // src/utils/type-utils.ts
 function getTypeId(type, typeChecker) {
   const internalId = type.id;
@@ -1515,6 +1723,30 @@ function collectReferencedTypesFromNode(node, typeChecker, referencedTypes) {
   });
 }
 function isBuiltInType(name) {
+  if (name.length === 1 && /^[A-Z]$/.test(name)) {
+    return true;
+  }
+  if (/^T[A-Z][a-zA-Z]*$/.test(name)) {
+    return true;
+  }
+  const libraryInternals = [
+    "UnionStatic",
+    "IntersectStatic",
+    "ObjectStatic",
+    "ArrayStatic",
+    "StaticDecode",
+    "StaticEncode",
+    "ZodType",
+    "ZodObject",
+    "ZodString",
+    "ZodNumber",
+    "ZodArray",
+    "ZodUnion",
+    "ZodIntersection"
+  ];
+  if (libraryInternals.includes(name)) {
+    return true;
+  }
   const builtIns = [
     "string",
     "number",
@@ -1523,6 +1755,8 @@ function isBuiltInType(name) {
     "symbol",
     "undefined",
     "null",
+    "true",
+    "false",
     "any",
     "unknown",
     "never",
@@ -1566,11 +1800,125 @@ function isBuiltInType(name) {
     "Proxy",
     "Intl",
     "globalThis",
+    "Record",
+    "Partial",
+    "Required",
+    "Readonly",
+    "Pick",
+    "Omit",
+    "Exclude",
+    "Extract",
+    "NonNullable",
+    "ReturnType",
+    "Parameters",
+    "InstanceType",
+    "ConstructorParameters",
+    "Awaited",
+    "ThisType",
+    "Uppercase",
+    "Lowercase",
+    "Capitalize",
+    "Uncapitalize",
     "__type"
   ];
   return builtIns.includes(name);
 }
 
+// src/analysis/context.ts
+import * as path2 from "node:path";
+
+// src/options.ts
+var DEFAULT_OPTIONS = {
+  includePrivate: false,
+  followImports: true
+};
+function normalizeDocCovOptions(options = {}) {
+  return {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+}
+var normalizeOpenPkgOptions = normalizeDocCovOptions;
+
+// src/analysis/program.ts
+import * as path from "node:path";
+var DEFAULT_COMPILER_OPTIONS = {
+  target: ts2.ScriptTarget.Latest,
+  module: ts2.ModuleKind.CommonJS,
+  lib: ["lib.es2021.d.ts"],
+  declaration: true,
+  moduleResolution: ts2.ModuleResolutionKind.NodeJs
+};
+function createProgram({
+  entryFile,
+  baseDir = path.dirname(entryFile),
+  content
+}) {
+  const configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
+  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
+  if (configPath) {
+    const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
+    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.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 = ts2.createCompilerHost(compilerOptions, true);
+  let inMemorySource;
+  if (content !== undefined) {
+    inMemorySource = ts2.createSourceFile(entryFile, content, ts2.ScriptTarget.Latest, true, ts2.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 = ts2.createProgram([entryFile], compilerOptions, compilerHost);
+  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
+  return {
+    program,
+    compilerHost,
+    compilerOptions,
+    sourceFile,
+    configPath
+  };
+}
+
+// src/analysis/context.ts
+function createAnalysisContext({
+  entryFile,
+  packageDir,
+  content,
+  options
+}) {
+  const baseDir = packageDir ?? path2.dirname(entryFile);
+  const normalizedOptions = normalizeOpenPkgOptions(options);
+  const programResult = createProgram({ entryFile, baseDir, content });
+  if (!programResult.sourceFile) {
+    throw new Error(`Could not load ${entryFile}`);
+  }
+  return {
+    entryFile,
+    baseDir,
+    program: programResult.program,
+    checker: programResult.program.getTypeChecker(),
+    sourceFile: programResult.sourceFile,
+    compilerOptions: programResult.compilerOptions,
+    compilerHost: programResult.compilerHost,
+    options: normalizedOptions,
+    configPath: programResult.configPath
+  };
+}
+
+// src/analysis/spec-builder.ts
+import * as fs from "node:fs";
+import * as path3 from "node:path";
+import { SCHEMA_URL } from "@openpkg-ts/spec";
+
 // src/utils/parameter-utils.ts
 var BUILTIN_TYPE_SCHEMAS = {
   Date: { type: "string", format: "date-time" },
@@ -3705,10 +4053,10 @@ function collectDanglingRefs(spec) {
   const referencedTypes = new Set;
   collectAllRefs(spec.exports, referencedTypes);
   collectAllRefs(spec.types, referencedTypes);
-  return Array.from(referencedTypes).filter((ref) => !definedTypes.has(ref));
+  return Array.from(referencedTypes).filter((ref) => !definedTypes.has(ref) && !isBuiltInType(ref));
 }
 function collectExternalTypes(spec) {
-  return (spec.types ?? []).filter((t) => t.kind === "external").map((t) => t.id);
+  return (spec.types ?? []).filter((t) => t.kind === "external").map((t) => t.id).filter((id) => !isBuiltInType(id));
 }
 function hasExternalImports(sourceFile) {
   let found = false;
@@ -4077,7 +4425,7 @@ function generateAssertionFix(drift, exportEntry) {
   const oldValue = oldValueMatch?.[1];
   if (!oldValue)
     return null;
-  const updatedExample = oldExample.replace(new RegExp(`//\\s*=>\\s*${escapeRegex(oldValue)}`, "g"), `// => ${newValue}`);
+  const updatedExample = oldExample.replace(new RegExp(`//\\s*=>\\s*${escapeRegex2(oldValue)}`, "g"), `// => ${newValue}`);
   const updatedExamples = [...examples];
   updatedExamples[exampleIndex] = updatedExample;
   return {
@@ -4195,7 +4543,7 @@ function stringifySchema(schema) {
   }
   return "unknown";
 }
-function escapeRegex(str) {
+function escapeRegex2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function categorizeDrifts(drifts) {

package/package.json

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