depwire-cli 0.8.0 → 0.9.0

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, and Go
+- 🌍 **Multi-language** — TypeScript, JavaScript, Python, Go, and Rust
 
 ## Why Depwire?
 
@@ -177,6 +177,7 @@ Settings → Features → Experimental → Enable MCP → Add Server:
 | JavaScript | `.js`, `.jsx`, `.mjs`, `.cjs` | ES modules, CommonJS require(), JSX components |
 | Python | `.py` | Imports, classes, decorators, inheritance |
 | Go | `.go` | go.mod resolution, structs, interfaces, methods |
+| Rust | `.rs` | Functions, structs, enums, traits, impl blocks, use declarations |
 
 ## Visualization
 
@@ -612,10 +613,26 @@ See [SECURITY.md](SECURITY.md) for full details.
 
 ## Roadmap
 
-- [ ] PR Impact Visualization (GitHub Action)
-- [ ] Temporal Graph — watch your architecture evolve over git history
+### ✅ Shipped
+- [x] Arc diagram visualization
+- [x] MCP server (15 tools)
+- [x] Multi-language support (TypeScript, JavaScript, Python, Go, Rust)
+- [x] File watching + live refresh
+- [x] Auto-generated documentation (13 documents)
+- [x] Dependency health score (0-100)
+- [x] Dead code detection with confidence scoring
+- [x] Temporal graph — watch your architecture evolve over git history
+- [x] PR Impact GitHub Action (depwire-action v1.0.0)
+- [x] Auto-detect project root (no path needed)
+- [x] WASM migration (Windows support)
+
+### 🔜 Coming Next
+- [ ] New language support (C — community requested)
+- [ ] "What If" simulation — simulate refactors before touching code
 - [ ] Cross-language edge detection (API routes ↔ frontend calls)
-- [ ] Dependency health scoring
+- [ ] Cloud dashboard (first paid feature)
+- [ ] AI-suggested refactors
+- [ ] Natural language architecture queries
 - [ ] VSCode extension
 
 ## Contributing

package/dist/{chunk-IGRFC3MQ.js → chunk-MGMDHXPB.js}

@@ -29,7 +29,8 @@ function scanDirectory(rootDir, baseDir = rootDir) {
         const isJavaScript = entry.endsWith(".js") || entry.endsWith(".jsx") || entry.endsWith(".mjs") || entry.endsWith(".cjs");
         const isPython = entry.endsWith(".py");
         const isGo = entry.endsWith(".go") && !entry.endsWith("_test.go");
-        if (isTypeScript || isJavaScript || isPython || isGo) {
+        const isRust = entry.endsWith(".rs");
+        if (isTypeScript || isJavaScript || isPython || isGo || isRust) {
           files.push(relative(rootDir, fullPath));
         }
       }
@@ -54,6 +55,8 @@ function findProjectRoot(startDir = process.cwd()) {
     // TypeScript
     "go.mod",
     // Go
+    "Cargo.toml",
+    // Rust
     "pyproject.toml",
     // Python (modern)
     "setup.py",
@@ -80,8 +83,8 @@ function findProjectRoot(startDir = process.cwd()) {
 }
 
 // src/parser/index.ts
-import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join7 } from "path";
 
 // src/parser/detect.ts
 import { extname as extname3 } from "path";
@@ -109,7 +112,8 @@ async function initParser() {
     "tsx": "tree-sitter-tsx.wasm",
     "javascript": "tree-sitter-javascript.wasm",
     "python": "tree-sitter-python.wasm",
-    "go": "tree-sitter-go.wasm"
+    "go": "tree-sitter-go.wasm",
+    "rust": "tree-sitter-rust.wasm"
   };
   for (const [name, file] of Object.entries(grammarFiles)) {
     const wasmPath = path.join(grammarsDir, file);
@@ -1972,12 +1976,429 @@ var goParser = {
   parseFile: parseGoFile
 };
 
+// src/parser/rust.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6, dirname as dirname5, relative as relative3 } from "path";
+function parseRustFile(filePath, sourceCode, projectRoot) {
+  const parser = getParser("rust");
+  const tree = parser.parse(sourceCode, null, { bufferSize: 1024 * 1024 });
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    currentModule: []
+  };
+  walkNode5(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode5(node, context) {
+  processNode5(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode5(child, context);
+    }
+  }
+}
+function processNode5(node, context) {
+  const type = node.type;
+  switch (type) {
+    case "function_item":
+      processFunctionItem(node, context);
+      break;
+    case "struct_item":
+      processStructItem(node, context);
+      break;
+    case "enum_item":
+      processEnumItem(node, context);
+      break;
+    case "trait_item":
+      processTraitItem(node, context);
+      break;
+    case "impl_item":
+      processImplItem(node, context);
+      break;
+    case "const_item":
+      processConstItem(node, context);
+      break;
+    case "type_item":
+      processTypeItem(node, context);
+      break;
+    case "use_declaration":
+      processUseDeclaration(node, context);
+      break;
+    case "mod_item":
+      processModItem(node, context);
+      break;
+    case "call_expression":
+      processCallExpression5(node, context);
+      break;
+  }
+}
+function processFunctionItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  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) {
+    walkNode5(body, context);
+  }
+  context.currentScope.pop();
+}
+function processStructItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "class",
+    // Consistent with other parsers
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processEnumItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  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
+  });
+}
+function processTraitItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "interface",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processImplItem(node, context) {
+  const typeNode = node.childForFieldName("type");
+  if (!typeNode) return;
+  const typeName = extractTypeName2(typeNode, context);
+  if (!typeName) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "function_item") {
+      const nameNode = child.childForFieldName("name");
+      if (!nameNode) continue;
+      const name = nodeText4(nameNode, context);
+      const exported = hasVisibility(child, "pub");
+      const symbolId = `${context.filePath}::${typeName}.${name}`;
+      context.symbols.push({
+        id: symbolId,
+        name,
+        kind: "method",
+        filePath: context.filePath,
+        startLine: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1,
+        exported,
+        scope: typeName
+      });
+      context.currentScope.push(`${typeName}.${name}`);
+      const body = child.childForFieldName("body");
+      if (body) {
+        walkNode5(body, context);
+      }
+      context.currentScope.pop();
+    }
+  }
+}
+function processConstItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "constant",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processTypeItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const exported = hasVisibility(node, "pub");
+  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
+  });
+}
+function processUseDeclaration(node, context) {
+  let pathNode = findChildByType5(node, "scoped_identifier");
+  if (!pathNode) {
+    pathNode = findChildByType5(node, "identifier");
+  }
+  if (!pathNode) {
+    pathNode = findChildByType5(node, "use_as_clause");
+    if (pathNode) {
+      pathNode = pathNode.childForFieldName("path");
+    }
+  }
+  if (!pathNode) {
+    return;
+  }
+  let pathText = nodeText4(pathNode, context);
+  if (!pathText.startsWith("crate::") && !pathText.startsWith("super::") && !pathText.startsWith("self::")) {
+    return;
+  }
+  const segments = pathText.split("::");
+  if (segments.length > 1) {
+    segments.pop();
+    pathText = segments.join("::");
+  }
+  const resolvedFiles = resolveRustImport(pathText, context);
+  if (resolvedFiles.length === 0) return;
+  const sourceId = `${context.filePath}::__file__`;
+  for (const targetFile of resolvedFiles) {
+    const targetId = `${targetFile}::__file__`;
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processModItem(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText4(nameNode, context);
+  const body = node.childForFieldName("body");
+  if (!body) {
+    const resolvedFiles = resolveModuleFile(name, context);
+    if (resolvedFiles.length > 0) {
+      const sourceId = `${context.filePath}::__file__`;
+      for (const targetFile of resolvedFiles) {
+        const targetId = `${targetFile}::__file__`;
+        context.edges.push({
+          source: sourceId,
+          target: targetId,
+          kind: "imports",
+          filePath: context.filePath,
+          line: node.startPosition.row + 1
+        });
+      }
+    }
+  }
+  const exported = hasVisibility(node, "pub");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "module",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported
+  });
+}
+function processCallExpression5(node, context) {
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  const calleeName = extractCalleeNameFromNode(functionNode, context);
+  if (!calleeName) return;
+  const builtins = ["println!", "print!", "eprintln!", "eprint!", "format!", "panic!", "assert!", "assert_eq!", "assert_ne!", "vec!"];
+  if (builtins.includes(calleeName)) return;
+  const callerId = getCurrentSymbolId5(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol4(calleeName, context);
+  if (!calleeId) return;
+  context.edges.push({
+    source: callerId,
+    target: calleeId,
+    kind: "calls",
+    filePath: context.filePath,
+    line: node.startPosition.row + 1
+  });
+}
+function resolveRustImport(importPath, context) {
+  if (importPath.startsWith("crate::")) {
+    const relativePath = importPath.replace("crate::", "").replace(/::/g, "/");
+    const possibleFiles = [
+      join6(context.projectRoot, "src", `${relativePath}.rs`),
+      join6(context.projectRoot, "src", relativePath, "mod.rs")
+    ];
+    return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+  }
+  if (importPath.startsWith("super::")) {
+    const currentFileAbs = join6(context.projectRoot, context.filePath);
+    const currentDir = dirname5(currentFileAbs);
+    const parentDir = dirname5(currentDir);
+    const relativePath = importPath.replace("super::", "").replace(/::/g, "/");
+    const possibleFiles = [
+      join6(parentDir, `${relativePath}.rs`),
+      join6(parentDir, relativePath, "mod.rs")
+    ];
+    return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+  }
+  if (importPath.startsWith("self::")) {
+    const currentFileAbs = join6(context.projectRoot, context.filePath);
+    const currentDir = dirname5(currentFileAbs);
+    const relativePath = importPath.replace("self::", "").replace(/::/g, "/");
+    const possibleFiles = [
+      join6(currentDir, `${relativePath}.rs`),
+      join6(currentDir, relativePath, "mod.rs")
+    ];
+    return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+  }
+  return [];
+}
+function resolveModuleFile(moduleName, context) {
+  const currentFileAbs = join6(context.projectRoot, context.filePath);
+  const currentDir = dirname5(currentFileAbs);
+  const possibleFiles = [
+    join6(currentDir, `${moduleName}.rs`),
+    join6(currentDir, moduleName, "mod.rs")
+  ];
+  return possibleFiles.filter((f) => existsSync6(f)).map((f) => relative3(context.projectRoot, f));
+}
+function hasVisibility(node, visibility) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "visibility_modifier") {
+      const text = nodeText4(child, { sourceCode: node.text });
+      return text === visibility;
+    }
+  }
+  return false;
+}
+function extractTypeName2(typeNode, context) {
+  if (typeNode.type === "type_identifier") {
+    return nodeText4(typeNode, context);
+  }
+  if (typeNode.type === "generic_type") {
+    const typeId = findChildByType5(typeNode, "type_identifier");
+    if (typeId) {
+      return nodeText4(typeId, context);
+    }
+  }
+  for (let i = 0; i < typeNode.childCount; i++) {
+    const child = typeNode.child(i);
+    if (child && child.type === "type_identifier") {
+      return nodeText4(child, context);
+    }
+  }
+  return null;
+}
+function extractCalleeNameFromNode(functionNode, context) {
+  if (functionNode.type === "identifier") {
+    return nodeText4(functionNode, context);
+  }
+  if (functionNode.type === "field_expression") {
+    const field = functionNode.childForFieldName("field");
+    if (field) {
+      return nodeText4(field, context);
+    }
+  }
+  if (functionNode.type === "scoped_identifier") {
+    const name = functionNode.childForFieldName("name");
+    if (name) {
+      return nodeText4(name, context);
+    }
+  }
+  return null;
+}
+function resolveSymbol4(name, context) {
+  const currentFileId = context.filePath;
+  const symbol = context.symbols.find((s) => s.name === name && s.filePath === currentFileId);
+  if (symbol) {
+    return symbol.id;
+  }
+  if (context.currentScope.length > 0) {
+    for (let i = context.currentScope.length - 1; i >= 0; i--) {
+      const scopedId = `${currentFileId}::${context.currentScope[i]}.${name}`;
+      const scopedSymbol = context.symbols.find((s) => s.id === scopedId);
+      if (scopedSymbol) {
+        return scopedId;
+      }
+    }
+  }
+  return null;
+}
+function findChildByType5(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 nodeText4(node, context) {
+  return context.sourceCode.slice(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId5(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope.join(".")}`;
+}
+var rustParser = {
+  language: "rust",
+  extensions: [".rs"],
+  parseFile: parseRustFile
+};
+
 // src/parser/detect.ts
 var parsers = [
   typescriptParser,
   pythonParser,
   javascriptParser,
-  goParser
+  goParser,
+  rustParser
 ];
 function getParserForFile(filePath) {
   const ext = extname3(filePath).toLowerCase();
@@ -2007,7 +2428,7 @@ async function parseProject(projectRoot, options) {
   let errorFiles = 0;
   for (const file of files) {
     try {
-      const fullPath = join6(projectRoot, file);
+      const fullPath = join7(projectRoot, file);
       if (options?.exclude) {
         const shouldExclude2 = options.exclude.some(
           (pattern) => minimatch(file, pattern, { matchBase: true })
@@ -2033,7 +2454,7 @@ async function parseProject(projectRoot, options) {
         skippedFiles++;
         continue;
       }
-      const sourceCode = readFileSync3(fullPath, "utf-8");
+      const sourceCode = readFileSync4(fullPath, "utf-8");
       const parsed = parser.parseFile(file, sourceCode, projectRoot);
       parsedFiles.push(parsed);
     } catch (err) {
@@ -2089,6 +2510,18 @@ function buildGraph(parsedFiles) {
           exported: false
         });
       }
+      if (edge.target.endsWith("::__file__") && !fileNodes.has(edge.target)) {
+        fileNodes.add(edge.target);
+        const filePath = edge.target.replace("::__file__", "");
+        graph.addNode(edge.target, {
+          name: "__file__",
+          kind: "import",
+          filePath,
+          startLine: 1,
+          endLine: 1,
+          exported: false
+        });
+      }
     }
   }
   for (const file of parsedFiles) {
@@ -2414,7 +2847,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"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2422,7 +2855,7 @@ function watchProject(projectRoot, callbacks) {
     callbacks.onFileChanged(relativePath);
   });
   watcher.on("add", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2430,7 +2863,7 @@ function watchProject(projectRoot, callbacks) {
     callbacks.onFileAdded(relativePath);
   });
   watcher.on("unlink", (absolutePath) => {
-    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go"];
+    const validExtensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2460,10 +2893,10 @@ function watchProject(projectRoot, callbacks) {
 import express from "express";
 import open from "open";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname5, join as join7 } from "path";
+import { dirname as dirname6, join as join8 } from "path";
 import { WebSocketServer } from "ws";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname5(__filename);
+var __dirname2 = dirname6(__filename);
 var activeServer = null;
 async function findAvailablePort(startPort, maxAttempts = 10) {
   const net = await import("net");
@@ -2501,7 +2934,7 @@ async function startVizServer(initialVizData, graph, projectRoot, port = 3333, s
   const availablePort = await findAvailablePort(port);
   const app = express();
   let vizData = initialVizData;
-  const publicDir = join7(__dirname2, "viz", "public");
+  const publicDir = join8(__dirname2, "viz", "public");
   app.use(express.static(publicDir));
   app.get("/api/graph", (req, res) => {
     res.json(vizData);
@@ -2617,7 +3050,7 @@ function isProjectLoaded(state) {
 }
 
 // src/graph/updater.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function removeFileFromGraph(graph, filePath) {
   const nodesToRemove = [];
   graph.forEachNode((node, attrs) => {
@@ -2661,7 +3094,7 @@ function addFileToGraph(graph, parsedFile) {
 }
 async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
   removeFileFromGraph(graph, relativeFilePath);
-  const absolutePath = join8(projectRoot, relativeFilePath);
+  const absolutePath = join9(projectRoot, relativeFilePath);
   try {
     const parsedFile = parseTypeScriptFile(absolutePath, relativeFilePath);
     addFileToGraph(graph, parsedFile);
@@ -2671,7 +3104,7 @@ async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
 }
 
 // src/health/metrics.ts
-import { dirname as dirname6 } from "path";
+import { dirname as dirname7 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -2704,8 +3137,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 = dirname6(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname6(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname7(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname7(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -2752,8 +3185,8 @@ function calculateCohesionScore(graph) {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
     if (sourceAttrs.filePath !== targetAttrs.filePath) {
-      const sourceDir = dirname6(sourceAttrs.filePath);
-      const targetDir = dirname6(targetAttrs.filePath);
+      const sourceDir = dirname7(sourceAttrs.filePath);
+      const targetDir = dirname7(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -3035,8 +3468,8 @@ function calculateDepthScore(graph) {
 }
 
 // src/health/index.ts
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync6, mkdirSync } from "fs";
-import { join as join9, dirname as dirname7 } from "path";
+import { readFileSync as readFileSync5, writeFileSync, existsSync as existsSync7, mkdirSync } from "fs";
+import { join as join10, dirname as dirname8 } from "path";
 function calculateHealthScore(graph, projectRoot) {
   const coupling = calculateCouplingScore(graph);
   const cohesion = calculateCohesionScore(graph);
@@ -3135,7 +3568,7 @@ function getHealthTrend(projectRoot, currentScore) {
   }
 }
 function saveHealthHistory(projectRoot, report) {
-  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
+  const historyFile = join10(projectRoot, ".depwire", "health-history.json");
   const entry = {
     timestamp: report.timestamp,
     score: report.overall,
@@ -3147,9 +3580,9 @@ function saveHealthHistory(projectRoot, report) {
     }))
   };
   let history = [];
-  if (existsSync6(historyFile)) {
+  if (existsSync7(historyFile)) {
     try {
-      const content = readFileSync4(historyFile, "utf-8");
+      const content = readFileSync5(historyFile, "utf-8");
       history = JSON.parse(content);
     } catch {
     }
@@ -3158,16 +3591,16 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname7(historyFile), { recursive: true });
+  mkdirSync(dirname8(historyFile), { recursive: true });
   writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
 }
 function loadHealthHistory(projectRoot) {
-  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
-  if (!existsSync6(historyFile)) {
+  const historyFile = join10(projectRoot, ".depwire", "health-history.json");
+  if (!existsSync7(historyFile)) {
     return [];
   }
   try {
-    const content = readFileSync4(historyFile, "utf-8");
+    const content = readFileSync5(historyFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -3473,11 +3906,11 @@ function filterByConfidence(symbols, minConfidence) {
 }
 
 // src/docs/generator.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync9 } from "fs";
-import { join as join12 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync10 } from "fs";
+import { join as join13 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -3628,7 +4061,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname8(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -3653,7 +4086,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname8(attrs.filePath);
+    const dir = dirname9(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -3668,8 +4101,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname8(sourceAttrs.filePath);
-    const targetDir = dirname8(targetAttrs.filePath);
+    const sourceDir = dirname9(sourceAttrs.filePath);
+    const targetDir = dirname9(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4650,7 +5083,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -4709,7 +5142,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 = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -4813,7 +5246,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(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, {
@@ -4828,7 +5261,7 @@ function getDirectoryStats2(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());
     }
@@ -4843,8 +5276,8 @@ function getDirectoryStats2(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 });
@@ -4925,7 +5358,7 @@ function detectClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4979,8 +5412,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname9(files[0]);
-  if (files.every((f) => dirname9(f) === commonDir)) {
+  const commonDir = dirname10(files[0]);
+  if (files.every((f) => dirname10(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -5038,7 +5471,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname10, basename as basename3 } from "path";
+import { dirname as dirname11, basename as basename3 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5142,7 +5575,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname10(file.filePath);
+    const dir = dirname11(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -5785,7 +6218,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename4, dirname as dirname11 } from "path";
+import { basename as basename4, dirname as dirname12 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5814,7 +6247,7 @@ function getFileCount8(graph) {
 }
 function isTestFile3(filePath) {
   const fileName = basename4(filePath).toLowerCase();
-  const dirPath = dirname11(filePath).toLowerCase();
+  const dirPath = dirname12(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -5873,12 +6306,12 @@ function generateTestFileInventory(graph) {
 }
 function matchTestToSource(testFile) {
   const testFileName = basename4(testFile);
-  const testDir = dirname11(testFile);
+  const testDir = dirname12(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 = dirname11(testDir);
+    const parentDir = dirname12(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -6075,7 +6508,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname11(sourceFile).split("/")[0];
+    const dir = dirname12(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -6098,7 +6531,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -6379,7 +6812,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname12(attrs.filePath);
+    const dir = dirname13(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -6461,7 +6894,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname13 } from "path";
+import { dirname as dirname14 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6599,7 +7032,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 = dirname13(info.filePath);
+    const dir = dirname14(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -6810,8 +7243,8 @@ function getTopLevelDir2(filePath) {
 }
 
 // src/docs/status.ts
-import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
+import { join as join11 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6844,12 +7277,12 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const fullPath = join10(projectRoot, filePath);
-  if (!existsSync7(fullPath)) {
+  const fullPath = join11(projectRoot, filePath);
+  if (!existsSync8(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync5(fullPath, "utf-8");
+    const content = readFileSync6(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -7411,15 +7844,15 @@ function generateConfidenceSection(title, description, symbols, projectRoot) {
 }
 
 // src/docs/metadata.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
+import { join as join12 } from "path";
 function loadMetadata(outputDir) {
-  const metadataPath = join11(outputDir, "metadata.json");
-  if (!existsSync8(metadataPath)) {
+  const metadataPath = join12(outputDir, "metadata.json");
+  if (!existsSync9(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync6(metadataPath, "utf-8");
+    const content = readFileSync7(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -7427,7 +7860,7 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const metadataPath = join11(outputDir, "metadata.json");
+  const metadataPath = join12(outputDir, "metadata.json");
   writeFileSync2(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
 }
 function createMetadata(version, projectPath, fileCount, symbolCount, edgeCount, docTypes) {
@@ -7470,7 +7903,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync9(options.outputDir)) {
+    if (!existsSync10(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -7509,7 +7942,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 = join12(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join13(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -7520,7 +7953,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 = join12(options.outputDir, "CONVENTIONS.md");
+          const filePath = join13(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -7531,7 +7964,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 = join12(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join13(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -7542,7 +7975,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 = join12(options.outputDir, "ONBOARDING.md");
+          const filePath = join13(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -7553,7 +7986,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 = join12(options.outputDir, "FILES.md");
+          const filePath = join13(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -7564,7 +7997,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 = join12(options.outputDir, "API_SURFACE.md");
+          const filePath = join13(options.outputDir, "API_SURFACE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
@@ -7575,7 +8008,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 = join12(options.outputDir, "ERRORS.md");
+          const filePath = join13(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -7586,7 +8019,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 = join12(options.outputDir, "TESTS.md");
+          const filePath = join13(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -7597,7 +8030,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 = join12(options.outputDir, "HISTORY.md");
+          const filePath = join13(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -7608,7 +8041,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 = join12(options.outputDir, "CURRENT.md");
+          const filePath = join13(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -7619,7 +8052,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 = join12(options.outputDir, "STATUS.md");
+          const filePath = join13(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -7630,7 +8063,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 = join12(options.outputDir, "HEALTH.md");
+          const filePath = join13(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
@@ -7641,7 +8074,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 = join12(options.outputDir, "DEAD_CODE.md");
+          const filePath = join13(options.outputDir, "DEAD_CODE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEAD_CODE.md");
         } catch (err) {
@@ -7689,13 +8122,13 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/mcp/tools.ts
-import { dirname as dirname14, join as join15 } from "path";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname15, join as join16 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
 
 // src/mcp/connect.ts
 import simpleGit from "simple-git";
-import { existsSync as existsSync10 } from "fs";
-import { join as join13, basename as basename5, resolve as resolve2 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join14, basename as basename5, resolve as resolve2 } from "path";
 import { tmpdir, homedir } from "os";
 function validateProjectPath(source) {
   const resolved = resolve2(source);
@@ -7708,11 +8141,11 @@ function validateProjectPath(source) {
     "/boot",
     "/proc",
     "/sys",
-    join13(homedir(), ".ssh"),
-    join13(homedir(), ".gnupg"),
-    join13(homedir(), ".aws"),
-    join13(homedir(), ".config"),
-    join13(homedir(), ".env")
+    join14(homedir(), ".ssh"),
+    join14(homedir(), ".gnupg"),
+    join14(homedir(), ".aws"),
+    join14(homedir(), ".config"),
+    join14(homedir(), ".env")
   ];
   for (const blocked of blockedPaths) {
     if (resolved.startsWith(blocked)) {
@@ -7735,11 +8168,11 @@ async function connectToRepo(source, subdirectory, state) {
         };
       }
       projectName = match[1];
-      const reposDir = join13(tmpdir(), "depwire-repos");
-      const cloneDir = join13(reposDir, projectName);
+      const reposDir = join14(tmpdir(), "depwire-repos");
+      const cloneDir = join14(reposDir, projectName);
       console.error(`Connecting to GitHub repo: ${source}`);
       const git = simpleGit();
-      if (existsSync10(cloneDir)) {
+      if (existsSync11(cloneDir)) {
         console.error(`Repo already cloned at ${cloneDir}, pulling latest changes...`);
         try {
           await git.cwd(cloneDir).pull();
@@ -7757,7 +8190,7 @@ async function connectToRepo(source, subdirectory, state) {
           };
         }
       }
-      projectRoot = subdirectory ? join13(cloneDir, subdirectory) : cloneDir;
+      projectRoot = subdirectory ? join14(cloneDir, subdirectory) : cloneDir;
     } else {
       const validation2 = validateProjectPath(source);
       if (!validation2.valid) {
@@ -7766,13 +8199,13 @@ async function connectToRepo(source, subdirectory, state) {
           message: validation2.error
         };
       }
-      if (!existsSync10(source)) {
+      if (!existsSync11(source)) {
         return {
           error: "Directory not found",
           message: `Directory does not exist: ${source}`
         };
       }
-      projectRoot = subdirectory ? join13(source, subdirectory) : source;
+      projectRoot = subdirectory ? join14(source, subdirectory) : source;
       projectName = basename5(projectRoot);
     }
     const validation = validateProjectPath(projectRoot);
@@ -7782,7 +8215,7 @@ async function connectToRepo(source, subdirectory, state) {
         message: validation.error
       };
     }
-    if (!existsSync10(projectRoot)) {
+    if (!existsSync11(projectRoot)) {
       return {
         error: "Project root not found",
         message: `Directory does not exist: ${projectRoot}`
@@ -8063,24 +8496,24 @@ function getWeekNumber(date) {
 }
 
 // src/temporal/snapshots.ts
-import { writeFileSync as writeFileSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync3, existsSync as existsSync11, readdirSync as readdirSync3 } from "fs";
-import { join as join14 } from "path";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync8, mkdirSync as mkdirSync3, existsSync as existsSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join15 } from "path";
 function saveSnapshot(snapshot, outputDir) {
-  if (!existsSync11(outputDir)) {
+  if (!existsSync12(outputDir)) {
     mkdirSync3(outputDir, { recursive: true });
   }
   const filename = `${snapshot.commitHash.substring(0, 8)}.json`;
-  const filepath = join14(outputDir, filename);
+  const filepath = join15(outputDir, filename);
   writeFileSync4(filepath, JSON.stringify(snapshot, null, 2), "utf-8");
 }
 function loadSnapshot(commitHash, outputDir) {
   const shortHash = commitHash.substring(0, 8);
-  const filepath = join14(outputDir, `${shortHash}.json`);
-  if (!existsSync11(filepath)) {
+  const filepath = join15(outputDir, `${shortHash}.json`);
+  if (!existsSync12(filepath)) {
     return null;
   }
   try {
-    const content = readFileSync7(filepath, "utf-8");
+    const content = readFileSync8(filepath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -8767,7 +9200,7 @@ function handleGetArchitectureSummary(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   const languageBreakdown = {};
   fileSummary.forEach((f) => {
-    const dir = f.filePath.includes("/") ? dirname14(f.filePath) : ".";
+    const dir = f.filePath.includes("/") ? dirname15(f.filePath) : ".";
     if (!dirMap.has(dir)) {
       dirMap.set(dir, { fileCount: 0, symbolCount: 0 });
     }
@@ -8854,8 +9287,8 @@ The server will keep running until you end the MCP session or press Ctrl+C.`;
   };
 }
 async function handleGetProjectDocs(docType, state) {
-  const docsDir = join15(state.projectRoot, ".depwire");
-  if (!existsSync12(docsDir)) {
+  const docsDir = join16(state.projectRoot, ".depwire");
+  if (!existsSync13(docsDir)) {
     const errorMessage = `Project documentation has not been generated yet.
 
 Run \`depwire docs ${state.projectRoot}\` to generate codebase documentation.
@@ -8885,12 +9318,12 @@ Available document types:
       missing.push(doc);
       continue;
     }
-    const filePath = join15(docsDir, metadata.documents[doc].file);
-    if (!existsSync12(filePath)) {
+    const filePath = join16(docsDir, metadata.documents[doc].file);
+    if (!existsSync13(filePath)) {
       missing.push(doc);
       continue;
     }
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     if (docsToReturn.length > 1) {
       output += `
 
@@ -8915,16 +9348,16 @@ Available document types:
 }
 async function handleUpdateProjectDocs(docType, state) {
   const startTime = Date.now();
-  const docsDir = join15(state.projectRoot, ".depwire");
+  const docsDir = join16(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 = join15(__dirname, "../../package.json");
-  const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
+  const packageJsonPath = join16(__dirname, "../../package.json");
+  const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
   const docsToGenerate = docType === "all" ? ["architecture", "conventions", "dependencies", "onboarding"] : [docType];
-  const docsExist = existsSync12(docsDir);
+  const docsExist = existsSync13(docsDir);
   const result = await generateDocs(graph, state.projectRoot, packageJson.version, parseTime, {
     outputDir: docsDir,
     format: "markdown",
@@ -8983,7 +9416,7 @@ async function handleGetTemporalGraph(state, commits, strategy) {
     }
     const sampledCommits = sampleCommits(allCommits, commits, strategy);
     const snapshots = [];
-    const outputDir = join15(projectRoot, ".depwire", "temporal");
+    const outputDir = join16(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-IGRFC3MQ.js";
+} from "./chunk-MGMDHXPB.js";
 
 // src/index.ts
 import { Command } from "commander";

package/dist/mcpb-entry.js

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

package/package.json

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