depwire-cli 0.9.0 → 0.9.1

package/README.md

@@ -39,7 +39,7 @@ Depwire analyzes codebases to build a cross-reference graph showing how every fi
 - 🔍 **Impact analysis** — "What breaks if I rename this function?" answered precisely
 - 🧹 **Dead code detection** — Find symbols that are defined but never referenced, categorized by confidence level
 - 👀 **Live updates** — Graph stays current as you edit code
-- 🌍 **Multi-language** — TypeScript, JavaScript, Python, Go, and Rust
+- 🌍 **Multi-language** — TypeScript, JavaScript, Python, Go, Rust, and C
 
 ## Why Depwire?
 
@@ -178,6 +178,7 @@ Settings → Features → Experimental → Enable MCP → Add Server:
 | Python | `.py` | Imports, classes, decorators, inheritance |
 | Go | `.go` | go.mod resolution, structs, interfaces, methods |
 | Rust | `.rs` | Functions, structs, enums, traits, impl blocks, use declarations |
+| C | `.c`, `.h` | Functions, structs, enums, typedefs, macros, #include directives |
 
 ## Visualization
 
@@ -616,7 +617,7 @@ See [SECURITY.md](SECURITY.md) for full details.
 ### ✅ Shipped
 - [x] Arc diagram visualization
 - [x] MCP server (15 tools)
-- [x] Multi-language support (TypeScript, JavaScript, Python, Go, Rust)
+- [x] Multi-language support (TypeScript, JavaScript, Python, Go, Rust, C)
 - [x] File watching + live refresh
 - [x] Auto-generated documentation (13 documents)
 - [x] Dependency health score (0-100)

package/dist/{chunk-MGMDHXPB.js → chunk-UPAZDLUB.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 [];
@@ -3906,11 +4284,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 existsSync11 } 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 +4439,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 +4464,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 +4479,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 +5461,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 +5520,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 +5624,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 +5639,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 +5654,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 +5736,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 +5790,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 +5849,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 +5953,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 +6596,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 +6625,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 +6684,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 +6886,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 +6909,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 +7190,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 +7272,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 +7410,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 +7621,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 readFileSync7, existsSync as existsSync9 } 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 +7655,12 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const fullPath = join11(projectRoot, filePath);
-  if (!existsSync8(fullPath)) {
+  const fullPath = join12(projectRoot, filePath);
+  if (!existsSync9(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync6(fullPath, "utf-8");
+    const content = readFileSync7(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -7844,15 +8222,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 existsSync10, readFileSync as readFileSync8, 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 (!existsSync10(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync7(metadataPath, "utf-8");
+    const content = readFileSync8(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -7860,7 +8238,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 +8281,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync10(options.outputDir)) {
+    if (!existsSync11(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -7942,7 +8320,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 +8331,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 +8342,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 +8353,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 +8364,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 +8375,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 +8386,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 +8397,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 +8408,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 +8419,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 +8430,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 +8441,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 +8452,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 +8500,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 existsSync14, readFileSync as readFileSync10 } 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 existsSync12 } 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 +8519,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 +8546,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 (existsSync12(cloneDir)) {
         console.error(`Repo already cloned at ${cloneDir}, pulling latest changes...`);
         try {
           await git.cwd(cloneDir).pull();
@@ -8190,7 +8568,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 +8577,13 @@ async function connectToRepo(source, subdirectory, state) {
           message: validation2.error
         };
       }
-      if (!existsSync11(source)) {
+      if (!existsSync12(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 +8593,7 @@ async function connectToRepo(source, subdirectory, state) {
         message: validation.error
       };
     }
-    if (!existsSync11(projectRoot)) {
+    if (!existsSync12(projectRoot)) {
       return {
         error: "Project root not found",
         message: `Directory does not exist: ${projectRoot}`
@@ -8496,24 +8874,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 readFileSync9, mkdirSync as mkdirSync3, existsSync as existsSync13, readdirSync as readdirSync5 } from "fs";
+import { join as join16 } from "path";
 function saveSnapshot(snapshot, outputDir) {
-  if (!existsSync12(outputDir)) {
+  if (!existsSync13(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 (!existsSync13(filepath)) {
     return null;
   }
   try {
-    const content = readFileSync8(filepath, "utf-8");
+    const content = readFileSync9(filepath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -9200,7 +9578,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 +9665,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 (!existsSync14(docsDir)) {
     const errorMessage = `Project documentation has not been generated yet.
 
 Run \`depwire docs ${state.projectRoot}\` to generate codebase documentation.
@@ -9318,12 +9696,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 (!existsSync14(filePath)) {
       missing.push(doc);
       continue;
     }
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     if (docsToReturn.length > 1) {
       output += `
 
@@ -9348,16 +9726,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(readFileSync10(packageJsonPath, "utf-8"));
   const docsToGenerate = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
-  const docsExist = existsSync13(docsDir);
+  const docsExist = existsSync14(docsDir);
   const result = await generateDocs(graph, state.projectRoot, packageJson.version, parseTime, {
     outputDir: docsDir,
     format: "markdown",
@@ -9416,7 +9794,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) {

package/dist/index.js

@@ -27,7 +27,7 @@ import {
   stashChanges,
   updateFileInGraph,
   watchProject
-} from "./chunk-MGMDHXPB.js";
+} from "./chunk-UPAZDLUB.js";
 
 // src/index.ts
 import { Command } from "commander";

package/dist/mcpb-entry.js

@@ -6,7 +6,7 @@ import {
   startMcpServer,
   updateFileInGraph,
   watchProject
-} from "./chunk-MGMDHXPB.js";
+} from "./chunk-UPAZDLUB.js";
 
 // src/mcpb-entry.ts
 import { resolve } from "path";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "depwire-cli",
-  "version": "0.9.0",
-  "description": "Code cross-reference visualization and AI context engine for TypeScript, JavaScript, Python, Go, and Rust. Zero native dependencies — works on Windows, macOS, and Linux.",
+  "version": "0.9.1",
+  "description": "Code cross-reference visualization and AI context engine for TypeScript, JavaScript, Python, Go, Rust, and C. Zero native dependencies — works on Windows, macOS, and Linux.",
   "type": "module",
   "bin": {
     "depwire": "dist/index.js"