depwire-cli 0.9.0 → 0.9.2

package/dist/{chunk-MGMDHXPB.js → chunk-3DXWSPZL.js}

@@ -30,7 +30,8 @@ function scanDirectory(rootDir, baseDir = rootDir) {
         const isPython = entry.endsWith(".py");
         const isGo = entry.endsWith(".go") && !entry.endsWith("_test.go");
         const isRust = entry.endsWith(".rs");
-        if (isTypeScript || isJavaScript || isPython || isGo || isRust) {
+        const isC = entry.endsWith(".c") || entry.endsWith(".h");
+        if (isTypeScript || isJavaScript || isPython || isGo || isRust || isC) {
           files.push(relative(rootDir, fullPath));
         }
       }
@@ -61,6 +62,12 @@ function findProjectRoot(startDir = process.cwd()) {
     // Python (modern)
     "setup.py",
     // Python (legacy)
+    "Makefile",
+    // C/C++ (make-based)
+    "CMakeLists.txt",
+    // C/C++ (cmake-based)
+    "configure.ac",
+    // C/C++ (autotools)
     ".git"
     // Any git repo
   ];
@@ -83,8 +90,8 @@ function findProjectRoot(startDir = process.cwd()) {
 }
 
 // src/parser/index.ts
-import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
 
 // src/parser/detect.ts
 import { extname as extname3 } from "path";
@@ -113,7 +120,8 @@ async function initParser() {
     "javascript": "tree-sitter-javascript.wasm",
     "python": "tree-sitter-python.wasm",
     "go": "tree-sitter-go.wasm",
-    "rust": "tree-sitter-rust.wasm"
+    "rust": "tree-sitter-rust.wasm",
+    "c": "tree-sitter-c.wasm"
   };
   for (const [name, file] of Object.entries(grammarFiles)) {
     const wasmPath = path.join(grammarsDir, file);
@@ -2392,13 +2400,383 @@ var rustParser = {
   parseFile: parseRustFile
 };
 
+// src/parser/c.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join7, dirname as dirname6, relative as relative4 } from "path";
+function parseCFile(filePath, sourceCode, projectRoot) {
+  const parser = getParser("c");
+  const tree = parser.parse(sourceCode, null, { bufferSize: 1024 * 1024 });
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: []
+  };
+  walkNode6(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode6(node, context) {
+  processNode6(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode6(child, context);
+    }
+  }
+}
+function processNode6(node, context) {
+  const type = node.type;
+  switch (type) {
+    case "function_definition":
+      processFunctionDefinition2(node, context);
+      break;
+    case "struct_specifier":
+      processStructSpecifier(node, context);
+      break;
+    case "enum_specifier":
+      processEnumSpecifier(node, context);
+      break;
+    case "type_definition":
+      processTypeDefinition(node, context);
+      break;
+    case "declaration":
+      processDeclaration(node, context);
+      break;
+    case "preproc_def":
+    case "preproc_function_def":
+      processMacroDefinition(node, context);
+      break;
+    case "preproc_include":
+      processIncludeDirective(node, context);
+      break;
+    case "call_expression":
+      processCallExpression6(node, context);
+      break;
+  }
+}
+function processFunctionDefinition2(node, context) {
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return;
+  const nameNode = extractFunctionName(declarator);
+  if (!nameNode) return;
+  const name = nodeText5(nameNode, context);
+  const exported = !hasStorageClass(node, "static", context);
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "function",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body");
+  if (body) {
+    walkNode6(body, context);
+  }
+  context.currentScope.pop();
+}
+function processStructSpecifier(node, context) {
+  const parent = node.parent;
+  let name = null;
+  if (parent && parent.type === "type_definition") {
+    const typedefName = parent.childForFieldName("declarator");
+    if (typedefName) {
+      name = extractIdentifierFromDeclarator(typedefName, context);
+    }
+  }
+  if (!name) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) {
+      name = nodeText5(nameNode, context);
+    }
+  }
+  if (!name) return;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "class",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+  });
+}
+function processEnumSpecifier(node, context) {
+  const parent = node.parent;
+  let name = null;
+  if (parent && parent.type === "type_definition") {
+    const typedefName = parent.childForFieldName("declarator");
+    if (typedefName) {
+      name = extractIdentifierFromDeclarator(typedefName, context);
+    }
+  }
+  if (!name) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode) {
+      name = nodeText5(nameNode, context);
+    }
+  }
+  if (!name) return;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "enum",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+  });
+}
+function processTypeDefinition(node, context) {
+  const typeNode = node.childForFieldName("type");
+  if (!typeNode) return;
+  if (typeNode.type === "struct_specifier" || typeNode.type === "enum_specifier") {
+    return;
+  }
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return;
+  const name = extractIdentifierFromDeclarator(declarator, context);
+  if (!name) return;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "type_alias",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+  });
+}
+function processDeclaration(node, context) {
+  if (context.currentScope.length > 0) {
+    return;
+  }
+  const parent = node.parent;
+  if (!parent || parent.type !== "translation_unit") {
+    return;
+  }
+  const hasStatic = hasStorageClass(node, "static", context);
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return;
+  const name = extractIdentifierFromDeclarator(declarator, context);
+  if (!name) return;
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "variable",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: !hasStatic
+  });
+}
+function processMacroDefinition(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText5(nameNode, context);
+  const kind = node.type === "preproc_function_def" ? "function" : "constant";
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind,
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+  });
+}
+function processIncludeDirective(node, context) {
+  const pathNode = node.childForFieldName("path");
+  if (!pathNode) return;
+  const pathText = nodeText5(pathNode, context);
+  const isLocalInclude = pathText.startsWith('"') && pathText.endsWith('"');
+  if (!isLocalInclude) {
+    return;
+  }
+  const includePath = pathText.slice(1, -1);
+  const resolvedFiles = resolveIncludePath(includePath, context.filePath, context.projectRoot);
+  if (resolvedFiles.length === 0) return;
+  const sourceId = `${context.filePath}::__file__`;
+  for (const targetPath of resolvedFiles) {
+    const targetId = `${targetPath}::__file__`;
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processCallExpression6(node, context) {
+  if (context.currentScope.length === 0) return;
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  const calleeName = nodeText5(functionNode, context);
+  const builtins = /* @__PURE__ */ new Set(["printf", "scanf", "malloc", "free", "memcpy", "strlen", "strcmp", "strcpy", "strcat"]);
+  if (builtins.has(calleeName)) return;
+  const callerId = getCurrentSymbolId6(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol5(calleeName, context);
+  if (!calleeId) return;
+  context.edges.push({
+    source: callerId,
+    target: calleeId,
+    kind: "calls",
+    filePath: context.filePath,
+    line: node.startPosition.row + 1
+  });
+}
+function resolveIncludePath(includePath, currentFile, projectRoot) {
+  const currentFileAbs = join7(projectRoot, currentFile);
+  const currentDir = dirname6(currentFileAbs);
+  const possibleFiles = [
+    join7(currentDir, includePath),
+    join7(projectRoot, includePath)
+  ];
+  const resolvedFiles = [];
+  for (const absPath of possibleFiles) {
+    if (existsSync7(absPath)) {
+      const relPath = relative4(projectRoot, absPath);
+      resolvedFiles.push(relPath);
+    }
+  }
+  return resolvedFiles;
+}
+function hasStorageClass(node, className, context) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "storage_class_specifier") {
+      const text = nodeText5(child, context);
+      if (text === className) {
+        return true;
+      }
+    }
+  }
+  let parent = node.parent;
+  while (parent) {
+    for (let i = 0; i < parent.childCount; i++) {
+      const child = parent.child(i);
+      if (child && child.type === "storage_class_specifier") {
+        const text = nodeText5(child, context);
+        if (text === className) {
+          return true;
+        }
+      }
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+function extractFunctionName(declarator) {
+  if (declarator.type === "identifier") {
+    return declarator;
+  }
+  if (declarator.type === "function_declarator") {
+    const innerDeclarator = declarator.childForFieldName("declarator");
+    if (innerDeclarator) {
+      return extractFunctionName(innerDeclarator);
+    }
+  }
+  if (declarator.type === "pointer_declarator") {
+    const innerDeclarator = declarator.childForFieldName("declarator");
+    if (innerDeclarator) {
+      return extractFunctionName(innerDeclarator);
+    }
+  }
+  for (let i = 0; i < declarator.childCount; i++) {
+    const child = declarator.child(i);
+    if (child && child.type === "identifier") {
+      return child;
+    }
+  }
+  return null;
+}
+function extractIdentifierFromDeclarator(declarator, context) {
+  if (declarator.type === "identifier") {
+    return nodeText5(declarator, context);
+  }
+  if (declarator.type === "type_identifier") {
+    return nodeText5(declarator, context);
+  }
+  const identifierNode = findChildByType6(declarator, "identifier");
+  if (identifierNode) {
+    return nodeText5(identifierNode, context);
+  }
+  const typeIdNode = findChildByType6(declarator, "type_identifier");
+  if (typeIdNode) {
+    return nodeText5(typeIdNode, context);
+  }
+  for (let i = 0; i < declarator.childCount; i++) {
+    const child = declarator.child(i);
+    if (child) {
+      const name = extractIdentifierFromDeclarator(child, context);
+      if (name) return name;
+    }
+  }
+  return null;
+}
+function resolveSymbol5(name, context) {
+  const currentFileId = `${context.filePath}::__file__`;
+  const symbol = context.symbols.find(
+    (s) => s.name === name && (s.filePath === context.filePath || s.exported)
+  );
+  if (symbol) {
+    return symbol.id;
+  }
+  for (let i = context.currentScope.length - 1; i >= 0; i--) {
+    const scopedId = `${context.filePath}::${context.currentScope.slice(0, i + 1).join("::")}::${name}`;
+    const scopedSymbol = context.symbols.find((s) => s.id === scopedId);
+    if (scopedSymbol) {
+      return scopedSymbol.id;
+    }
+  }
+  return null;
+}
+function findChildByType6(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) {
+      return child;
+    }
+  }
+  return null;
+}
+function nodeText5(node, context) {
+  return context.sourceCode.slice(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId6(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope.join("::")}`;
+}
+var cParser = {
+  name: "c",
+  extensions: [".c", ".h"],
+  parseFile: parseCFile
+};
+
 // src/parser/detect.ts
 var parsers = [
   typescriptParser,
   pythonParser,
   javascriptParser,
   goParser,
-  rustParser
+  rustParser,
+  cParser
 ];
 function getParserForFile(filePath) {
   const ext = extname3(filePath).toLowerCase();
@@ -2428,7 +2806,7 @@ async function parseProject(projectRoot, options) {
   let errorFiles = 0;
   for (const file of files) {
     try {
-      const fullPath = join7(projectRoot, file);
+      const fullPath = join8(projectRoot, file);
       if (options?.exclude) {
         const shouldExclude2 = options.exclude.some(
           (pattern) => minimatch(file, pattern, { matchBase: true })
@@ -2454,7 +2832,7 @@ async function parseProject(projectRoot, options) {
         skippedFiles++;
         continue;
       }
-      const sourceCode = readFileSync4(fullPath, "utf-8");
+      const sourceCode = readFileSync5(fullPath, "utf-8");
       const parsed = parser.parseFile(file, sourceCode, projectRoot);
       parsedFiles.push(parsed);
     } catch (err) {
@@ -2847,7 +3225,7 @@ function watchProject(projectRoot, callbacks) {
   const watcher = chokidar.watch(projectRoot, watcherOptions);
   console.error("[Watcher] Attaching event listeners...");
   watcher.on("change", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".c", ".h"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2855,7 +3233,7 @@ function watchProject(projectRoot, callbacks) {
     callbacks.onFileChanged(relativePath);
   });
   watcher.on("add", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".c", ".h"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2863,7 +3241,7 @@ function watchProject(projectRoot, callbacks) {
     callbacks.onFileAdded(relativePath);
   });
   watcher.on("unlink", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".c", ".h"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2881,10 +3259,10 @@ function watchProject(projectRoot, callbacks) {
     for (const dir of dirs) {
       const files = watched[dir];
       fileCount += files.filter(
-        (f) => f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js") || f.endsWith(".jsx") || f.endsWith(".mjs") || f.endsWith(".cjs") || f.endsWith(".py") || f.endsWith(".go") && !f.endsWith("_test.go")
+        (f) => f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js") || f.endsWith(".jsx") || f.endsWith(".mjs") || f.endsWith(".cjs") || f.endsWith(".py") || f.endsWith(".go") && !f.endsWith("_test.go") || f.endsWith(".rs") || f.endsWith(".c") || f.endsWith(".h")
       ).length;
     }
-    console.error(`[Watcher] Watching ${fileCount} TypeScript/JavaScript/Python/Go files in ${dirs.length} directories`);
+    console.error(`[Watcher] Watching ${fileCount} TypeScript/JavaScript/Python/Go/Rust/C files in ${dirs.length} directories`);
   });
   return watcher;
 }
@@ -2893,10 +3271,10 @@ function watchProject(projectRoot, callbacks) {
 import express from "express";
 import open from "open";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, join as join8 } from "path";
+import { dirname as dirname7, join as join9 } from "path";
 import { WebSocketServer } from "ws";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname6(__filename);
+var __dirname2 = dirname7(__filename);
 var activeServer = null;
 async function findAvailablePort(startPort, maxAttempts = 10) {
   const net = await import("net");
@@ -2934,7 +3312,7 @@ async function startVizServer(initialVizData, graph, projectRoot, port = 3333, s
   const availablePort = await findAvailablePort(port);
   const app = express();
   let vizData = initialVizData;
-  const publicDir = join8(__dirname2, "viz", "public");
+  const publicDir = join9(__dirname2, "viz", "public");
   app.use(express.static(publicDir));
   app.get("/api/graph", (req, res) => {
     res.json(vizData);
@@ -3050,7 +3428,7 @@ function isProjectLoaded(state) {
 }
 
 // src/graph/updater.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function removeFileFromGraph(graph, filePath) {
   const nodesToRemove = [];
   graph.forEachNode((node, attrs) => {
@@ -3094,7 +3472,7 @@ function addFileToGraph(graph, parsedFile) {
 }
 async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
   removeFileFromGraph(graph, relativeFilePath);
-  const absolutePath = join9(projectRoot, relativeFilePath);
+  const absolutePath = join10(projectRoot, relativeFilePath);
   try {
     const parsedFile = parseTypeScriptFile(absolutePath, relativeFilePath);
     addFileToGraph(graph, parsedFile);
@@ -3104,7 +3482,7 @@ async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
 }
 
 // src/health/metrics.ts
-import { dirname as dirname7 } from "path";
+import { dirname as dirname8 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -3137,8 +3515,8 @@ function calculateCouplingScore(graph) {
       totalEdges++;
       fileConnections.set(sourceAttrs.filePath, (fileConnections.get(sourceAttrs.filePath) || 0) + 1);
       fileConnections.set(targetAttrs.filePath, (fileConnections.get(targetAttrs.filePath) || 0) + 1);
-      const sourceDir = dirname7(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname7(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname8(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname8(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -3185,8 +3563,8 @@ function calculateCohesionScore(graph) {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
     if (sourceAttrs.filePath !== targetAttrs.filePath) {
-      const sourceDir = dirname7(sourceAttrs.filePath);
-      const targetDir = dirname7(targetAttrs.filePath);
+      const sourceDir = dirname8(sourceAttrs.filePath);
+      const targetDir = dirname8(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -3468,8 +3846,8 @@ function calculateDepthScore(graph) {
 }
 
 // src/health/index.ts
-import { readFileSync as readFileSync5, writeFileSync, existsSync as existsSync7, mkdirSync } from "fs";
-import { join as join10, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync6, writeFileSync, existsSync as existsSync8, mkdirSync } from "fs";
+import { join as join11, dirname as dirname9 } from "path";
 function calculateHealthScore(graph, projectRoot) {
   const coupling = calculateCouplingScore(graph);
   const cohesion = calculateCohesionScore(graph);
@@ -3568,7 +3946,7 @@ function getHealthTrend(projectRoot, currentScore) {
   }
 }
 function saveHealthHistory(projectRoot, report) {
-  const historyFile = join10(projectRoot, ".depwire", "health-history.json");
+  const historyFile = join11(projectRoot, ".depwire", "health-history.json");
   const entry = {
     timestamp: report.timestamp,
     score: report.overall,
@@ -3580,9 +3958,9 @@ function saveHealthHistory(projectRoot, report) {
     }))
   };
   let history = [];
-  if (existsSync7(historyFile)) {
+  if (existsSync8(historyFile)) {
     try {
-      const content = readFileSync5(historyFile, "utf-8");
+      const content = readFileSync6(historyFile, "utf-8");
       history = JSON.parse(content);
     } catch {
     }
@@ -3591,16 +3969,16 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname8(historyFile), { recursive: true });
+  mkdirSync(dirname9(historyFile), { recursive: true });
   writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
 }
 function loadHealthHistory(projectRoot) {
-  const historyFile = join10(projectRoot, ".depwire", "health-history.json");
-  if (!existsSync7(historyFile)) {
+  const historyFile = join11(projectRoot, ".depwire", "health-history.json");
+  if (!existsSync8(historyFile)) {
     return [];
   }
   try {
-    const content = readFileSync5(historyFile, "utf-8");
+    const content = readFileSync6(historyFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -3609,21 +3987,89 @@ function loadHealthHistory(projectRoot) {
 
 // src/dead-code/detector.ts
 import path2 from "path";
-function findDeadSymbols(graph, projectRoot, includeTests = false) {
+import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
+function findDeadSymbols(graph, projectRoot, includeTests = false, debug = false) {
   const deadSymbols = [];
   const context = { graph, projectRoot };
+  const stats = {
+    total: 0,
+    excludedByTestFile: 0,
+    excludedByEntryPoint: 0,
+    excludedByConfigFile: 0,
+    excludedByTypeDeclaration: 0,
+    excludedByDefaultExport: 0,
+    excludedByFrameworkDir: 0
+  };
+  const packageEntryPoints = getPackageEntryPoints(projectRoot);
+  if (debug) {
+    console.log("\n\u{1F50D} Debug: Graph Structure");
+    console.log(`Total nodes in graph: ${graph.order}`);
+    console.log(`Total edges in graph: ${graph.size}`);
+    let nodesWithZeroInDegree = 0;
+    let nodesWithZeroOutDegree = 0;
+    graph.forEachNode((node) => {
+      if (graph.inDegree(node) === 0) nodesWithZeroInDegree++;
+      if (graph.outDegree(node) === 0) nodesWithZeroOutDegree++;
+    });
+    console.log(`Nodes with inDegree=0: ${nodesWithZeroInDegree}`);
+    console.log(`Nodes with outDegree=0: ${nodesWithZeroOutDegree}`);
+    if (nodesWithZeroInDegree <= 10) {
+      console.log("\nSample nodes with inDegree=0:");
+      let count = 0;
+      graph.forEachNode((node) => {
+        if (graph.inDegree(node) === 0 && count < 10) {
+          const attrs = graph.getNodeAttributes(node);
+          const filePath = attrs.file || attrs.filePath || "unknown";
+          console.log(`  - ${attrs.name} (${attrs.kind}) in ${path2.relative(projectRoot, filePath)}`);
+          count++;
+        }
+      });
+    }
+  }
   for (const node of graph.nodes()) {
     const attrs = graph.getNodeAttributes(node);
-    if (!attrs.file || !attrs.name) continue;
+    if (!attrs.name) continue;
+    if (!attrs.file && !attrs.filePath) {
+      if (debug) {
+        console.log(`Skipping node ${attrs.name} - no file attribute`);
+      }
+      continue;
+    }
+    const filePath = attrs.file || attrs.filePath;
+    if (!isRelevantForDeadCodeDetection(attrs)) {
+      continue;
+    }
     const inDegree = graph.inDegree(node);
     if (inDegree === 0) {
-      if (shouldExclude(attrs, context, includeTests)) {
+      stats.total++;
+      const exclusionReason = shouldExclude(attrs, context, includeTests, packageEntryPoints);
+      if (exclusionReason) {
+        switch (exclusionReason) {
+          case "test":
+            stats.excludedByTestFile++;
+            break;
+          case "entry":
+            stats.excludedByEntryPoint++;
+            break;
+          case "config":
+            stats.excludedByConfigFile++;
+            break;
+          case "types":
+            stats.excludedByTypeDeclaration++;
+            break;
+          case "default":
+            stats.excludedByDefaultExport++;
+            break;
+          case "framework":
+            stats.excludedByFrameworkDir++;
+            break;
+        }
         continue;
       }
       deadSymbols.push({
         name: attrs.name,
         kind: attrs.kind || "unknown",
-        file: attrs.file,
+        file: filePath,
         line: attrs.startLine || 0,
         exported: attrs.exported || false,
         dependents: 0,
@@ -3632,38 +4078,115 @@ function findDeadSymbols(graph, projectRoot, includeTests = false) {
       });
     }
   }
-  return deadSymbols;
+  if (debug) {
+    console.log("\n\u{1F50D} Debug: Exclusion Statistics");
+    console.log(`Total symbols with 0 incoming edges: ${stats.total}`);
+    console.log(`Excluded by test file: ${stats.excludedByTestFile}`);
+    console.log(`Excluded by entry point: ${stats.excludedByEntryPoint}`);
+    console.log(`Excluded by config file: ${stats.excludedByConfigFile}`);
+    console.log(`Excluded by type declaration: ${stats.excludedByTypeDeclaration}`);
+    console.log(`Excluded by default export: ${stats.excludedByDefaultExport}`);
+    console.log(`Excluded by framework dir: ${stats.excludedByFrameworkDir}`);
+    console.log(`Remaining dead symbols: ${deadSymbols.length}
+`);
+  }
+  return { symbols: deadSymbols, stats };
+}
+function isRelevantForDeadCodeDetection(attrs) {
+  const kind = attrs.kind;
+  const relevantKinds = [
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "const",
+    "let",
+    "var",
+    "method",
+    "property"
+  ];
+  if (!relevantKinds.includes(kind)) {
+    return false;
+  }
+  if (kind === "const" || kind === "let" || kind === "var" || kind === "variable") {
+    return attrs.exported === true;
+  }
+  return true;
+}
+function getPackageEntryPoints(projectRoot) {
+  const entryPoints = /* @__PURE__ */ new Set();
+  const packageJsonPath = path2.join(projectRoot, "package.json");
+  if (!existsSync9(packageJsonPath)) {
+    return entryPoints;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
+    if (packageJson.main) {
+      entryPoints.add(path2.resolve(projectRoot, packageJson.main));
+    }
+    if (packageJson.module) {
+      entryPoints.add(path2.resolve(projectRoot, packageJson.module));
+    }
+    if (packageJson.exports) {
+      const addExports = (exp) => {
+        if (typeof exp === "string") {
+          entryPoints.add(path2.resolve(projectRoot, exp));
+        } else if (typeof exp === "object") {
+          for (const key in exp) {
+            if (typeof exp[key] === "string") {
+              entryPoints.add(path2.resolve(projectRoot, exp[key]));
+            } else if (typeof exp[key] === "object") {
+              addExports(exp[key]);
+            }
+          }
+        }
+      };
+      addExports(packageJson.exports);
+    }
+  } catch (e) {
+  }
+  return entryPoints;
 }
-function shouldExclude(attrs, context, includeTests) {
-  const filePath = attrs.file;
+function shouldExclude(attrs, context, includeTests, packageEntryPoints) {
+  const filePath = attrs.file || attrs.filePath;
+  if (!filePath) {
+    return null;
+  }
   const relativePath = path2.relative(context.projectRoot, filePath);
   if (!includeTests && isTestFile(relativePath)) {
-    return true;
+    return "test";
   }
-  if (isEntryPoint(relativePath)) {
-    return true;
+  if (isRealPackageEntryPoint(filePath, packageEntryPoints)) {
+    return "entry";
   }
   if (isConfigFile(relativePath)) {
-    return true;
+    return "config";
   }
   if (isTypeDeclarationFile(relativePath)) {
-    return true;
+    return "types";
   }
   if (attrs.kind === "default") {
-    return true;
+    return "default";
   }
   if (isFrameworkAutoLoadedFile(relativePath)) {
-    return true;
+    return "framework";
+  }
+  return null;
+}
+function isRealPackageEntryPoint(filePath, packageEntryPoints) {
+  const normalizedPath = path2.normalize(filePath);
+  for (const entryPoint of packageEntryPoints) {
+    const normalizedEntry = path2.normalize(entryPoint);
+    if (normalizedPath === normalizedEntry || normalizedPath === normalizedEntry.replace(/\.(js|ts)$/, ".ts") || normalizedPath === normalizedEntry.replace(/\.(js|ts)$/, ".js")) {
+      return true;
+    }
   }
   return false;
 }
 function isTestFile(filePath) {
   return filePath.includes("__tests__/") || filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/test/") || filePath.includes("/tests/");
 }
-function isEntryPoint(filePath) {
-  const basename6 = path2.basename(filePath);
-  return basename6 === "index.ts" || basename6 === "index.js" || basename6 === "main.ts" || basename6 === "main.js" || basename6 === "app.ts" || basename6 === "app.js" || basename6 === "server.ts" || basename6 === "server.js";
-}
 function isConfigFile(filePath) {
   return filePath.includes(".config.") || filePath.includes("config/") || filePath.includes("vite.config") || filePath.includes("rollup.config") || filePath.includes("webpack.config");
 }
@@ -3874,9 +4397,15 @@ function analyzeDeadCode(graph, projectRoot, options = {}) {
     includeTests: options.includeTests || false,
     verbose: options.verbose || false,
     stats: options.stats || false,
-    json: options.json || false
+    json: options.json || false,
+    debug: options.debug || false
   };
-  const rawDeadSymbols = findDeadSymbols(graph, projectRoot, opts.includeTests);
+  const { symbols: rawDeadSymbols } = findDeadSymbols(
+    graph,
+    projectRoot,
+    opts.includeTests,
+    opts.debug
+  );
   const classifiedSymbols = classifyDeadSymbols(rawDeadSymbols, graph);
   const filteredSymbols = filterByConfidence(classifiedSymbols, opts.confidence);
   const totalSymbols = graph.order;
@@ -3906,11 +4435,11 @@ function filterByConfidence(symbols, minConfidence) {
 }
 
 // src/docs/generator.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync10 } from "fs";
-import { join as join13 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync12 } from "fs";
+import { join as join14 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -4061,7 +4590,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -4086,7 +4615,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4101,8 +4630,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname9(sourceAttrs.filePath);
-    const targetDir = dirname9(targetAttrs.filePath);
+    const sourceDir = dirname10(sourceAttrs.filePath);
+    const targetDir = dirname10(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -5083,7 +5612,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname10 } from "path";
+import { dirname as dirname11 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5142,7 +5671,7 @@ function generateQuickOrientation(graph) {
   const primaryLang = Object.entries(languages2).sort((a, b) => b[1] - a[1])[0];
   const dirs = /* @__PURE__ */ new Set();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname11(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -5246,7 +5775,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname11(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -5261,7 +5790,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname11(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -5276,8 +5805,8 @@ function getDirectoryStats2(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname10(sourceAttrs.filePath);
-    const targetDir = dirname10(targetAttrs.filePath);
+    const sourceDir = dirname11(sourceAttrs.filePath);
+    const targetDir = dirname11(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -5358,7 +5887,7 @@ function detectClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname11(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -5412,8 +5941,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname10(files[0]);
-  if (files.every((f) => dirname10(f) === commonDir)) {
+  const commonDir = dirname11(files[0]);
+  if (files.every((f) => dirname11(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -5471,7 +6000,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname11, basename as basename3 } from "path";
+import { dirname as dirname12, basename as basename3 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5575,7 +6104,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname11(file.filePath);
+    const dir = dirname12(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -6218,7 +6747,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename4, dirname as dirname12 } from "path";
+import { basename as basename4, dirname as dirname13 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6247,7 +6776,7 @@ function getFileCount8(graph) {
 }
 function isTestFile3(filePath) {
   const fileName = basename4(filePath).toLowerCase();
-  const dirPath = dirname12(filePath).toLowerCase();
+  const dirPath = dirname13(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -6306,12 +6835,12 @@ function generateTestFileInventory(graph) {
 }
 function matchTestToSource(testFile) {
   const testFileName = basename4(testFile);
-  const testDir = dirname12(testFile);
+  const testDir = dirname13(testFile);
   let sourceFileName = testFileName.replace(/\.test\./g, ".").replace(/\.spec\./g, ".").replace(/_test\./g, ".").replace(/_spec\./g, ".");
   const possiblePaths = [];
   possiblePaths.push(testDir + "/" + sourceFileName);
   if (testDir.endsWith("/test") || testDir.endsWith("/tests") || testDir.endsWith("/__tests__")) {
-    const parentDir = dirname12(testDir);
+    const parentDir = dirname13(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -6508,7 +7037,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname12(sourceFile).split("/")[0];
+    const dir = dirname13(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -6531,7 +7060,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -6812,7 +7341,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname13(attrs.filePath);
+    const dir = dirname14(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -6894,7 +7423,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname14 } from "path";
+import { dirname as dirname15 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7032,7 +7561,7 @@ function generateCompleteFileIndex(graph) {
   fileInfos.sort((a, b) => a.filePath.localeCompare(b.filePath));
   const dirGroups = /* @__PURE__ */ new Map();
   for (const info of fileInfos) {
-    const dir = dirname14(info.filePath);
+    const dir = dirname15(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -7243,8 +7772,8 @@ function getTopLevelDir2(filePath) {
 }
 
 // src/docs/status.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import { join as join12 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7277,12 +7806,12 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const fullPath = join11(projectRoot, filePath);
-  if (!existsSync8(fullPath)) {
+  const fullPath = join12(projectRoot, filePath);
+  if (!existsSync10(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync6(fullPath, "utf-8");
+    const content = readFileSync8(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -7844,15 +8373,15 @@ function generateConfidenceSection(title, description, symbols, projectRoot) {
 }
 
 // src/docs/metadata.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "fs";
+import { join as join13 } from "path";
 function loadMetadata(outputDir) {
-  const metadataPath = join12(outputDir, "metadata.json");
-  if (!existsSync9(metadataPath)) {
+  const metadataPath = join13(outputDir, "metadata.json");
+  if (!existsSync11(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync7(metadataPath, "utf-8");
+    const content = readFileSync9(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -7860,7 +8389,7 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const metadataPath = join12(outputDir, "metadata.json");
+  const metadataPath = join13(outputDir, "metadata.json");
   writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 function createMetadata(version, projectPath, fileCount, symbolCount, edgeCount, docTypes) {
@@ -7903,7 +8432,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync10(options.outputDir)) {
+    if (!existsSync12(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -7942,7 +8471,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ARCHITECTURE.md...");
           const content = generateArchitecture(graph, projectRoot, version, parseTime);
-          const filePath = join13(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join14(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -7953,7 +8482,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CONVENTIONS.md...");
           const content = generateConventions(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "CONVENTIONS.md");
+          const filePath = join14(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -7964,7 +8493,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEPENDENCIES.md...");
           const content = generateDependencies(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join14(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -7975,7 +8504,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ONBOARDING.md...");
           const content = generateOnboarding(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "ONBOARDING.md");
+          const filePath = join14(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -7986,7 +8515,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating FILES.md...");
           const content = generateFiles(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "FILES.md");
+          const filePath = join14(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -7997,7 +8526,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating API_SURFACE.md...");
           const content = generateApiSurface(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "API_SURFACE.md");
+          const filePath = join14(options.outputDir, "API_SURFACE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
@@ -8008,7 +8537,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating ERRORS.md...");
           const content = generateErrors(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "ERRORS.md");
+          const filePath = join14(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -8019,7 +8548,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating TESTS.md...");
           const content = generateTests(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "TESTS.md");
+          const filePath = join14(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -8030,7 +8559,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HISTORY.md...");
           const content = generateHistory(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "HISTORY.md");
+          const filePath = join14(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -8041,7 +8570,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating CURRENT.md...");
           const content = generateCurrent(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "CURRENT.md");
+          const filePath = join14(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -8052,7 +8581,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating STATUS.md...");
           const content = generateStatus(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "STATUS.md");
+          const filePath = join14(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -8063,7 +8592,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating HEALTH.md...");
           const content = generateHealth(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "HEALTH.md");
+          const filePath = join14(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
@@ -8074,7 +8603,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
         try {
           if (options.verbose) console.log("Generating DEAD_CODE.md...");
           const content = generateDeadCode(graph, projectRoot, version);
-          const filePath = join13(options.outputDir, "DEAD_CODE.md");
+          const filePath = join14(options.outputDir, "DEAD_CODE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEAD_CODE.md");
         } catch (err) {
@@ -8122,13 +8651,13 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import { dirname as dirname15, join as join16 } from "path";
-import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname16, join as join17 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
 
 // src/mcp/connect.ts
 import simpleGit from "simple-git";
-import { existsSync as existsSync11 } from "fs";
-import { join as join14, basename as basename5, resolve as resolve2 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join15, basename as basename5, resolve as resolve2 } from "path";
 import { tmpdir, homedir } from "os";
 function validateProjectPath(source) {
   const resolved = resolve2(source);
@@ -8141,11 +8670,11 @@ function validateProjectPath(source) {
     "/boot",
     "/proc",
     "/sys",
-    join14(homedir(), ".ssh"),
-    join14(homedir(), ".gnupg"),
-    join14(homedir(), ".aws"),
-    join14(homedir(), ".config"),
-    join14(homedir(), ".env")
+    join15(homedir(), ".ssh"),
+    join15(homedir(), ".gnupg"),
+    join15(homedir(), ".aws"),
+    join15(homedir(), ".config"),
+    join15(homedir(), ".env")
   ];
   for (const blocked of blockedPaths) {
     if (resolved.startsWith(blocked)) {
@@ -8168,11 +8697,11 @@ async function connectToRepo(source, subdirectory, state) {
         };
       }
       projectName = match[1];
-      const reposDir = join14(tmpdir(), "depwire-repos");
-      const cloneDir = join14(reposDir, projectName);
+      const reposDir = join15(tmpdir(), "depwire-repos");
+      const cloneDir = join15(reposDir, projectName);
       console.error(`Connecting to GitHub repo: ${source}`);
       const git = simpleGit();
-      if (existsSync11(cloneDir)) {
+      if (existsSync13(cloneDir)) {
         console.error(`Repo already cloned at ${cloneDir}, pulling latest changes...`);
         try {
           await git.cwd(cloneDir).pull();
@@ -8190,7 +8719,7 @@ async function connectToRepo(source, subdirectory, state) {
           };
         }
       }
-      projectRoot = subdirectory ? join14(cloneDir, subdirectory) : cloneDir;
+      projectRoot = subdirectory ? join15(cloneDir, subdirectory) : cloneDir;
     } else {
       const validation2 = validateProjectPath(source);
       if (!validation2.valid) {
@@ -8199,13 +8728,13 @@ async function connectToRepo(source, subdirectory, state) {
           message: validation2.error
         };
       }
-      if (!existsSync11(source)) {
+      if (!existsSync13(source)) {
         return {
           error: "Directory not found",
           message: `Directory does not exist: ${source}`
         };
       }
-      projectRoot = subdirectory ? join14(source, subdirectory) : source;
+      projectRoot = subdirectory ? join15(source, subdirectory) : source;
       projectName = basename5(projectRoot);
     }
     const validation = validateProjectPath(projectRoot);
@@ -8215,7 +8744,7 @@ async function connectToRepo(source, subdirectory, state) {
         message: validation.error
       };
     }
-    if (!existsSync11(projectRoot)) {
+    if (!existsSync13(projectRoot)) {
       return {
         error: "Project root not found",
         message: `Directory does not exist: ${projectRoot}`
@@ -8496,24 +9025,24 @@ function getWeekNumber(date) {
 }
 
 // src/temporal/snapshots.ts
-import { writeFileSync as writeFileSync4, readFileSync as readFileSync8, mkdirSync as mkdirSync3, existsSync as existsSync12, readdirSync as readdirSync4 } from "fs";
-import { join as join15 } from "path";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync10, mkdirSync as mkdirSync3, existsSync as existsSync14, readdirSync as readdirSync5 } from "fs";
+import { join as join16 } from "path";
 function saveSnapshot(snapshot, outputDir) {
-  if (!existsSync12(outputDir)) {
+  if (!existsSync14(outputDir)) {
     mkdirSync3(outputDir, { recursive: true });
   }
   const filename = `${snapshot.commitHash.substring(0, 8)}.json`;
-  const filepath = join15(outputDir, filename);
+  const filepath = join16(outputDir, filename);
   writeFileSync4(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
 }
 function loadSnapshot(commitHash, outputDir) {
   const shortHash = commitHash.substring(0, 8);
-  const filepath = join15(outputDir, `${shortHash}.json`);
-  if (!existsSync12(filepath)) {
+  const filepath = join16(outputDir, `${shortHash}.json`);
+  if (!existsSync14(filepath)) {
     return null;
   }
   try {
-    const content = readFileSync8(filepath, "utf-8");
+    const content = readFileSync10(filepath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -9200,7 +9729,7 @@ function handleGetArchitectureSummary(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   const languageBreakdown = {};
   fileSummary.forEach((f) => {
-    const dir = f.filePath.includes("/") ? dirname15(f.filePath) : ".";
+    const dir = f.filePath.includes("/") ? dirname16(f.filePath) : ".";
     if (!dirMap.has(dir)) {
       dirMap.set(dir, { fileCount: 0, symbolCount: 0 });
     }
@@ -9287,8 +9816,8 @@ The server will keep running until you end the MCP session or press Ctrl+C.`;
   };
 }
 async function handleGetProjectDocs(docType, state) {
-  const docsDir = join16(state.projectRoot, ".depwire");
-  if (!existsSync13(docsDir)) {
+  const docsDir = join17(state.projectRoot, ".depwire");
+  if (!existsSync15(docsDir)) {
     const errorMessage = `Project documentation has not been generated yet.
 
 Run \`depwire docs ${state.projectRoot}\` to generate codebase documentation.
@@ -9318,12 +9847,12 @@ Available document types:
       missing.push(doc);
       continue;
     }
-    const filePath = join16(docsDir, metadata.documents[doc].file);
-    if (!existsSync13(filePath)) {
+    const filePath = join17(docsDir, metadata.documents[doc].file);
+    if (!existsSync15(filePath)) {
       missing.push(doc);
       continue;
     }
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     if (docsToReturn.length > 1) {
       output += `
 
@@ -9348,16 +9877,16 @@ Available document types:
 }
 async function handleUpdateProjectDocs(docType, state) {
   const startTime = Date.now();
-  const docsDir = join16(state.projectRoot, ".depwire");
+  const docsDir = join17(state.projectRoot, ".depwire");
   console.error("Regenerating project documentation...");
   const parsedFiles = await parseProject(state.projectRoot);
   const graph = buildGraph(parsedFiles);
   const parseTime = (Date.now() - startTime) / 1e3;
   state.graph = graph;
-  const packageJsonPath = join16(__dirname, "../../package.json");
-  const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
+  const packageJsonPath = join17(__dirname, "../../package.json");
+  const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
   const docsToGenerate = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
-  const docsExist = existsSync13(docsDir);
+  const docsExist = existsSync15(docsDir);
   const result = await generateDocs(graph, state.projectRoot, packageJson.version, parseTime, {
     outputDir: docsDir,
     format: "markdown",
@@ -9416,7 +9945,7 @@ async function handleGetTemporalGraph(state, commits, strategy) {
     }
     const sampledCommits = sampleCommits(allCommits, commits, strategy);
     const snapshots = [];
-    const outputDir = join16(projectRoot, ".depwire", "temporal");
+    const outputDir = join17(projectRoot, ".depwire", "temporal");
     for (const commit of sampledCommits) {
       const existing = loadSnapshot(commit.hash, outputDir);
       if (existing) {