@harness-engineering/core 0.26.4 → 0.28.0

package/dist/chunk-BTUDWWB4.mjs

@@ -0,0 +1,1729 @@
+import {
+  Err,
+  Ok,
+  buildDependencyGraph,
+  createEntropyError,
+  detectComplexityViolations,
+  detectCouplingViolations,
+  fileExists,
+  findFiles,
+  getDefaultRegistry,
+  readFileContent,
+  relativePosix
+} from "./chunk-MUWJHO2S.mjs";
+
+// src/entropy/snapshot.ts
+import { skipDirGlobs } from "@harness-engineering/graph";
+import { resolve as resolve2 } from "path";
+import { minimatch } from "minimatch";
+
+// src/entropy/entry-points.ts
+import { join, resolve } from "path";
+function collectFieldEntries(rootDir, field) {
+  if (typeof field === "string") return [resolve(rootDir, field)];
+  if (typeof field === "object" && field !== null) {
+    return Object.values(field).filter((v) => typeof v === "string").map((v) => resolve(rootDir, v));
+  }
+  return [];
+}
+function extractPackageEntries(rootDir, pkg) {
+  const entries = [];
+  entries.push(...collectFieldEntries(rootDir, pkg["exports"]));
+  if (entries.length === 0 && typeof pkg["main"] === "string") {
+    entries.push(resolve(rootDir, pkg["main"]));
+  }
+  if (pkg["bin"]) entries.push(...collectFieldEntries(rootDir, pkg["bin"]));
+  return entries;
+}
+var TS_HINTS = ['Add "exports" or "main" to package.json', "Create src/index.ts"];
+var TS_CONVENTIONS = ["src/index.ts", "src/main.ts", "src/index.tsx", "index.ts", "main.ts"];
+async function readPackageJsonEntries(rootDir, pkgPath) {
+  const content = await readFileContent(pkgPath);
+  if (!content.ok) return [];
+  try {
+    const pkg = JSON.parse(content.value);
+    return extractPackageEntries(rootDir, pkg);
+  } catch {
+    return [];
+  }
+}
+async function resolveTypeScript(rootDir) {
+  const pkgPath = join(rootDir, "package.json");
+  const detected = await fileExists(pkgPath);
+  if (detected) {
+    const entries = await readPackageJsonEntries(rootDir, pkgPath);
+    if (entries.length > 0) {
+      return { language: "typescript", detected: true, entries, hints: TS_HINTS };
+    }
+  }
+  for (const conv of TS_CONVENTIONS) {
+    const p = join(rootDir, conv);
+    if (await fileExists(p)) {
+      return { language: "typescript", detected: true, entries: [p], hints: TS_HINTS };
+    }
+  }
+  return { language: "typescript", detected, entries: [], hints: TS_HINTS };
+}
+var PYTHON_HINTS = [
+  "Add an entry to [project.scripts] in pyproject.toml",
+  "Create main.py or <package>/__main__.py"
+];
+var PYTHON_CONVENTIONS = [
+  "__main__.py",
+  "main.py",
+  "app.py",
+  "src/__main__.py",
+  "src/main.py",
+  "src/app.py"
+];
+async function detectPython(rootDir) {
+  return await fileExists(join(rootDir, "pyproject.toml")) || await fileExists(join(rootDir, "setup.py")) || await fileExists(join(rootDir, "requirements.txt"));
+}
+async function readPyProject(rootDir) {
+  const pyproject = join(rootDir, "pyproject.toml");
+  if (!await fileExists(pyproject)) return { scriptTargets: [] };
+  const content = await readFileContent(pyproject);
+  if (!content.ok) return { scriptTargets: [] };
+  return parsePyProject(content.value);
+}
+async function resolveScriptTargetEntry(rootDir, target) {
+  const mod = target.split(":")[0];
+  if (!mod) return void 0;
+  const relPath = mod.replaceAll(".", "/") + ".py";
+  for (const candidate of [join(rootDir, relPath), join(rootDir, "src", relPath)]) {
+    if (await fileExists(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function resolvePythonFromScripts(rootDir, targets) {
+  const entries = [];
+  for (const target of targets) {
+    const entry = await resolveScriptTargetEntry(rootDir, target);
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+async function resolvePythonFromProjectName(rootDir, projectName) {
+  if (!projectName) return [];
+  const normalized = projectName.replaceAll("-", "_");
+  const candidates = [
+    join(rootDir, normalized, "__init__.py"),
+    join(rootDir, normalized, "__main__.py"),
+    join(rootDir, "src", normalized, "__init__.py"),
+    join(rootDir, "src", normalized, "__main__.py")
+  ];
+  const entries = [];
+  for (const c of candidates) {
+    if (await fileExists(c)) entries.push(c);
+  }
+  return entries;
+}
+async function resolvePythonConventions(rootDir) {
+  const entries = [];
+  for (const conv of PYTHON_CONVENTIONS) {
+    const p = join(rootDir, conv);
+    if (await fileExists(p)) entries.push(p);
+  }
+  return entries;
+}
+async function findPythonTopLevelPackages(rootDir) {
+  const found = await findFiles("*/__init__.py", rootDir);
+  if (found.length > 0) return found;
+  return findFiles("src/*/__init__.py", rootDir);
+}
+async function resolvePython(rootDir) {
+  if (!await detectPython(rootDir)) {
+    return { language: "python", detected: false, entries: [], hints: PYTHON_HINTS };
+  }
+  const info = await readPyProject(rootDir);
+  const strategies = [
+    () => resolvePythonFromScripts(rootDir, info.scriptTargets),
+    () => resolvePythonFromProjectName(rootDir, info.projectName),
+    () => resolvePythonConventions(rootDir),
+    () => findPythonTopLevelPackages(rootDir)
+  ];
+  for (const strategy of strategies) {
+    const entries = await strategy();
+    if (entries.length > 0) {
+      return { language: "python", detected: true, entries, hints: PYTHON_HINTS };
+    }
+  }
+  return { language: "python", detected: true, entries: [], hints: PYTHON_HINTS };
+}
+async function resolveGo(rootDir) {
+  const hints = ["Create main.go at the project root, or use the cmd/<name>/main.go layout"];
+  const detected = await fileExists(join(rootDir, "go.mod"));
+  if (!detected) return { language: "go", detected: false, entries: [], hints };
+  const entries = [];
+  const mainGo = join(rootDir, "main.go");
+  if (await fileExists(mainGo)) entries.push(mainGo);
+  entries.push(...await findFiles("cmd/*/main.go", rootDir));
+  return { language: "go", detected: true, entries, hints };
+}
+async function resolveRust(rootDir) {
+  const hints = [
+    "Create src/main.rs or src/lib.rs",
+    "Declare [[bin]] entries with a `path` in Cargo.toml"
+  ];
+  const cargoPath = join(rootDir, "Cargo.toml");
+  const detected = await fileExists(cargoPath);
+  if (!detected) return { language: "rust", detected: false, entries: [], hints };
+  const entries = [];
+  const content = await readFileContent(cargoPath);
+  if (content.ok) {
+    for (const bp of parseCargoBinPaths(content.value)) {
+      const abs = resolve(rootDir, bp);
+      if (await fileExists(abs)) entries.push(abs);
+    }
+  }
+  if (entries.length === 0) {
+    for (const conv of ["src/main.rs", "src/lib.rs"]) {
+      const p = join(rootDir, conv);
+      if (await fileExists(p)) entries.push(p);
+    }
+    entries.push(...await findFiles("src/bin/*.rs", rootDir));
+  }
+  return { language: "rust", detected: true, entries, hints };
+}
+async function resolveJava(rootDir) {
+  const hints = [
+    "Place an entry class at src/main/java/**/Main.java (or *Application.java for Spring Boot)"
+  ];
+  const detected = await fileExists(join(rootDir, "pom.xml")) || await fileExists(join(rootDir, "build.gradle")) || await fileExists(join(rootDir, "build.gradle.kts"));
+  if (!detected) return { language: "java", detected: false, entries: [], hints };
+  const entries = [];
+  entries.push(...await findFiles("src/main/java/**/Main.java", rootDir));
+  entries.push(...await findFiles("src/main/java/**/*Application.java", rootDir));
+  return { language: "java", detected: true, entries, hints };
+}
+function parseTomlLine(raw) {
+  const line = raw.replace(/(^|\s)#.*$/, "").trim();
+  if (!line) return {};
+  const sectionMatch = /^\[([^\]]+)\]$/.exec(line);
+  if (sectionMatch) return { section: sectionMatch[1] ?? "" };
+  const eq = line.indexOf("=");
+  if (eq <= 0) return {};
+  return {
+    key: line.slice(0, eq).trim(),
+    value: stripTomlString(line.slice(eq + 1).trim())
+  };
+}
+function parsePyProject(content) {
+  const result = { scriptTargets: [] };
+  let section = null;
+  for (const raw of content.split(/\r?\n/)) {
+    const parsed = parseTomlLine(raw);
+    if (parsed.section !== void 0) {
+      section = parsed.section;
+      continue;
+    }
+    if (parsed.key === void 0 || parsed.value === void 0) continue;
+    if (section === "project" && parsed.key === "name") result.projectName = parsed.value;
+    else if (section === "project.scripts") result.scriptTargets.push(parsed.value);
+  }
+  return result;
+}
+function parseCargoBinPaths(content) {
+  const paths = [];
+  let inBin = false;
+  for (const raw of content.split(/\r?\n/)) {
+    const line = raw.replace(/(^|\s)#.*$/, "").trim();
+    if (!line) continue;
+    if (line === "[[bin]]") {
+      inBin = true;
+      continue;
+    }
+    if (line.startsWith("[")) {
+      inBin = false;
+      continue;
+    }
+    if (!inBin) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (key === "path") paths.push(stripTomlString(line.slice(eq + 1).trim()));
+  }
+  return paths;
+}
+function stripTomlString(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+async function resolveEntryPoints(rootDir, explicitEntries) {
+  if (explicitEntries && explicitEntries.length > 0) {
+    return Ok(explicitEntries.map((e) => resolve(rootDir, e)));
+  }
+  const resolvers = [resolveTypeScript, resolvePython, resolveGo, resolveRust, resolveJava];
+  const resolutions = [];
+  for (const resolver of resolvers) {
+    const res = await resolver(rootDir);
+    resolutions.push(res);
+    if (res.entries.length > 0) return Ok(res.entries);
+  }
+  const detectedLangs = resolutions.filter((r) => r.detected);
+  const suggestions = detectedLangs.length > 0 ? detectedLangs.flatMap((r) => r.hints) : resolutions.flatMap((r) => r.hints);
+  suggestions.push("Specify entryPoints in config");
+  const reason = detectedLangs.length > 0 ? `Detected ${detectedLangs.map((r) => r.language).join(", ")} project but found no entry points` : "No language manifest (package.json, pyproject.toml, go.mod, Cargo.toml, pom.xml) and no conventional entry files found";
+  return Err(
+    createEntropyError(
+      "ENTRY_POINT_NOT_FOUND",
+      "Could not resolve entry points",
+      { reason },
+      suggestions
+    )
+  );
+}
+
+// src/entropy/snapshot.ts
+var DEFAULT_INCLUDE_PATTERNS = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.js",
+  "**/*.jsx",
+  "**/*.mjs",
+  "**/*.cjs",
+  "**/*.py",
+  "**/*.go",
+  "**/*.rs",
+  "**/*.java"
+];
+function extractCodeBlocks(content) {
+  const blocks = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && line.startsWith("```")) {
+      const langMatch = line.match(/```(\w*)/);
+      const language = langMatch?.[1] || "text";
+      let codeContent = "";
+      let j = i + 1;
+      let currentLine = lines[j];
+      while (j < lines.length && currentLine !== void 0 && !currentLine.startsWith("```")) {
+        codeContent += currentLine + "\n";
+        j++;
+        currentLine = lines[j];
+      }
+      blocks.push({
+        language,
+        content: codeContent.trim(),
+        line: i + 1
+      });
+      i = j;
+    }
+  }
+  return blocks;
+}
+function extractInlineRefs(content) {
+  const refs = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const regex = /`([^`]+)`/g;
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      const reference = match[1];
+      if (reference === void 0) continue;
+      if (reference.match(/^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*(\(.*\))?$/)) {
+        refs.push({
+          reference: reference.replace(/\(.*\)$/, ""),
+          // Remove function parens
+          line: i + 1,
+          column: match.index
+        });
+      }
+    }
+  }
+  return refs;
+}
+async function parseDocumentationFile(path) {
+  const contentResult = await readFileContent(path);
+  if (!contentResult.ok) {
+    return Err(
+      createEntropyError(
+        "PARSE_ERROR",
+        `Failed to read documentation file: ${path}`,
+        { file: path },
+        ["Check that the file exists"]
+      )
+    );
+  }
+  const content = contentResult.value;
+  const type = path.endsWith(".md") ? "markdown" : "text";
+  return Ok({
+    path,
+    type,
+    content,
+    codeBlocks: extractCodeBlocks(content),
+    inlineRefs: extractInlineRefs(content)
+  });
+}
+function makeInternalSymbol(name, type, line) {
+  return { name, type, line, references: 0, calledBy: [] };
+}
+function extractFunctionSymbol(node, line) {
+  if (node.id?.name) return [makeInternalSymbol(node.id.name, "function", line)];
+  return [];
+}
+function extractVariableSymbols(node, line) {
+  return (node.declarations || []).filter((decl) => decl.id?.name).map((decl) => makeInternalSymbol(decl.id.name, "variable", line));
+}
+function extractClassSymbol(node, line) {
+  if (node.id?.name) return [makeInternalSymbol(node.id.name, "class", line)];
+  return [];
+}
+function extractSymbolsFromNode(node) {
+  const line = node.loc?.start?.line || 0;
+  if (node.type === "FunctionDeclaration") return extractFunctionSymbol(node, line);
+  if (node.type === "VariableDeclaration") return extractVariableSymbols(node, line);
+  if (node.type === "ClassDeclaration") return extractClassSymbol(node, line);
+  return [];
+}
+function extractInternalSymbols(ast) {
+  if (ast.language !== "typescript" && ast.language !== "javascript") return [];
+  const body = ast.body;
+  if (!body?.body) return [];
+  const nodes = body.body;
+  return nodes.flatMap(extractSymbolsFromNode);
+}
+function toJSDocComment(comment) {
+  if (comment.type !== "Block" || !comment.value?.startsWith("*")) return null;
+  return { content: comment.value, line: comment.loc?.start?.line || 0 };
+}
+function extractJSDocComments(ast) {
+  if (ast.language !== "typescript" && ast.language !== "javascript") return [];
+  const body = ast.body;
+  if (!body?.comments) return [];
+  return body.comments.flatMap((c) => {
+    const doc = toJSDocComment(c);
+    return doc ? [doc] : [];
+  });
+}
+function buildExportMap(files) {
+  const byFile = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    byFile.set(file.path, file.exports);
+    for (const exp of file.exports) {
+      const existing = byName.get(exp.name) || [];
+      existing.push({ file: file.path, export: exp });
+      byName.set(exp.name, existing);
+    }
+  }
+  return { byFile, byName };
+}
+var CODE_BLOCK_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "ts", "javascript", "js"]);
+function refsFromInlineRefs(doc) {
+  return doc.inlineRefs.map((inlineRef) => ({
+    docFile: doc.path,
+    line: inlineRef.line,
+    column: inlineRef.column,
+    reference: inlineRef.reference,
+    context: "inline"
+  }));
+}
+function refsFromCodeBlock(docPath, block) {
+  if (!CODE_BLOCK_LANGUAGES.has(block.language)) return [];
+  const refs = [];
+  const importRegex = /import\s+\{([^}]+)\}\s+from/g;
+  let match;
+  while ((match = importRegex.exec(block.content)) !== null) {
+    const group = match[1];
+    if (group === void 0) continue;
+    for (const name of group.split(",").map((n) => n.trim())) {
+      refs.push({
+        docFile: docPath,
+        line: block.line,
+        column: 0,
+        reference: name,
+        context: "code-block"
+      });
+    }
+  }
+  return refs;
+}
+function refsFromCodeBlocks(doc) {
+  return doc.codeBlocks.flatMap((block) => refsFromCodeBlock(doc.path, block));
+}
+function extractAllCodeReferences(docs) {
+  return docs.flatMap((doc) => [...refsFromInlineRefs(doc), ...refsFromCodeBlocks(doc)]);
+}
+async function buildSnapshot(config) {
+  const startTime = Date.now();
+  const rootDir = resolve2(config.rootDir);
+  const entryPointsResult = await resolveEntryPoints(rootDir, config.entryPoints);
+  if (!entryPointsResult.ok) {
+    return Err(entryPointsResult.error);
+  }
+  const registry = getDefaultRegistry();
+  const singleParser = config.parser;
+  const parserForFile = (filePath) => singleParser ?? registry.getForFile(filePath);
+  const includePatterns = config.include || DEFAULT_INCLUDE_PATTERNS;
+  const excludePatterns = config.exclude || [...skipDirGlobs(), "**/*.test.ts", "**/*.spec.ts"];
+  let sourceFilePaths = [];
+  for (const pattern of includePatterns) {
+    const files2 = await findFiles(pattern, rootDir);
+    sourceFilePaths.push(...files2);
+  }
+  sourceFilePaths = sourceFilePaths.filter((f) => {
+    const rel = relativePosix(rootDir, f);
+    return !excludePatterns.some((p) => minimatch(rel, p));
+  });
+  const files = [];
+  for (const filePath of sourceFilePaths) {
+    const fileParser = parserForFile(filePath);
+    if (!fileParser) continue;
+    const parseResult = await fileParser.parseFile(filePath);
+    if (!parseResult.ok) continue;
+    const importsResult = fileParser.extractImports(parseResult.value);
+    const exportsResult = fileParser.extractExports(parseResult.value);
+    const internalSymbols = extractInternalSymbols(parseResult.value);
+    const jsDocComments = extractJSDocComments(parseResult.value);
+    files.push({
+      path: filePath,
+      ast: parseResult.value,
+      imports: importsResult.ok ? importsResult.value : [],
+      exports: exportsResult.ok ? exportsResult.value : [],
+      internalSymbols,
+      jsDocComments
+    });
+  }
+  const graphResult = await buildDependencyGraph(sourceFilePaths, singleParser ?? registry);
+  const dependencyGraph = graphResult.ok ? graphResult.value : { nodes: [], edges: [] };
+  const docPatterns = config.docPaths || ["docs/**/*.md", "README.md", "**/README.md"];
+  let docFilePaths = [];
+  for (const pattern of docPatterns) {
+    const docFiles = await findFiles(pattern, rootDir);
+    docFilePaths.push(...docFiles);
+  }
+  docFilePaths = [...new Set(docFilePaths)];
+  const docs = [];
+  for (const docPath of docFilePaths) {
+    const docResult = await parseDocumentationFile(docPath);
+    if (docResult.ok) {
+      docs.push(docResult.value);
+    }
+  }
+  const exportMap = buildExportMap(files);
+  const codeReferences = extractAllCodeReferences(docs);
+  const buildTime = Date.now() - startTime;
+  return Ok({
+    files,
+    dependencyGraph,
+    exportMap,
+    docs,
+    codeReferences,
+    entryPoints: entryPointsResult.value,
+    rootDir,
+    config,
+    buildTime
+  });
+}
+
+// src/entropy/detectors/drift.ts
+import { dirname, resolve as resolve3 } from "path";
+function initLevenshteinMatrix(aLen, bLen) {
+  const matrix = [];
+  for (let i = 0; i <= bLen; i++) {
+    matrix[i] = [i];
+  }
+  const firstRow = matrix[0];
+  if (firstRow) {
+    for (let j = 0; j <= aLen; j++) {
+      firstRow[j] = j;
+    }
+  }
+  return matrix;
+}
+function computeLevenshteinCell(row, prevRow, j, charsMatch) {
+  if (charsMatch) {
+    row[j] = prevRow[j - 1] ?? 0;
+  } else {
+    row[j] = Math.min((prevRow[j - 1] ?? 0) + 1, (row[j - 1] ?? 0) + 1, (prevRow[j] ?? 0) + 1);
+  }
+}
+function levenshteinDistance(a, b) {
+  const matrix = initLevenshteinMatrix(a.length, b.length);
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      const row = matrix[i];
+      const prevRow = matrix[i - 1];
+      if (!row || !prevRow) continue;
+      computeLevenshteinCell(row, prevRow, j, b.charAt(i - 1) === a.charAt(j - 1));
+    }
+  }
+  const lastRow = matrix[b.length];
+  return lastRow?.[a.length] ?? 0;
+}
+function findPossibleMatches(reference, exportNames, maxDistance = 5) {
+  const matches = [];
+  const refLower = reference.toLowerCase();
+  for (const name of exportNames) {
+    const nameLower = name.toLowerCase();
+    if (nameLower === refLower) {
+      matches.push({ name, score: 0 });
+      continue;
+    }
+    if (nameLower.includes(refLower) || refLower.includes(nameLower)) {
+      matches.push({ name, score: 1 });
+      continue;
+    }
+    const distance = levenshteinDistance(refLower, nameLower);
+    if (distance <= maxDistance) {
+      matches.push({ name, score: distance });
+    }
+  }
+  return matches.sort((a, b) => a.score - b.score).slice(0, 3).map((m) => m.name);
+}
+var DEFAULT_DRIFT_CONFIG = {
+  docPaths: [],
+  checkApiSignatures: true,
+  checkExamples: true,
+  checkStructure: true,
+  ignorePatterns: []
+};
+function checkApiSignatureDrift(snapshot, config) {
+  const drifts = [];
+  const exportNames = Array.from(snapshot.exportMap.byName.keys());
+  for (const ref of snapshot.codeReferences) {
+    if (config.ignorePatterns.some((p) => ref.reference.match(new RegExp(p)))) {
+      continue;
+    }
+    if (!snapshot.exportMap.byName.has(ref.reference)) {
+      const possibleMatches = findPossibleMatches(ref.reference, exportNames);
+      const confidence = possibleMatches.length > 0 ? "high" : "medium";
+      const drift = {
+        type: "api-signature",
+        docFile: ref.docFile,
+        line: ref.line,
+        reference: ref.reference,
+        context: ref.context,
+        issue: possibleMatches.length > 0 ? "RENAMED" : "NOT_FOUND",
+        details: possibleMatches.length > 0 ? `Symbol "${ref.reference}" not found. Similar: ${possibleMatches.join(", ")}` : `Symbol "${ref.reference}" not found in codebase`,
+        suggestion: possibleMatches.length > 0 ? `Did you mean "${possibleMatches[0]}"?` : "Remove reference or add the missing export",
+        confidence
+      };
+      if (possibleMatches.length > 0) {
+        drift.possibleMatches = possibleMatches;
+      }
+      drifts.push(drift);
+    }
+  }
+  return drifts;
+}
+function extractFileLinks(content) {
+  const links = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const linkRegex = /\[([^\]]*)\]\(([^)]+)\)/g;
+    let match;
+    while ((match = linkRegex.exec(line)) !== null) {
+      const linkPath = match[2];
+      if (linkPath && !linkPath.startsWith("http") && !linkPath.startsWith("#") && (linkPath.includes(".") || linkPath.startsWith(".."))) {
+        links.push({ link: linkPath, line: i + 1 });
+      }
+    }
+  }
+  return links;
+}
+async function checkStructureDrift(snapshot, _config) {
+  const drifts = [];
+  for (const doc of snapshot.docs) {
+    const fileLinks = extractFileLinks(doc.content);
+    for (const { link, line } of fileLinks) {
+      const resolvedPath = resolve3(dirname(doc.path), link);
+      const exists = await fileExists(resolvedPath);
+      if (!exists) {
+        drifts.push({
+          type: "structure",
+          docFile: doc.path,
+          line,
+          reference: link,
+          context: "link",
+          issue: "NOT_FOUND",
+          details: `File "${link}" referenced in documentation does not exist`,
+          suggestion: "Update the link or remove the reference",
+          confidence: "high"
+        });
+      }
+    }
+  }
+  return drifts;
+}
+function computeDriftSeverity(driftCount) {
+  if (driftCount === 0) return "none";
+  if (driftCount <= 3) return "low";
+  if (driftCount <= 10) return "medium";
+  return "high";
+}
+function buildGraphDriftReport(graphDriftData) {
+  const drifts = [];
+  for (const target of graphDriftData.missingTargets) {
+    drifts.push({
+      type: "api-signature",
+      docFile: target,
+      line: 0,
+      reference: target,
+      context: "graph-missing-target",
+      issue: "NOT_FOUND",
+      details: `Graph node "${target}" has no matching code target`,
+      confidence: "high"
+    });
+  }
+  for (const edge of graphDriftData.staleEdges) {
+    drifts.push({
+      type: "api-signature",
+      docFile: edge.docNodeId,
+      line: 0,
+      reference: edge.codeNodeId,
+      context: `graph-stale-edge:${edge.edgeType}`,
+      issue: "NOT_FOUND",
+      details: `Stale edge from doc "${edge.docNodeId}" to code "${edge.codeNodeId}" (${edge.edgeType})`,
+      confidence: "medium"
+    });
+  }
+  return Ok({
+    drifts,
+    stats: {
+      docsScanned: graphDriftData.staleEdges.length,
+      referencesChecked: graphDriftData.staleEdges.length + graphDriftData.missingTargets.length,
+      driftsFound: drifts.length,
+      byType: { api: drifts.length, example: 0, structure: 0 }
+    },
+    severity: computeDriftSeverity(drifts.length)
+  });
+}
+async function detectDocDrift(snapshot, config, graphDriftData) {
+  if (graphDriftData) {
+    return buildGraphDriftReport(graphDriftData);
+  }
+  const fullConfig = { ...DEFAULT_DRIFT_CONFIG, ...config };
+  const drifts = [];
+  if (fullConfig.checkApiSignatures) {
+    drifts.push(...checkApiSignatureDrift(snapshot, fullConfig));
+  }
+  if (fullConfig.checkStructure) {
+    drifts.push(...await checkStructureDrift(snapshot, fullConfig));
+  }
+  const apiDrifts = drifts.filter((d) => d.type === "api-signature").length;
+  const exampleDrifts = drifts.filter((d) => d.type === "example-code").length;
+  const structureDrifts = drifts.filter((d) => d.type === "structure").length;
+  const severity = drifts.length === 0 ? "none" : drifts.length <= 3 ? "low" : drifts.length <= 10 ? "medium" : "high";
+  return Ok({
+    drifts,
+    stats: {
+      docsScanned: snapshot.docs.length,
+      referencesChecked: snapshot.codeReferences.length,
+      driftsFound: drifts.length,
+      byType: { api: apiDrifts, example: exampleDrifts, structure: structureDrifts }
+    },
+    severity
+  });
+}
+
+// src/entropy/detectors/dead-code.ts
+import { dirname as dirname2, extname, resolve as resolve4 } from "path";
+var JS_EXT_FALLBACKS = {
+  ".js": [".ts", ".tsx", ".jsx"],
+  ".jsx": [".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"]
+};
+function buildFileIndex(snapshot) {
+  const index = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    index.set(file.path, file);
+  }
+  return index;
+}
+function resolveImportToFile(importSource, fromFile, snapshot, fileIndex) {
+  if (!importSource.startsWith(".")) {
+    return null;
+  }
+  const hasFile = fileIndex ? (p) => fileIndex.has(p) : (p) => snapshot.files.some((f) => f.path === p);
+  const fromDir = dirname2(fromFile);
+  const resolved = resolve4(fromDir, importSource);
+  const sourceExt = extname(resolved);
+  const fallbacks = JS_EXT_FALLBACKS[sourceExt];
+  if (fallbacks) {
+    const base = resolved.slice(0, -sourceExt.length);
+    for (const ext of fallbacks) {
+      const candidate = base + ext;
+      if (hasFile(candidate)) return candidate;
+    }
+    for (const indexExt of [".ts", ".tsx", ".jsx"]) {
+      const indexPath = resolve4(base, "index" + indexExt);
+      if (hasFile(indexPath)) return indexPath;
+    }
+  }
+  if (hasFile(resolved)) return resolved;
+  if (!sourceExt) {
+    for (const ext of [".ts", ".tsx"]) {
+      const candidate = resolved + ext;
+      if (hasFile(candidate)) return candidate;
+    }
+    for (const indexExt of [".ts", ".tsx"]) {
+      const indexPath = resolve4(resolved, "index" + indexExt);
+      if (hasFile(indexPath)) return indexPath;
+    }
+  }
+  return null;
+}
+function enqueueResolved(sources, current, snapshot, visited, queue, fileIndex) {
+  for (const item of sources) {
+    if (!item.source) continue;
+    const resolved = resolveImportToFile(item.source, current, snapshot, fileIndex);
+    if (resolved && !visited.has(resolved)) {
+      queue.push(resolved);
+    }
+  }
+}
+function processReachabilityNode(current, snapshot, reachability, visited, queue, fileIndex) {
+  reachability.set(current, true);
+  const sourceFile = fileIndex ? fileIndex.get(current) : snapshot.files.find((f) => f.path === current);
+  if (!sourceFile) return;
+  enqueueResolved(sourceFile.imports, current, snapshot, visited, queue, fileIndex);
+  const reExports = sourceFile.exports.filter((e) => e.isReExport);
+  enqueueResolved(reExports, current, snapshot, visited, queue, fileIndex);
+}
+function buildReachabilityMap(snapshot) {
+  const fileIndex = buildFileIndex(snapshot);
+  const reachability = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    reachability.set(file.path, false);
+  }
+  const queue = [...snapshot.entryPoints];
+  const visited = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) continue;
+    visited.add(current);
+    processReachabilityNode(current, snapshot, reachability, visited, queue, fileIndex);
+  }
+  return reachability;
+}
+function buildExportUsageMap(snapshot) {
+  const fileIndex = buildFileIndex(snapshot);
+  const usageMap = /* @__PURE__ */ new Map();
+  for (const file of snapshot.files) {
+    for (const exp of file.exports) {
+      const key = `${file.path}:${exp.name}`;
+      usageMap.set(key, { importers: [], isReExported: exp.isReExport });
+    }
+  }
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const resolvedFile = resolveImportToFile(imp.source, file.path, snapshot, fileIndex);
+      if (!resolvedFile) continue;
+      const sourceFile = fileIndex.get(resolvedFile);
+      if (!sourceFile) continue;
+      for (const specifier of imp.specifiers) {
+        const matchingExport = sourceFile.exports.find(
+          (e) => e.name === specifier || specifier === "default" && e.type === "default"
+        );
+        if (matchingExport) {
+          const key = `${resolvedFile}:${matchingExport.name}`;
+          const usage = usageMap.get(key);
+          if (usage) {
+            usage.importers.push(file.path);
+          }
+        }
+      }
+    }
+  }
+  return usageMap;
+}
+function findDeadExports(snapshot, usageMap, reachability) {
+  const deadExports = [];
+  for (const file of snapshot.files) {
+    if (snapshot.entryPoints.includes(file.path)) continue;
+    for (const exp of file.exports) {
+      if (exp.isReExport) continue;
+      const key = `${file.path}:${exp.name}`;
+      const usage = usageMap.get(key);
+      if (!usage || usage.importers.length === 0) {
+        deadExports.push({
+          file: file.path,
+          name: exp.name,
+          line: exp.location.line,
+          type: "variable",
+          // Default type since Export doesn't track declaration kind
+          isDefault: exp.type === "default",
+          reason: "NO_IMPORTERS"
+        });
+      } else {
+        const allImportersDead = usage.importers.every((importer) => !reachability.get(importer));
+        if (allImportersDead) {
+          deadExports.push({
+            file: file.path,
+            name: exp.name,
+            line: exp.location.line,
+            type: "variable",
+            // Default type since Export doesn't track declaration kind
+            isDefault: exp.type === "default",
+            reason: "IMPORTERS_ALSO_DEAD"
+          });
+        }
+      }
+    }
+  }
+  return deadExports;
+}
+function maxLineOfValue(value) {
+  if (Array.isArray(value)) {
+    return value.reduce((m, item) => Math.max(m, findMaxLineInNode(item)), 0);
+  }
+  if (value && typeof value === "object") {
+    return findMaxLineInNode(value);
+  }
+  return 0;
+}
+function maxLineOfNodeKeys(node) {
+  let max = 0;
+  for (const key of Object.keys(node)) {
+    max = Math.max(max, maxLineOfValue(node[key]));
+  }
+  return max;
+}
+function findMaxLineInNode(node) {
+  if (!node || typeof node !== "object") return 0;
+  const n = node;
+  const locLine = n.loc?.end?.line ?? 0;
+  return Math.max(locLine, maxLineOfNodeKeys(node));
+}
+function countLinesFromAST(ast) {
+  if (!ast.body || !Array.isArray(ast.body)) return 1;
+  const maxLine = findMaxLineInNode(ast);
+  if (maxLine > 0) return maxLine;
+  return Math.max(ast.body.length * 3, 1);
+}
+function findDeadFiles(snapshot, reachability) {
+  const deadFiles = [];
+  for (const file of snapshot.files) {
+    const isReachable = reachability.get(file.path) ?? false;
+    if (!isReachable) {
+      deadFiles.push({
+        path: file.path,
+        reason: "NO_IMPORTERS",
+        exportCount: file.exports.filter((e) => !e.isReExport).length,
+        lineCount: countLinesFromAST(file.ast)
+      });
+    }
+  }
+  return deadFiles;
+}
+function isIdentifierUsedInAST(ast, identifier, skipImportDeclaration = true) {
+  const astString = JSON.stringify(
+    ast,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  );
+  const identifierPattern = new RegExp(`"name"\\s*:\\s*"${identifier}"`, "g");
+  const matches = astString.match(identifierPattern);
+  if (!matches) return false;
+  if (skipImportDeclaration) {
+    return matches.length > 2;
+  }
+  return matches.length > 0;
+}
+function findUnusedImports(snapshot) {
+  const unusedImports = [];
+  for (const file of snapshot.files) {
+    for (const imp of file.imports) {
+      const unusedSpecifiers = [];
+      for (const specifier of imp.specifiers) {
+        if (!isIdentifierUsedInAST(file.ast, specifier, true)) {
+          unusedSpecifiers.push(specifier);
+        }
+      }
+      if (unusedSpecifiers.length > 0) {
+        unusedImports.push({
+          file: file.path,
+          line: imp.location.line,
+          source: imp.source,
+          specifiers: unusedSpecifiers,
+          isFullyUnused: unusedSpecifiers.length === imp.specifiers.length
+        });
+      }
+    }
+  }
+  return unusedImports;
+}
+function findDeadInternals(snapshot, _reachability) {
+  const deadInternals = [];
+  for (const file of snapshot.files) {
+    for (const symbol of file.internalSymbols) {
+      if (symbol.type === "type") continue;
+      if (symbol.references === 0 && symbol.calledBy.length === 0) {
+        deadInternals.push({
+          file: file.path,
+          name: symbol.name,
+          line: symbol.line,
+          type: symbol.type,
+          reason: "NEVER_CALLED"
+        });
+      }
+    }
+  }
+  return deadInternals;
+}
+var FILE_TYPES = /* @__PURE__ */ new Set(["file", "module"]);
+var EXPORT_TYPES = /* @__PURE__ */ new Set(["function", "class", "method", "interface", "variable"]);
+function classifyUnreachableNode(node, deadFiles, deadExports) {
+  if (FILE_TYPES.has(node.type)) {
+    deadFiles.push({
+      path: node.path || node.id,
+      reason: "NO_IMPORTERS",
+      exportCount: 0,
+      lineCount: 0
+    });
+  } else if (EXPORT_TYPES.has(node.type)) {
+    const exportType = node.type === "method" ? "function" : node.type;
+    deadExports.push({
+      file: node.path || node.id,
+      name: node.name,
+      line: 0,
+      type: exportType,
+      isDefault: false,
+      reason: "NO_IMPORTERS"
+    });
+  }
+}
+function computeGraphReportStats(data, deadFiles, deadExports) {
+  const reachableCount = data.reachableNodeIds instanceof Set ? data.reachableNodeIds.size : data.reachableNodeIds.length;
+  const fileNodes = data.unreachableNodes.filter((n) => FILE_TYPES.has(n.type));
+  const exportNodes = data.unreachableNodes.filter((n) => EXPORT_TYPES.has(n.type));
+  const totalFiles = reachableCount + fileNodes.length;
+  const totalExports = exportNodes.length + (reachableCount > 0 ? reachableCount : 0);
+  return {
+    filesAnalyzed: totalFiles,
+    entryPointsUsed: [],
+    totalExports,
+    deadExportCount: deadExports.length,
+    totalFiles,
+    deadFileCount: deadFiles.length,
+    estimatedDeadLines: 0
+  };
+}
+function buildReportFromGraph(data) {
+  const deadFiles = [];
+  const deadExports = [];
+  for (const node of data.unreachableNodes) {
+    classifyUnreachableNode(node, deadFiles, deadExports);
+  }
+  return {
+    deadExports,
+    deadFiles,
+    deadInternals: [],
+    unusedImports: [],
+    stats: computeGraphReportStats(data, deadFiles, deadExports)
+  };
+}
+function buildReportFromSnapshot(snapshot) {
+  const reachability = buildReachabilityMap(snapshot);
+  const usageMap = buildExportUsageMap(snapshot);
+  const deadExports = findDeadExports(snapshot, usageMap, reachability);
+  const deadFiles = findDeadFiles(snapshot, reachability);
+  const unusedImports = findUnusedImports(snapshot);
+  const deadInternals = findDeadInternals(snapshot, reachability);
+  const totalExports = snapshot.files.reduce(
+    (acc, file) => acc + file.exports.filter((e) => !e.isReExport).length,
+    0
+  );
+  const estimatedDeadLines = deadFiles.reduce((acc, file) => acc + file.lineCount, 0);
+  return {
+    deadExports,
+    deadFiles,
+    deadInternals,
+    unusedImports,
+    stats: {
+      filesAnalyzed: snapshot.files.length,
+      entryPointsUsed: snapshot.entryPoints,
+      totalExports,
+      deadExportCount: deadExports.length,
+      totalFiles: snapshot.files.length,
+      deadFileCount: deadFiles.length,
+      estimatedDeadLines
+    }
+  };
+}
+function filterProtectedFindings(report, regions) {
+  const deadExports = report.deadExports.filter(
+    (e) => !regions.isProtected(e.file, e.line, "entropy")
+  );
+  const deadFiles = report.deadFiles.filter((f) => regions.getRegions(f.path).length === 0);
+  const unusedImports = report.unusedImports.filter(
+    (i) => !regions.isProtected(i.file, i.line, "entropy")
+  );
+  const deadInternals = report.deadInternals.filter(
+    (i) => !regions.isProtected(i.file, i.line, "entropy")
+  );
+  const estimatedDeadLines = deadFiles.reduce((acc, f) => acc + f.lineCount, 0);
+  return {
+    deadExports,
+    deadFiles,
+    unusedImports,
+    deadInternals,
+    stats: {
+      ...report.stats,
+      deadExportCount: deadExports.length,
+      deadFileCount: deadFiles.length,
+      estimatedDeadLines
+    }
+  };
+}
+async function detectDeadCode(snapshot, graphDeadCodeData, protectedRegions) {
+  let report = graphDeadCodeData ? buildReportFromGraph(graphDeadCodeData) : buildReportFromSnapshot(snapshot);
+  if (protectedRegions) {
+    report = filterProtectedFindings(report, protectedRegions);
+  }
+  return Ok(report);
+}
+
+// src/entropy/detectors/patterns.ts
+import { minimatch as minimatch2 } from "minimatch";
+function fileMatchesPattern(filePath, pattern, rootDir) {
+  const relativePath = relativePosix(rootDir, filePath);
+  return minimatch2(relativePath, pattern);
+}
+var CONVENTION_DESCRIPTIONS = {
+  camelCase: "camelCase (e.g., myFunction)",
+  PascalCase: "PascalCase (e.g., MyClass)",
+  UPPER_SNAKE: "UPPER_SNAKE_CASE (e.g., MY_CONSTANT)",
+  "kebab-case": "kebab-case (e.g., my-component)"
+};
+function checkMustExport(rule, file, message) {
+  if (rule.type !== "must-export") return [];
+  const matches = [];
+  for (const name of rule.names) {
+    if (!file.exports.some((e) => e.name === name)) {
+      matches.push({
+        line: 1,
+        message: message || `Missing required export: "${name}"`,
+        suggestion: `Add export for "${name}"`
+      });
+    }
+  }
+  return matches;
+}
+function checkMustExportDefault(_rule, file, message) {
+  if (!file.exports.some((e) => e.type === "default")) {
+    return [
+      {
+        line: 1,
+        message: message || "File must have a default export",
+        suggestion: "Add a default export"
+      }
+    ];
+  }
+  return [];
+}
+function checkNoExport(rule, file, message) {
+  if (rule.type !== "no-export") return [];
+  const matches = [];
+  for (const name of rule.names) {
+    const exp = file.exports.find((e) => e.name === name);
+    if (exp) {
+      matches.push({
+        line: exp.location.line,
+        message: message || `Forbidden export: "${name}"`,
+        suggestion: `Remove export "${name}"`
+      });
+    }
+  }
+  return matches;
+}
+function checkMustImport(rule, file, message) {
+  if (rule.type !== "must-import") return [];
+  const hasImport = file.imports.some(
+    (i) => i.source === rule.from || i.source.endsWith(rule.from)
+  );
+  if (!hasImport) {
+    return [
+      {
+        line: 1,
+        message: message || `Missing required import from "${rule.from}"`,
+        suggestion: `Add import from "${rule.from}"`
+      }
+    ];
+  }
+  return [];
+}
+function checkNoImport(rule, file, message) {
+  if (rule.type !== "no-import") return [];
+  const forbiddenImport = file.imports.find(
+    (i) => i.source === rule.from || i.source.endsWith(rule.from)
+  );
+  if (forbiddenImport) {
+    return [
+      {
+        line: forbiddenImport.location.line,
+        message: message || `Forbidden import from "${rule.from}"`,
+        suggestion: `Remove import from "${rule.from}"`
+      }
+    ];
+  }
+  return [];
+}
+function checkNaming(rule, file, message) {
+  if (rule.type !== "naming") return [];
+  const regex = new RegExp(rule.match);
+  const matches = [];
+  for (const exp of file.exports) {
+    if (!regex.test(exp.name)) {
+      const expected = CONVENTION_DESCRIPTIONS[rule.convention] ?? rule.convention;
+      matches.push({
+        line: exp.location.line,
+        message: message || `"${exp.name}" does not follow ${rule.convention} convention`,
+        suggestion: `Rename to follow ${expected}`
+      });
+    }
+  }
+  return matches;
+}
+function checkMaxExports(rule, file, message) {
+  if (rule.type !== "max-exports") return [];
+  if (file.exports.length > rule.count) {
+    return [
+      {
+        line: 1,
+        message: message || `File has ${file.exports.length} exports, max is ${rule.count}`,
+        suggestion: `Split into multiple files or reduce exports to ${rule.count}`
+      }
+    ];
+  }
+  return [];
+}
+function checkMaxLines(_rule, _file, _message) {
+  return [];
+}
+function checkRequireJsdoc(_rule, file, message) {
+  if (file.jsDocComments.length === 0 && file.exports.length > 0) {
+    return [
+      {
+        line: 1,
+        message: message || "Exported symbols require JSDoc documentation",
+        suggestion: "Add JSDoc comments to exports"
+      }
+    ];
+  }
+  return [];
+}
+var RULE_CHECKERS = {
+  "must-export": checkMustExport,
+  "must-export-default": checkMustExportDefault,
+  "no-export": checkNoExport,
+  "must-import": checkMustImport,
+  "no-import": checkNoImport,
+  naming: checkNaming,
+  "max-exports": checkMaxExports,
+  "max-lines": checkMaxLines,
+  "require-jsdoc": checkRequireJsdoc
+};
+function checkConfigPattern(pattern, file, rootDir) {
+  const fileMatches = pattern.files.some((glob) => fileMatchesPattern(file.path, glob, rootDir));
+  if (!fileMatches) return [];
+  const checker = RULE_CHECKERS[pattern.rule.type];
+  if (!checker) return [];
+  return checker(pattern.rule, file, pattern.message);
+}
+async function detectPatternViolations(snapshot, config) {
+  const violations = [];
+  const patterns = config?.patterns || [];
+  for (const file of snapshot.files) {
+    for (const pattern of patterns) {
+      const matches = checkConfigPattern(pattern, file, snapshot.rootDir);
+      for (const match of matches) {
+        violations.push({
+          pattern: pattern.name,
+          file: file.path,
+          line: match.line,
+          message: match.message,
+          suggestion: match.suggestion || "Review and fix this pattern violation",
+          severity: pattern.severity
+        });
+      }
+    }
+  }
+  if (config?.customPatterns) {
+    for (const file of snapshot.files) {
+      for (const custom of config.customPatterns) {
+        const matches = custom.check(file, snapshot);
+        for (const match of matches) {
+          violations.push({
+            pattern: custom.name,
+            file: file.path,
+            line: match.line,
+            message: match.message,
+            suggestion: match.suggestion || "Review and fix this pattern violation",
+            severity: custom.severity
+          });
+        }
+      }
+    }
+  }
+  const errorCount = violations.filter((v) => v.severity === "error").length;
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const customCount = config?.customPatterns?.length ?? 0;
+  const allPatternsCount = patterns.length + customCount;
+  const totalChecks = snapshot.files.length * allPatternsCount;
+  const passRate = totalChecks > 0 ? Math.max(0, (totalChecks - violations.length) / totalChecks) : 1;
+  return Ok({
+    violations,
+    stats: {
+      filesChecked: snapshot.files.length,
+      patternsApplied: allPatternsCount,
+      violationCount: violations.length,
+      errorCount,
+      warningCount
+    },
+    passRate
+  });
+}
+
+// src/entropy/detectors/size-budget.ts
+import { readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+import { DEFAULT_SKIP_DIRS } from "@harness-engineering/graph";
+function parseSize(size) {
+  const match = size.trim().match(/^(\d+(?:\.\d+)?)\s*(KB|MB|GB|B)?$/i);
+  if (!match) return 0;
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || "B").toUpperCase();
+  switch (unit) {
+    case "KB":
+      return Math.round(value * 1024);
+    case "MB":
+      return Math.round(value * 1024 * 1024);
+    case "GB":
+      return Math.round(value * 1024 * 1024 * 1024);
+    default:
+      return Math.round(value);
+  }
+}
+function dirSize(dirPath) {
+  let total = 0;
+  let entries;
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    if (DEFAULT_SKIP_DIRS.has(entry)) continue;
+    const fullPath = join2(dirPath, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        total += dirSize(fullPath);
+      } else if (stat.isFile()) {
+        total += stat.size;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return total;
+}
+async function detectSizeBudgetViolations(rootDir, config) {
+  const budgets = config?.budgets ?? {};
+  const violations = [];
+  let packagesChecked = 0;
+  for (const [pkgPath, budget] of Object.entries(budgets)) {
+    packagesChecked++;
+    const distPath = join2(rootDir, pkgPath, "dist");
+    const currentSize = dirSize(distPath);
+    if (budget.warn) {
+      const budgetBytes = parseSize(budget.warn);
+      if (budgetBytes > 0 && currentSize > budgetBytes) {
+        violations.push({
+          package: pkgPath,
+          currentSize,
+          budgetSize: budgetBytes,
+          unit: "bytes",
+          tier: 2,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  const warningCount = violations.filter((v) => v.severity === "warning").length;
+  const infoCount = violations.filter((v) => v.severity === "info").length;
+  return Ok({
+    violations,
+    stats: {
+      packagesChecked,
+      violationCount: violations.length,
+      warningCount,
+      infoCount
+    }
+  });
+}
+
+// src/entropy/fixers/suggestions.ts
+function deadFileSuggestion(file) {
+  return {
+    type: "delete",
+    priority: "high",
+    source: "dead-code",
+    relatedIssues: [`dead-file:${file.path}`],
+    title: `Remove dead file: ${file.path.split("/").pop()}`,
+    description: `This file is not imported by any other file and can be safely removed.`,
+    files: [file.path],
+    steps: [`Delete ${file.path}`, "Run tests to verify no regressions"],
+    whyManual: "File deletion requires verification that no dynamic imports exist"
+  };
+}
+function deadExportSuggestion(exp) {
+  return {
+    type: "refactor",
+    priority: "medium",
+    source: "dead-code",
+    relatedIssues: [`dead-export:${exp.file}:${exp.name}`],
+    title: `Remove unused export: ${exp.name}`,
+    description: `The export "${exp.name}" is not used anywhere. Consider removing it.`,
+    files: [exp.file],
+    steps: [`Remove export "${exp.name}" from ${exp.file}`, "Run tests to verify no regressions"],
+    whyManual: "Export removal may affect external consumers not in scope"
+  };
+}
+function unusedImportSuggestion(imp) {
+  const plural = imp.specifiers.length > 1;
+  return {
+    type: "delete",
+    priority: "medium",
+    source: "dead-code",
+    relatedIssues: [`unused-import:${imp.file}:${imp.specifiers.join(",")}`],
+    title: `Remove unused import${plural ? "s" : ""}: ${imp.specifiers.join(", ")}`,
+    description: `The import${plural ? "s" : ""} from "${imp.source}" ${plural ? "are" : "is"} not used.`,
+    files: [imp.file],
+    steps: imp.isFullyUnused ? [`Remove entire import line from ${imp.file}`] : [`Remove unused specifiers (${imp.specifiers.join(", ")}) from import statement`],
+    whyManual: "Import removal can be auto-fixed"
+  };
+}
+function generateDeadCodeSuggestions(report) {
+  return [
+    ...report.deadFiles.map(deadFileSuggestion),
+    ...report.deadExports.map(deadExportSuggestion),
+    ...report.unusedImports.map(unusedImportSuggestion)
+  ];
+}
+function generateDriftSuggestions(report) {
+  const suggestions = [];
+  for (const drift of report.drifts) {
+    const priority = drift.confidence === "high" ? "high" : "medium";
+    suggestions.push({
+      type: "update-docs",
+      priority,
+      source: "drift",
+      relatedIssues: [`drift:${drift.docFile}:${drift.reference}`],
+      title: `Fix documentation drift: ${drift.reference}`,
+      description: drift.details,
+      files: [drift.docFile],
+      steps: [
+        drift.suggestion || "Review and update documentation",
+        "Review documentation for accuracy"
+      ],
+      whyManual: "Documentation updates require human judgment for accuracy"
+    });
+  }
+  return suggestions;
+}
+function generatePatternSuggestions(report) {
+  const suggestions = [];
+  for (const violation of report.violations) {
+    suggestions.push({
+      type: "refactor",
+      priority: violation.severity === "error" ? "high" : "low",
+      source: "pattern",
+      relatedIssues: [`pattern:${violation.pattern}:${violation.file}`],
+      title: `Fix pattern violation: ${violation.pattern}`,
+      description: violation.message,
+      files: [violation.file],
+      steps: [violation.suggestion || "Follow pattern guidelines"],
+      whyManual: "Pattern violations often require architectural decisions"
+    });
+  }
+  return suggestions;
+}
+function generateSuggestions(deadCode, drift, patterns) {
+  const suggestions = [];
+  if (deadCode) {
+    suggestions.push(...generateDeadCodeSuggestions(deadCode));
+  }
+  if (drift) {
+    suggestions.push(...generateDriftSuggestions(drift));
+  }
+  if (patterns) {
+    suggestions.push(...generatePatternSuggestions(patterns));
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  suggestions.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  const byPriority = {
+    high: suggestions.filter((s) => s.priority === "high"),
+    medium: suggestions.filter((s) => s.priority === "medium"),
+    low: suggestions.filter((s) => s.priority === "low")
+  };
+  let estimatedEffort;
+  if (suggestions.length === 0) {
+    estimatedEffort = "trivial";
+  } else if (suggestions.length <= 5) {
+    estimatedEffort = "small";
+  } else if (suggestions.length <= 20) {
+    estimatedEffort = "medium";
+  } else {
+    estimatedEffort = "large";
+  }
+  return {
+    suggestions,
+    byPriority,
+    estimatedEffort
+  };
+}
+
+// src/entropy/analyzer.ts
+var EntropyAnalyzer = class {
+  config;
+  snapshot;
+  report;
+  constructor(config) {
+    this.config = { ...config };
+  }
+  /**
+   * Run full entropy analysis.
+   * When graphOptions is provided, passes graph data to drift and dead code detectors
+   * for graph-enhanced analysis instead of snapshot-based analysis.
+   */
+  async analyze(graphOptions) {
+    const startTime = Date.now();
+    const needsSnapshot = !graphOptions || !graphOptions.graphDriftData || !graphOptions.graphDeadCodeData;
+    if (needsSnapshot) {
+      const snapshotResult = await buildSnapshot(this.config);
+      if (!snapshotResult.ok) {
+        return Err(snapshotResult.error);
+      }
+      this.snapshot = snapshotResult.value;
+    } else {
+      this.snapshot = {
+        files: [],
+        dependencyGraph: { nodes: [], edges: [] },
+        exportMap: { byFile: /* @__PURE__ */ new Map(), byName: /* @__PURE__ */ new Map() },
+        docs: [],
+        codeReferences: [],
+        entryPoints: [],
+        rootDir: this.config.rootDir,
+        config: this.config,
+        buildTime: 0
+      };
+    }
+    let driftReport;
+    let deadCodeReport;
+    let patternReport;
+    const analysisErrors = [];
+    if (this.config.analyze.drift) {
+      const driftConfig = typeof this.config.analyze.drift === "object" ? this.config.analyze.drift : {};
+      const result = await detectDocDrift(this.snapshot, driftConfig, graphOptions?.graphDriftData);
+      if (result.ok) {
+        driftReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "drift", error: result.error });
+      }
+    }
+    if (this.config.analyze.deadCode) {
+      const result = await detectDeadCode(
+        this.snapshot,
+        graphOptions?.graphDeadCodeData,
+        this.config.protectedRegions
+      );
+      if (result.ok) {
+        deadCodeReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "deadCode", error: result.error });
+      }
+    }
+    if (this.config.analyze.patterns) {
+      const patternConfig = typeof this.config.analyze.patterns === "object" ? this.config.analyze.patterns : { patterns: [] };
+      const result = await detectPatternViolations(this.snapshot, patternConfig);
+      if (result.ok) {
+        patternReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "patterns", error: result.error });
+      }
+    }
+    let complexityReport;
+    if (this.config.analyze.complexity) {
+      const complexityConfig = typeof this.config.analyze.complexity === "object" ? this.config.analyze.complexity : {};
+      const result = await detectComplexityViolations(
+        this.snapshot,
+        complexityConfig,
+        graphOptions?.graphComplexityData
+      );
+      if (result.ok) {
+        complexityReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "complexity", error: result.error });
+      }
+    }
+    let couplingReport;
+    if (this.config.analyze.coupling) {
+      const couplingConfig = typeof this.config.analyze.coupling === "object" ? this.config.analyze.coupling : {};
+      const result = await detectCouplingViolations(
+        this.snapshot,
+        couplingConfig,
+        graphOptions?.graphCouplingData
+      );
+      if (result.ok) {
+        couplingReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "coupling", error: result.error });
+      }
+    }
+    let sizeBudgetReport;
+    if (this.config.analyze.sizeBudget) {
+      const sizeBudgetConfig = typeof this.config.analyze.sizeBudget === "object" ? this.config.analyze.sizeBudget : {};
+      const result = await detectSizeBudgetViolations(this.config.rootDir, sizeBudgetConfig);
+      if (result.ok) {
+        sizeBudgetReport = result.value;
+      } else {
+        analysisErrors.push({ analyzer: "sizeBudget", error: result.error });
+      }
+    }
+    const driftIssues = driftReport?.drifts.length || 0;
+    const deadCodeIssues = (deadCodeReport?.deadExports.length || 0) + (deadCodeReport?.deadFiles.length || 0) + (deadCodeReport?.unusedImports.length || 0);
+    const patternIssues = patternReport?.violations.length || 0;
+    const patternErrors = patternReport?.stats.errorCount || 0;
+    const patternWarnings = patternReport?.stats.warningCount || 0;
+    const complexityIssues = complexityReport?.violations.length || 0;
+    const couplingIssues = couplingReport?.violations.length || 0;
+    const sizeBudgetIssues = sizeBudgetReport?.violations.length || 0;
+    const complexityErrors = complexityReport?.stats.errorCount || 0;
+    const complexityWarnings = complexityReport?.stats.warningCount || 0;
+    const couplingWarnings = couplingReport?.stats.warningCount || 0;
+    const sizeBudgetWarnings = sizeBudgetReport?.stats.warningCount || 0;
+    const totalIssues = driftIssues + deadCodeIssues + patternIssues + complexityIssues + couplingIssues + sizeBudgetIssues;
+    const fixableCount = (deadCodeReport?.deadFiles.length || 0) + (deadCodeReport?.unusedImports.length || 0);
+    const suggestions = generateSuggestions(deadCodeReport, driftReport, patternReport);
+    const duration = Date.now() - startTime;
+    const report = {
+      snapshot: this.snapshot,
+      analysisErrors,
+      summary: {
+        totalIssues,
+        errors: patternErrors + complexityErrors,
+        warnings: patternWarnings + driftIssues + complexityWarnings + couplingWarnings + sizeBudgetWarnings,
+        fixableCount,
+        suggestionCount: suggestions.suggestions.length
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration
+    };
+    if (driftReport) {
+      report.drift = driftReport;
+    }
+    if (deadCodeReport) {
+      report.deadCode = deadCodeReport;
+    }
+    if (patternReport) {
+      report.patterns = patternReport;
+    }
+    if (complexityReport) {
+      report.complexity = complexityReport;
+    }
+    if (couplingReport) {
+      report.coupling = couplingReport;
+    }
+    if (sizeBudgetReport) {
+      report.sizeBudget = sizeBudgetReport;
+    }
+    this.report = report;
+    return Ok(report);
+  }
+  /**
+   * Get the built snapshot (must call analyze first)
+   */
+  getSnapshot() {
+    return this.snapshot;
+  }
+  /**
+   * Get the last report (must call analyze first)
+   */
+  getReport() {
+    return this.report;
+  }
+  /**
+   * Generate suggestions from the last analysis
+   */
+  getSuggestions() {
+    if (!this.report) {
+      return {
+        suggestions: [],
+        byPriority: { high: [], medium: [], low: [] },
+        estimatedEffort: "trivial"
+      };
+    }
+    return generateSuggestions(this.report.deadCode, this.report.drift, this.report.patterns);
+  }
+  /**
+   * Build snapshot without running analysis
+   */
+  async buildSnapshot() {
+    const result = await buildSnapshot(this.config);
+    if (result.ok) {
+      this.snapshot = result.value;
+    }
+    return result;
+  }
+  /**
+   * Ensure snapshot is built, returning the snapshot or an error
+   */
+  async ensureSnapshot() {
+    if (this.snapshot) {
+      return Ok(this.snapshot);
+    }
+    return this.buildSnapshot();
+  }
+  /**
+   * Run drift detection only (snapshot must be built first)
+   */
+  async detectDrift(config, graphDriftData) {
+    const snapshotResult = await this.ensureSnapshot();
+    if (!snapshotResult.ok) {
+      return Err(snapshotResult.error);
+    }
+    return detectDocDrift(snapshotResult.value, config || {}, graphDriftData);
+  }
+  /**
+   * Run dead code detection only (snapshot must be built first)
+   */
+  async detectDeadCode(graphDeadCodeData) {
+    const snapshotResult = await this.ensureSnapshot();
+    if (!snapshotResult.ok) {
+      return Err(snapshotResult.error);
+    }
+    return detectDeadCode(snapshotResult.value, graphDeadCodeData, this.config.protectedRegions);
+  }
+  /**
+   * Run pattern detection only (snapshot must be built first)
+   */
+  async detectPatterns(config) {
+    const snapshotResult = await this.ensureSnapshot();
+    if (!snapshotResult.ok) {
+      return Err(snapshotResult.error);
+    }
+    return detectPatternViolations(snapshotResult.value, config);
+  }
+};
+
+export {
+  buildSnapshot,
+  detectDocDrift,
+  detectDeadCode,
+  detectPatternViolations,
+  parseSize,
+  detectSizeBudgetViolations,
+  generateSuggestions,
+  EntropyAnalyzer
+};