depwire-cli 0.8.0 → 0.9.1

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

@@ -29,7 +29,9 @@ 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");
+        const isC = entry.endsWith(".c") || entry.endsWith(".h");
+        if (isTypeScript || isJavaScript || isPython || isGo || isRust || isC) {
           files.push(relative(rootDir, fullPath));
         }
       }
@@ -54,10 +56,18 @@ function findProjectRoot(startDir = process.cwd()) {
     // TypeScript
     "go.mod",
     // Go
+    "Cargo.toml",
+    // Rust
     "pyproject.toml",
     // 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
   ];
@@ -80,8 +90,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 readFileSync5, statSync as statSync2 } from "fs";
+import { join as join8 } from "path";
 
 // src/parser/detect.ts
 import { extname as extname3 } from "path";
@@ -109,7 +119,9 @@ 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",
+    "c": "tree-sitter-c.wasm"
   };
   for (const [name, file] of Object.entries(grammarFiles)) {
     const wasmPath = path.join(grammarsDir, file);
@@ -1972,12 +1984,799 @@ 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/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
+  goParser,
+  rustParser,
+  cParser
 ];
 function getParserForFile(filePath) {
   const ext = extname3(filePath).toLowerCase();
@@ -2007,7 +2806,7 @@ async function parseProject(projectRoot, options) {
   let errorFiles = 0;
   for (const file of files) {
     try {
-      const fullPath = join6(projectRoot, file);
+      const fullPath = join8(projectRoot, file);
       if (options?.exclude) {
         const shouldExclude2 = options.exclude.some(
           (pattern) => minimatch(file, pattern, { matchBase: true })
@@ -2033,7 +2832,7 @@ async function parseProject(projectRoot, options) {
         skippedFiles++;
         continue;
       }
-      const sourceCode = readFileSync3(fullPath, "utf-8");
+      const sourceCode = readFileSync5(fullPath, "utf-8");
       const parsed = parser.parseFile(file, sourceCode, projectRoot);
       parsedFiles.push(parsed);
     } catch (err) {
@@ -2089,6 +2888,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 +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"];
+    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 + "/", "");
@@ -2422,7 +3233,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", ".c", ".h"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2430,7 +3241,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", ".c", ".h"];
     if (!validExtensions.some((ext) => absolutePath.endsWith(ext))) return;
     if (absolutePath.endsWith("_test.go")) return;
     const relativePath = absolutePath.replace(projectRoot + "/", "");
@@ -2448,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;
 }
@@ -2460,10 +3271,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 dirname7, join as join9 } from "path";
 import { WebSocketServer } from "ws";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname5(__filename);
+var __dirname2 = dirname7(__filename);
 var activeServer = null;
 async function findAvailablePort(startPort, maxAttempts = 10) {
   const net = await import("net");
@@ -2501,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 = join7(__dirname2, "viz", "public");
+  const publicDir = join9(__dirname2, "viz", "public");
   app.use(express.static(publicDir));
   app.get("/api/graph", (req, res) => {
     res.json(vizData);
@@ -2617,7 +3428,7 @@ function isProjectLoaded(state) {
 }
 
 // src/graph/updater.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 function removeFileFromGraph(graph, filePath) {
   const nodesToRemove = [];
   graph.forEachNode((node, attrs) => {
@@ -2661,7 +3472,7 @@ function addFileToGraph(graph, parsedFile) {
 }
 async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
   removeFileFromGraph(graph, relativeFilePath);
-  const absolutePath = join8(projectRoot, relativeFilePath);
+  const absolutePath = join10(projectRoot, relativeFilePath);
   try {
     const parsedFile = parseTypeScriptFile(absolutePath, relativeFilePath);
     addFileToGraph(graph, parsedFile);
@@ -2671,7 +3482,7 @@ async function updateFileInGraph(graph, projectRoot, relativeFilePath) {
 }
 
 // src/health/metrics.ts
-import { dirname as dirname6 } from "path";
+import { dirname as dirname8 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -2704,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 = dirname6(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname6(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname8(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname8(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -2752,8 +3563,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 = dirname8(sourceAttrs.filePath);
+      const targetDir = dirname8(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -3035,8 +3846,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 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);
@@ -3135,7 +3946,7 @@ function getHealthTrend(projectRoot, currentScore) {
   }
 }
 function saveHealthHistory(projectRoot, report) {
-  const historyFile = join9(projectRoot, ".depwire", "health-history.json");
+  const historyFile = join11(projectRoot, ".depwire", "health-history.json");
   const entry = {
     timestamp: report.timestamp,
     score: report.overall,
@@ -3147,9 +3958,9 @@ function saveHealthHistory(projectRoot, report) {
     }))
   };
   let history = [];
-  if (existsSync6(historyFile)) {
+  if (existsSync8(historyFile)) {
     try {
-      const content = readFileSync4(historyFile, "utf-8");
+      const content = readFileSync6(historyFile, "utf-8");
       history = JSON.parse(content);
     } catch {
     }
@@ -3158,16 +3969,16 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname7(historyFile), { recursive: true });
+  mkdirSync(dirname9(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 = join11(projectRoot, ".depwire", "health-history.json");
+  if (!existsSync8(historyFile)) {
     return [];
   }
   try {
-    const content = readFileSync4(historyFile, "utf-8");
+    const content = readFileSync6(historyFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -3473,11 +4284,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 existsSync11 } from "fs";
+import { join as join14 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname8 } from "path";
+import { dirname as dirname10 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -3628,7 +4439,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname8(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -3653,7 +4464,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname8(attrs.filePath);
+    const dir = dirname10(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -3668,8 +4479,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 = dirname10(sourceAttrs.filePath);
+    const targetDir = dirname10(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4650,7 +5461,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname9 } from "path";
+import { dirname as dirname11 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -4709,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 = dirname9(attrs.filePath);
+    const dir = dirname11(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -4813,7 +5624,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname11(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -4828,7 +5639,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname9(attrs.filePath);
+    const dir = dirname11(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4843,8 +5654,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 = dirname11(sourceAttrs.filePath);
+    const targetDir = dirname11(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4925,7 +5736,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 = dirname11(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -4979,8 +5790,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 = dirname11(files[0]);
+  if (files.every((f) => dirname11(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -5038,7 +5849,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname10, 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];
@@ -5142,7 +5953,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 = dirname12(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -5785,7 +6596,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename4, dirname as dirname11 } 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];
@@ -5814,7 +6625,7 @@ function getFileCount8(graph) {
 }
 function isTestFile3(filePath) {
   const fileName = basename4(filePath).toLowerCase();
-  const dirPath = dirname11(filePath).toLowerCase();
+  const dirPath = dirname13(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -5873,12 +6684,12 @@ function generateTestFileInventory(graph) {
 }
 function matchTestToSource(testFile) {
   const testFileName = basename4(testFile);
-  const testDir = dirname11(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 = dirname11(testDir);
+    const parentDir = dirname13(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -6075,7 +6886,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname11(sourceFile).split("/")[0];
+    const dir = dirname13(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -6098,7 +6909,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname12 } from "path";
+import { dirname as dirname14 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -6379,7 +7190,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 = dirname14(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -6461,7 +7272,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname13 } from "path";
+import { dirname as dirname15 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6599,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 = dirname13(info.filePath);
+    const dir = dirname15(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -6810,8 +7621,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 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];
@@ -6844,12 +7655,12 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const fullPath = join10(projectRoot, filePath);
-  if (!existsSync7(fullPath)) {
+  const fullPath = join12(projectRoot, filePath);
+  if (!existsSync9(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync5(fullPath, "utf-8");
+    const content = readFileSync7(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -7411,15 +8222,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 existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
+import { join as join13 } from "path";
 function loadMetadata(outputDir) {
-  const metadataPath = join11(outputDir, "metadata.json");
-  if (!existsSync8(metadataPath)) {
+  const metadataPath = join13(outputDir, "metadata.json");
+  if (!existsSync10(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync6(metadataPath, "utf-8");
+    const content = readFileSync8(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -7427,7 +8238,7 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const metadataPath = join11(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) {
@@ -7470,7 +8281,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync9(options.outputDir)) {
+    if (!existsSync11(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -7509,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 = join12(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join14(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -7520,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 = join12(options.outputDir, "CONVENTIONS.md");
+          const filePath = join14(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -7531,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 = join12(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join14(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -7542,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 = join12(options.outputDir, "ONBOARDING.md");
+          const filePath = join14(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -7553,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 = join12(options.outputDir, "FILES.md");
+          const filePath = join14(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -7564,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 = join12(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) {
@@ -7575,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 = join12(options.outputDir, "ERRORS.md");
+          const filePath = join14(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -7586,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 = join12(options.outputDir, "TESTS.md");
+          const filePath = join14(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -7597,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 = join12(options.outputDir, "HISTORY.md");
+          const filePath = join14(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -7608,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 = join12(options.outputDir, "CURRENT.md");
+          const filePath = join14(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -7619,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 = join12(options.outputDir, "STATUS.md");
+          const filePath = join14(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -7630,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 = join12(options.outputDir, "HEALTH.md");
+          const filePath = join14(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
@@ -7641,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 = join12(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) {
@@ -7689,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 dirname14, join as join15 } from "path";
-import { existsSync as existsSync12, readFileSync as readFileSync8 } 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 existsSync10 } from "fs";
-import { join as join13, 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);
@@ -7708,11 +8519,11 @@ function validateProjectPath(source) {
     "/boot",
     "/proc",
     "/sys",
-    join13(homedir(), ".ssh"),
-    join13(homedir(), ".gnupg"),
-    join13(homedir(), ".aws"),
-    join13(homedir(), ".config"),
-    join13(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)) {
@@ -7735,11 +8546,11 @@ async function connectToRepo(source, subdirectory, state) {
         };
       }
       projectName = match[1];
-      const reposDir = join13(tmpdir(), "depwire-repos");
-      const cloneDir = join13(reposDir, projectName);
+      const reposDir = join15(tmpdir(), "depwire-repos");
+      const cloneDir = join15(reposDir, projectName);
       console.error(`Connecting to GitHub repo: ${source}`);
       const git = simpleGit();
-      if (existsSync10(cloneDir)) {
+      if (existsSync12(cloneDir)) {
         console.error(`Repo already cloned at ${cloneDir}, pulling latest changes...`);
         try {
           await git.cwd(cloneDir).pull();
@@ -7757,7 +8568,7 @@ async function connectToRepo(source, subdirectory, state) {
           };
         }
       }
-      projectRoot = subdirectory ? join13(cloneDir, subdirectory) : cloneDir;
+      projectRoot = subdirectory ? join15(cloneDir, subdirectory) : cloneDir;
     } else {
       const validation2 = validateProjectPath(source);
       if (!validation2.valid) {
@@ -7766,13 +8577,13 @@ async function connectToRepo(source, subdirectory, state) {
           message: validation2.error
         };
       }
-      if (!existsSync10(source)) {
+      if (!existsSync12(source)) {
         return {
           error: "Directory not found",
           message: `Directory does not exist: ${source}`
         };
       }
-      projectRoot = subdirectory ? join13(source, subdirectory) : source;
+      projectRoot = subdirectory ? join15(source, subdirectory) : source;
       projectName = basename5(projectRoot);
     }
     const validation = validateProjectPath(projectRoot);
@@ -7782,7 +8593,7 @@ async function connectToRepo(source, subdirectory, state) {
         message: validation.error
       };
     }
-    if (!existsSync10(projectRoot)) {
+    if (!existsSync12(projectRoot)) {
       return {
         error: "Project root not found",
         message: `Directory does not exist: ${projectRoot}`
@@ -8063,24 +8874,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 readFileSync9, mkdirSync as mkdirSync3, existsSync as existsSync13, readdirSync as readdirSync5 } from "fs";
+import { join as join16 } from "path";
 function saveSnapshot(snapshot, outputDir) {
-  if (!existsSync11(outputDir)) {
+  if (!existsSync13(outputDir)) {
     mkdirSync3(outputDir, { recursive: true });
   }
   const filename = `${snapshot.commitHash.substring(0, 8)}.json`;
-  const filepath = join14(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 = join14(outputDir, `${shortHash}.json`);
-  if (!existsSync11(filepath)) {
+  const filepath = join16(outputDir, `${shortHash}.json`);
+  if (!existsSync13(filepath)) {
     return null;
   }
   try {
-    const content = readFileSync7(filepath, "utf-8");
+    const content = readFileSync9(filepath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -8767,7 +9578,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("/") ? dirname16(f.filePath) : ".";
     if (!dirMap.has(dir)) {
       dirMap.set(dir, { fileCount: 0, symbolCount: 0 });
     }
@@ -8854,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 = join15(state.projectRoot, ".depwire");
-  if (!existsSync12(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.
@@ -8885,12 +9696,12 @@ Available document types:
       missing.push(doc);
       continue;
     }
-    const filePath = join15(docsDir, metadata.documents[doc].file);
-    if (!existsSync12(filePath)) {
+    const filePath = join17(docsDir, metadata.documents[doc].file);
+    if (!existsSync14(filePath)) {
       missing.push(doc);
       continue;
     }
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     if (docsToReturn.length > 1) {
       output += `
 
@@ -8915,16 +9726,16 @@ Available document types:
 }
 async function handleUpdateProjectDocs(docType, state) {
   const startTime = Date.now();
-  const docsDir = join15(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 = join15(__dirname, "../../package.json");
-  const packageJson = JSON.parse(readFileSync8(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 = existsSync12(docsDir);
+  const docsExist = existsSync14(docsDir);
   const result = await generateDocs(graph, state.projectRoot, packageJson.version, parseTime, {
     outputDir: docsDir,
     format: "markdown",
@@ -8983,7 +9794,7 @@ async function handleGetTemporalGraph(state, commits, strategy) {
     }
     const sampledCommits = sampleCommits(allCommits, commits, strategy);
     const snapshots = [];
-    const outputDir = join15(projectRoot, ".depwire", "temporal");
+    const outputDir = join17(projectRoot, ".depwire", "temporal");
     for (const commit of sampledCommits) {
       const existing = loadSnapshot(commit.hash, outputDir);
       if (existing) {