depwire-cli 1.0.1 → 1.0.4

package/dist/{chunk-LV32EDYQ.js → chunk-7HLVFIVW.js}

@@ -31,10 +31,12 @@ function scanDirectory(rootDir, baseDir = rootDir) {
         const isPython = entry.endsWith(".py");
         const isGo = entry.endsWith(".go") && !entry.endsWith("_test.go");
         const isRust = entry.endsWith(".rs");
-        const isC = entry.endsWith(".c") || entry.endsWith(".h");
+        const isC = entry.endsWith(".c");
+        const isCpp = entry.endsWith(".cpp") || entry.endsWith(".cc") || entry.endsWith(".cxx") || entry.endsWith(".c++") || entry.endsWith(".hpp") || entry.endsWith(".hh") || entry.endsWith(".hxx") || entry.endsWith(".h++") || entry.endsWith(".h") || entry.endsWith(".inl") || entry.endsWith(".ipp");
         const isCSharp = entry.endsWith(".cs") || entry.endsWith(".csx") || entry.endsWith(".csproj");
         const isJava = entry.endsWith(".java") || entry === "pom.xml" || entry === "build.gradle" || entry === "build.gradle.kts";
-        if (isTypeScript || isJavaScript || isPython || isGo || isRust || isC || isCSharp || isJava) {
+        const isCppBuild = entry === "CMakeLists.txt" || entry === "conanfile.txt" || entry === "vcpkg.json";
+        if (isTypeScript || isJavaScript || isPython || isGo || isRust || isC || isCpp || isCSharp || isJava || isCppBuild) {
           files.push(relative(rootDir, fullPath));
         }
       }
@@ -109,11 +111,11 @@ function findProjectRoot(startDir = process.cwd()) {
 }
 
 // src/parser/index.ts
-import { readFileSync as readFileSync7, statSync as statSync4 } from "fs";
-import { join as join10, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { join as join11, resolve as resolve5 } from "path";
 
 // src/parser/detect.ts
-import { extname as extname5, basename as basename3 } from "path";
+import { extname as extname6, basename as basename4 } from "path";
 
 // src/parser/wasm-init.ts
 import { Parser, Language } from "web-tree-sitter";
@@ -142,7 +144,8 @@ async function initParser() {
     "rust": "tree-sitter-rust.wasm",
     "c": "tree-sitter-c.wasm",
     "c_sharp": "tree-sitter-c_sharp.wasm",
-    "java": "tree-sitter-java.wasm"
+    "java": "tree-sitter-java.wasm",
+    "cpp": "tree-sitter-cpp.wasm"
   };
   for (const [name, file] of Object.entries(grammarFiles)) {
     const wasmPath = path.join(grammarsDir, file);
@@ -2786,7 +2789,7 @@ function getCurrentSymbolId6(context) {
 }
 var cParser = {
   name: "c",
-  extensions: [".c", ".h"],
+  extensions: [".c"],
   parseFile: parseCFile
 };
 
@@ -4096,6 +4099,834 @@ var javaParser = {
   parseFile: parseJavaFile
 };
 
+// src/parser/cpp.ts
+import { dirname as dirname9, join as join10, relative as relative5, basename as basename3 } from "path";
+import { existsSync as existsSync10 } from "fs";
+function parseCppFile(filePath, sourceCode, projectRoot) {
+  if (basename3(filePath) === "CMakeLists.txt") {
+    return parseCMakeLists(filePath, sourceCode, projectRoot);
+  }
+  if (basename3(filePath) === "conanfile.txt") {
+    return parseConanfileTxt(filePath, sourceCode, projectRoot);
+  }
+  if (basename3(filePath) === "vcpkg.json") {
+    return parseVcpkgJson(filePath, sourceCode, projectRoot);
+  }
+  const parser = getParser("cpp");
+  const tree = parser.parse(sourceCode, null, { bufferSize: 1024 * 1024 });
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    currentClass: null,
+    currentNamespace: null,
+    imports: /* @__PURE__ */ new Map(),
+    isBuildFile: false
+  };
+  walkNode9(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode9(node, context) {
+  processNode9(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode9(child, context);
+    }
+  }
+}
+function processNode9(node, context) {
+  switch (node.type) {
+    case "namespace_definition":
+      processNamespaceDefinition(node, context);
+      break;
+    case "class_specifier":
+      processClassSpecifier(node, context);
+      break;
+    case "struct_specifier":
+      processStructSpecifier2(node, context);
+      break;
+    case "union_specifier":
+      processUnionSpecifier(node, context);
+      break;
+    case "enum_specifier":
+      processEnumSpecifier2(node, context);
+      break;
+    case "function_definition":
+      processFunctionDefinition3(node, context);
+      break;
+    case "declaration":
+      processDeclaration2(node, context);
+      break;
+    case "alias_declaration":
+      processAliasDeclaration(node, context);
+      break;
+    case "type_definition":
+      processTypeDefinition2(node, context);
+      break;
+    case "preproc_include":
+      processIncludeDirective2(node, context);
+      break;
+    case "preproc_def":
+    case "preproc_function_def":
+      processMacroDefinition2(node, context);
+      break;
+    case "template_declaration":
+      processTemplateDeclaration(node, context);
+      break;
+    case "call_expression":
+      processCallExpression9(node, context);
+      break;
+    case "static_assert_declaration":
+      processStaticAssert(node, context);
+      break;
+  }
+}
+function processNamespaceDefinition(node, context) {
+  const nameNode = node.childForFieldName("name");
+  const name = nameNode ? nodeText8(nameNode, context) : "<anonymous>";
+  if (name !== "<anonymous>") {
+    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: true
+    });
+  }
+  const oldNamespace = context.currentNamespace;
+  context.currentNamespace = name !== "<anonymous>" ? name : oldNamespace;
+  if (name !== "<anonymous>") context.currentScope.push(name);
+  const body = node.childForFieldName("body") || findChildByType9(node, "declaration_list");
+  if (body) {
+    walkNode9(body, context);
+  }
+  if (name !== "<anonymous>") context.currentScope.pop();
+  context.currentNamespace = oldNamespace;
+}
+function processClassSpecifier(node, context) {
+  processTypeSpecifier(node, context, "class");
+}
+function processStructSpecifier2(node, context) {
+  processTypeSpecifier(node, context, "class");
+}
+function processUnionSpecifier(node, context) {
+  processTypeSpecifier(node, context, "class");
+}
+function processTypeSpecifier(node, context, kind) {
+  let nameNode = node.childForFieldName("name");
+  let name = null;
+  if (nameNode) {
+    name = nodeText8(nameNode, context);
+    const angleBracketIdx = name.indexOf("<");
+    if (angleBracketIdx > 0) {
+      name = name.substring(0, angleBracketIdx);
+    }
+  }
+  if (!name) {
+    const parent = node.parent;
+    if (parent && parent.type === "type_definition") {
+      const typedefDecl = parent.childForFieldName("declarator");
+      if (typedefDecl) {
+        name = extractIdentifierFromDeclarator2(typedefDecl, context);
+      }
+    }
+  }
+  if (!name) return;
+  const exported = true;
+  const scope = context.currentClass || void 0;
+  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,
+    scope
+  });
+  const baseClause = findChildByType9(node, "base_class_clause");
+  if (baseClause) {
+    processBaseClassClause(baseClause, symbolId, context);
+  }
+  const oldClass = context.currentClass;
+  context.currentClass = name;
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body") || findChildByType9(node, "field_declaration_list");
+  if (body) {
+    walkNode9(body, context);
+  }
+  context.currentScope.pop();
+  context.currentClass = oldClass;
+}
+function processBaseClassClause(node, sourceId, context) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "base_class_specifier" || child.type === "type_identifier" || child.type === "qualified_identifier" || child.type === "template_type") {
+      const baseName = extractTypeName4(child, context);
+      if (baseName) {
+        const baseId = resolveSymbol8(baseName, context);
+        if (baseId) {
+          context.edges.push({
+            source: sourceId,
+            target: baseId,
+            kind: "inherits",
+            filePath: context.filePath,
+            line: child.startPosition.row + 1
+          });
+        }
+      }
+    }
+  }
+}
+function processEnumSpecifier2(node, context) {
+  let nameNode = node.childForFieldName("name");
+  let name = null;
+  if (nameNode) {
+    name = nodeText8(nameNode, context);
+  }
+  if (!name) {
+    const parent = node.parent;
+    if (parent && parent.type === "type_definition") {
+      const typedefDecl = parent.childForFieldName("declarator");
+      if (typedefDecl) {
+        name = extractIdentifierFromDeclarator2(typedefDecl, 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
+  });
+  const body = node.childForFieldName("body") || findChildByType9(node, "enumerator_list");
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child && child.type === "enumerator") {
+        const constNameNode = child.childForFieldName("name");
+        if (!constNameNode) continue;
+        const constName = nodeText8(constNameNode, context);
+        const constId = `${context.filePath}::${name}.${constName}`;
+        context.symbols.push({
+          id: constId,
+          name: constName,
+          kind: "constant",
+          filePath: context.filePath,
+          startLine: child.startPosition.row + 1,
+          endLine: child.endPosition.row + 1,
+          exported: true,
+          scope: name
+        });
+      }
+    }
+  }
+}
+function processFunctionDefinition3(node, context) {
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return;
+  const nameNode = extractFunctionName2(declarator);
+  if (!nameNode) return;
+  let name = nodeText8(nameNode, context);
+  if (name === "operator") {
+    const fullText = nodeText8(declarator, context);
+    const opMatch = fullText.match(/operator\s*([^\s(]+)/);
+    if (opMatch) {
+      name = `operator${opMatch[1]}`;
+    }
+  }
+  const fullDeclText = nodeText8(declarator, context);
+  if (fullDeclText.includes("~")) {
+    const tildeMatch = fullDeclText.match(/~\s*(\w+)/);
+    if (tildeMatch) {
+      name = `~${tildeMatch[1]}`;
+    }
+  }
+  const isConstructor = context.currentClass !== null && name === context.currentClass;
+  const isDestructor = name.startsWith("~");
+  const isStatic = hasStorageClass2(node, "static", context);
+  const exported = !isStatic;
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: context.currentClass ? "method" : "function",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported,
+    scope
+  });
+  const scopeName = scope ? `${scope}.${name}` : name;
+  context.currentScope.push(scopeName);
+  const body = node.childForFieldName("body");
+  if (body) {
+    walkNode9(body, context);
+  }
+  context.currentScope.pop();
+}
+function processDeclaration2(node, context) {
+  if (context.currentClass) {
+    processFieldDeclaration2(node, context);
+    return;
+  }
+  const parent = node.parent;
+  if (!parent || parent.type !== "translation_unit" && parent.type !== "declaration_list") {
+    return;
+  }
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return;
+  if (containsType(declarator, "function_declarator")) {
+    return;
+  }
+  const name = extractIdentifierFromDeclarator2(declarator, context);
+  if (!name) return;
+  const isStatic = hasStorageClass2(node, "static", context);
+  const isConst = nodeText8(node, context).includes("const");
+  const symbolId = `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: isConst ? "constant" : "variable",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: !isStatic
+  });
+}
+function processFieldDeclaration2(node, context) {
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return;
+  if (containsType(declarator, "function_declarator")) {
+    const fnName = extractFunctionName2(declarator);
+    if (fnName) {
+      let name2 = nodeText8(fnName, context);
+      const scope2 = context.currentClass || void 0;
+      const symbolId2 = scope2 ? `${context.filePath}::${scope2}.${name2}` : `${context.filePath}::${name2}`;
+      if (!context.symbols.find((s) => s.id === symbolId2)) {
+        const exported = !hasAccessSpecifier(node, "private", context);
+        context.symbols.push({
+          id: symbolId2,
+          name: name2,
+          kind: "method",
+          filePath: context.filePath,
+          startLine: node.startPosition.row + 1,
+          endLine: node.endPosition.row + 1,
+          exported,
+          scope: scope2
+        });
+      }
+    }
+    return;
+  }
+  const name = extractIdentifierFromDeclarator2(declarator, context);
+  if (!name) return;
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  const isConst = nodeText8(node, context).includes("const");
+  const isStatic = nodeText8(node, context).includes("static");
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: isConst && isStatic ? "constant" : "property",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: !hasAccessSpecifier(node, "private", context),
+    scope
+  });
+}
+function processAliasDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText8(nameNode, context);
+  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 processTypeDefinition2(node, context) {
+  const typeNode = node.childForFieldName("type");
+  if (!typeNode) return;
+  if (typeNode.type === "struct_specifier" || typeNode.type === "enum_specifier" || typeNode.type === "union_specifier") {
+    return;
+  }
+  const declarator = node.childForFieldName("declarator");
+  if (!declarator) return;
+  const name = extractIdentifierFromDeclarator2(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 processTemplateDeclaration(node, context) {
+}
+function processStaticAssert(node, context) {
+  const symbolId = `${context.filePath}::static_assert:${node.startPosition.row + 1}`;
+  context.symbols.push({
+    id: symbolId,
+    name: "static_assert",
+    kind: "constant",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: false
+  });
+}
+function processMacroDefinition2(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText8(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 processIncludeDirective2(node, context) {
+  const pathNode = node.childForFieldName("path");
+  if (!pathNode) return;
+  const pathText = nodeText8(pathNode, context);
+  const isLocalInclude = pathText.startsWith('"') && pathText.endsWith('"');
+  if (!isLocalInclude) {
+    const includeName = pathText.replace(/[<>"]/g, "");
+    const symbolId = `${context.filePath}::include:${includeName}`;
+    context.symbols.push({
+      id: symbolId,
+      name: includeName,
+      kind: "import",
+      filePath: context.filePath,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      exported: false
+    });
+    return;
+  }
+  const includePath = pathText.slice(1, -1);
+  const resolvedFiles = resolveIncludePath2(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 processCallExpression9(node, context) {
+  if (context.currentScope.length === 0) return;
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  let calleeName = null;
+  if (functionNode.type === "identifier") {
+    calleeName = nodeText8(functionNode, context);
+  } else if (functionNode.type === "field_expression" || functionNode.type === "qualified_identifier") {
+    const nameNode = functionNode.childForFieldName("name") || functionNode.childForFieldName("field");
+    if (nameNode) {
+      calleeName = nodeText8(nameNode, context);
+    }
+  } else if (functionNode.type === "template_function") {
+    const nameNode = functionNode.childForFieldName("name");
+    if (nameNode) {
+      calleeName = nodeText8(nameNode, context);
+    }
+  }
+  if (!calleeName) return;
+  const builtins = /* @__PURE__ */ new Set([
+    "printf",
+    "scanf",
+    "malloc",
+    "free",
+    "memcpy",
+    "strlen",
+    "strcmp",
+    "strcpy",
+    "strcat",
+    "cout",
+    "cin",
+    "cerr",
+    "endl",
+    "make_shared",
+    "make_unique",
+    "make_pair",
+    "make_tuple",
+    "move",
+    "forward",
+    "swap",
+    "begin",
+    "end",
+    "size",
+    "empty",
+    "push_back",
+    "emplace_back",
+    "insert",
+    "erase",
+    "find",
+    "sort",
+    "transform",
+    "for_each",
+    "accumulate",
+    "static_cast",
+    "dynamic_cast",
+    "reinterpret_cast",
+    "const_cast"
+  ]);
+  if (builtins.has(calleeName)) return;
+  const callerId = getCurrentSymbolId9(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol8(calleeName, context);
+  if (calleeId) {
+    context.edges.push({
+      source: callerId,
+      target: calleeId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function parseCMakeLists(filePath, sourceCode, projectRoot) {
+  const symbols = [];
+  const edges = [];
+  const lines = sourceCode.split("\n");
+  const projectName = basename3(dirname9(join10(projectRoot, filePath)));
+  symbols.push({
+    id: `${filePath}::${projectName}`,
+    name: projectName,
+    kind: "module",
+    filePath,
+    startLine: 1,
+    endLine: lines.length,
+    exported: true
+  });
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const lineNum = i + 1;
+    const findPkgMatch = line.match(/find_package\s*\(\s*(\w+)/i);
+    if (findPkgMatch) {
+      symbols.push({
+        id: `${filePath}::dep:${findPkgMatch[1]}`,
+        name: findPkgMatch[1],
+        kind: "import",
+        filePath,
+        startLine: lineNum,
+        endLine: lineNum,
+        exported: false
+      });
+    }
+    const linkLibsMatch = line.match(/target_link_libraries\s*\(\s*\w+\s+(?:PRIVATE|PUBLIC|INTERFACE)?\s*(.*)\)/i);
+    if (linkLibsMatch) {
+      const libs = linkLibsMatch[1].trim().split(/\s+/).filter((l) => l && !["PRIVATE", "PUBLIC", "INTERFACE"].includes(l));
+      for (const lib of libs) {
+        symbols.push({
+          id: `${filePath}::dep:${lib}`,
+          name: lib,
+          kind: "import",
+          filePath,
+          startLine: lineNum,
+          endLine: lineNum,
+          exported: false
+        });
+      }
+    }
+    const addSubdirMatch = line.match(/add_subdirectory\s*\(\s*([^\s)]+)/i);
+    if (addSubdirMatch) {
+      const subdir = addSubdirMatch[1];
+      const cmakeDir = dirname9(join10(projectRoot, filePath));
+      const subdirCMake = join10(relative5(projectRoot, cmakeDir), subdir, "CMakeLists.txt");
+      if (existsSync10(join10(projectRoot, subdirCMake))) {
+        edges.push({
+          source: `${filePath}::__file__`,
+          target: `${subdirCMake}::__file__`,
+          kind: "imports",
+          filePath,
+          line: lineNum
+        });
+      }
+    }
+    const projectMatch = line.match(/project\s*\(\s*(\w+)/i);
+    if (projectMatch) {
+      symbols.push({
+        id: `${filePath}::project:${projectMatch[1]}`,
+        name: projectMatch[1],
+        kind: "module",
+        filePath,
+        startLine: lineNum,
+        endLine: lineNum,
+        exported: true
+      });
+    }
+  }
+  return { filePath, symbols, edges };
+}
+function parseConanfileTxt(filePath, sourceCode, _projectRoot) {
+  const symbols = [];
+  const lines = sourceCode.split("\n");
+  let inRequires = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const lineNum = i + 1;
+    if (line === "[requires]") {
+      inRequires = true;
+      continue;
+    }
+    if (line.startsWith("[") && line.endsWith("]")) {
+      inRequires = false;
+      continue;
+    }
+    if (inRequires && line.length > 0) {
+      symbols.push({
+        id: `${filePath}::dep:${line}`,
+        name: line,
+        kind: "import",
+        filePath,
+        startLine: lineNum,
+        endLine: lineNum,
+        exported: false
+      });
+    }
+  }
+  return { filePath, symbols, edges: [] };
+}
+function parseVcpkgJson(filePath, sourceCode, _projectRoot) {
+  const symbols = [];
+  try {
+    const vcpkg = JSON.parse(sourceCode);
+    if (vcpkg.dependencies && Array.isArray(vcpkg.dependencies)) {
+      for (let i = 0; i < vcpkg.dependencies.length; i++) {
+        const dep = vcpkg.dependencies[i];
+        const name = typeof dep === "string" ? dep : dep.name || "";
+        if (name) {
+          symbols.push({
+            id: `${filePath}::dep:${name}`,
+            name,
+            kind: "import",
+            filePath,
+            startLine: 1,
+            endLine: 1,
+            exported: false
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return { filePath, symbols, edges: [] };
+}
+function resolveIncludePath2(includePath, currentFile, projectRoot) {
+  const currentFileAbs = join10(projectRoot, currentFile);
+  const currentDir = dirname9(currentFileAbs);
+  const possibleFiles = [
+    join10(currentDir, includePath),
+    join10(projectRoot, includePath),
+    join10(projectRoot, "include", includePath),
+    join10(projectRoot, "src", includePath)
+  ];
+  const resolvedFiles = [];
+  for (const absPath of possibleFiles) {
+    if (existsSync10(absPath)) {
+      const relPath = relative5(projectRoot, absPath);
+      if (!resolvedFiles.includes(relPath)) {
+        resolvedFiles.push(relPath);
+      }
+    }
+  }
+  return resolvedFiles;
+}
+function resolveSymbol8(name, context) {
+  if (context.imports.has(name)) {
+    return context.imports.get(name) || null;
+  }
+  const currentFileId = `${context.filePath}::${name}`;
+  if (context.symbols.find((s) => s.id === currentFileId)) {
+    return currentFileId;
+  }
+  if (context.currentClass) {
+    const classMethodId = `${context.filePath}::${context.currentClass}.${name}`;
+    if (context.symbols.find((s) => s.id === classMethodId)) {
+      return classMethodId;
+    }
+  }
+  return null;
+}
+function hasStorageClass2(node, className, context) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "storage_class_specifier") {
+      if (nodeText8(child, context) === className) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasAccessSpecifier(node, specifier, context) {
+  const parent = node.parent;
+  if (!parent) return false;
+  let lastAccess = "";
+  for (let i = 0; i < parent.childCount; i++) {
+    const child = parent.child(i);
+    if (!child) continue;
+    if (child.type === "access_specifier") {
+      lastAccess = nodeText8(child, context).replace(":", "").trim();
+    }
+    if (child === node) break;
+  }
+  return lastAccess === specifier;
+}
+function extractFunctionName2(declarator) {
+  if (declarator.type === "identifier") {
+    return declarator;
+  }
+  if (declarator.type === "function_declarator") {
+    const innerDeclarator = declarator.childForFieldName("declarator");
+    if (innerDeclarator) {
+      return extractFunctionName2(innerDeclarator);
+    }
+  }
+  if (declarator.type === "pointer_declarator" || declarator.type === "reference_declarator") {
+    const innerDeclarator = declarator.childForFieldName("declarator");
+    if (innerDeclarator) {
+      return extractFunctionName2(innerDeclarator);
+    }
+  }
+  if (declarator.type === "qualified_identifier" || declarator.type === "template_function") {
+    const nameNode = declarator.childForFieldName("name");
+    if (nameNode) {
+      return extractFunctionName2(nameNode);
+    }
+  }
+  if (declarator.type === "destructor_name") {
+    return declarator;
+  }
+  if (declarator.type === "operator_name") {
+    return declarator;
+  }
+  for (let i = 0; i < declarator.childCount; i++) {
+    const child = declarator.child(i);
+    if (child && child.type === "identifier") {
+      return child;
+    }
+  }
+  return null;
+}
+function extractIdentifierFromDeclarator2(declarator, context) {
+  if (declarator.type === "identifier") {
+    return nodeText8(declarator, context);
+  }
+  if (declarator.type === "type_identifier") {
+    return nodeText8(declarator, context);
+  }
+  const identifierNode = findChildByType9(declarator, "identifier");
+  if (identifierNode) {
+    return nodeText8(identifierNode, context);
+  }
+  const typeIdNode = findChildByType9(declarator, "type_identifier");
+  if (typeIdNode) {
+    return nodeText8(typeIdNode, context);
+  }
+  for (let i = 0; i < declarator.childCount; i++) {
+    const child = declarator.child(i);
+    if (child) {
+      const name = extractIdentifierFromDeclarator2(child, context);
+      if (name) return name;
+    }
+  }
+  return null;
+}
+function extractTypeName4(node, context) {
+  const text = nodeText8(node, context).trim();
+  if (!text || text === ":" || text === ",") return null;
+  const accessStripped = text.replace(/^(?:public|protected|private|virtual)\s+/g, "");
+  const angleBracketIdx = accessStripped.indexOf("<");
+  const name = angleBracketIdx > 0 ? accessStripped.substring(0, angleBracketIdx) : accessStripped;
+  const colonIdx = name.lastIndexOf("::");
+  return colonIdx >= 0 ? name.substring(colonIdx + 2) : name;
+}
+function containsType(node, type) {
+  if (node.type === type) return true;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && containsType(child, type)) return true;
+  }
+  return false;
+}
+function findChildByType9(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 nodeText8(node, context) {
+  return context.sourceCode.substring(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId9(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope[context.currentScope.length - 1]}`;
+}
+var cppParser = {
+  name: "cpp",
+  extensions: [
+    ".cpp",
+    ".cc",
+    ".cxx",
+    ".c++",
+    ".hpp",
+    ".hh",
+    ".hxx",
+    ".h++",
+    ".inl",
+    ".ipp",
+    "CMakeLists.txt",
+    "conanfile.txt",
+    "vcpkg.json"
+  ],
+  parseFile: parseCppFile
+};
+
 // src/parser/detect.ts
 var parsers = [
   typescriptParser,
@@ -4105,11 +4936,22 @@ var parsers = [
   rustParser,
   cParser,
   csharpParser,
-  javaParser
+  javaParser,
+  cppParser
 ];
-function getParserForFile(filePath) {
-  const ext = extname5(filePath).toLowerCase();
-  const fileName = basename3(filePath);
+var CPP_KEYWORDS = /\b(?:class|namespace|template|public:|private:|protected:|virtual|nullptr|constexpr|auto\s+\w+\s*=|using\s+\w+\s*=|static_cast|dynamic_cast|reinterpret_cast|const_cast|noexcept|override|final|decltype|concept|requires|co_await|co_yield|co_return|std::)\b/;
+function getParserForFile(filePath, content) {
+  const ext = extname6(filePath).toLowerCase();
+  const fileName = basename4(filePath);
+  if (ext === ".h" && content) {
+    if (CPP_KEYWORDS.test(content)) {
+      return cppParser;
+    }
+    return cParser;
+  }
+  if (ext === ".h") {
+    return cParser;
+  }
   return parsers.find((p) => p.extensions.includes(ext) || p.extensions.includes(fileName)) || null;
 }
 
@@ -4118,7 +4960,7 @@ import { minimatch } from "minimatch";
 var MAX_FILE_SIZE = 1e6;
 function shouldParseFile(fullPath) {
   try {
-    const stats = statSync4(fullPath);
+    const stats = statSync5(fullPath);
     if (stats.size > MAX_FILE_SIZE) {
       console.error(`[Parser] Skipping ${fullPath} \u2014 file too large (${(stats.size / 1024).toFixed(0)}KB)`);
       return false;
@@ -4136,7 +4978,7 @@ async function parseProject(projectRoot, options) {
   let errorFiles = 0;
   for (const file of files) {
     try {
-      const fullPath = join10(projectRoot, file);
+      const fullPath = join11(projectRoot, file);
       if (!resolve5(fullPath).startsWith(resolve5(projectRoot))) {
         skippedFiles++;
         continue;
@@ -4160,13 +5002,13 @@ async function parseProject(projectRoot, options) {
       if (options?.verbose) {
         console.error(`[Parser] Parsing: ${file}`);
       }
-      const parser = getParserForFile(file);
+      const sourceCode = readFileSync8(fullPath, "utf-8");
+      const parser = getParserForFile(file, sourceCode);
       if (!parser) {
         console.error(`No parser found for file: ${file}`);
         skippedFiles++;
         continue;
       }
-      const sourceCode = readFileSync7(fullPath, "utf-8");
       const parsed = parser.parseFile(file, sourceCode, projectRoot);
       parsedFiles.push(parsed);
     } catch (err) {
@@ -4189,8 +5031,8 @@ async function parseProject(projectRoot, options) {
 }
 
 // src/cross-language/detectors/rest-api.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { join as join11, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join12, resolve as resolve6 } from "path";
 function getLanguage(filePath) {
   if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "typescript";
   if (filePath.endsWith(".js") || filePath.endsWith(".jsx") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs")) return "javascript";
@@ -4198,6 +5040,7 @@ function getLanguage(filePath) {
   if (filePath.endsWith(".go")) return "go";
   if (filePath.endsWith(".cs") || filePath.endsWith(".csx")) return "csharp";
   if (filePath.endsWith(".java")) return "java";
+  if (filePath.endsWith(".cpp") || filePath.endsWith(".cc") || filePath.endsWith(".cxx") || filePath.endsWith(".c++") || filePath.endsWith(".hpp") || filePath.endsWith(".hh") || filePath.endsWith(".hxx") || filePath.endsWith(".h++") || filePath.endsWith(".h") || filePath.endsWith(".inl") || filePath.endsWith(".ipp")) return "cpp";
   return "unknown";
 }
 function normalizePath(routePath) {
@@ -4451,6 +5294,72 @@ function extractRouteDefinitions(source, filePath) {
         });
       }
     }
+    if (lang === "cpp") {
+      const crowMatch = line.match(/CROW_ROUTE\s*\(\s*\w+\s*,\s*"([^"]+)"/);
+      if (crowMatch) {
+        const path6 = crowMatch[1];
+        if (path6.startsWith("/")) {
+          const methodsMatch = line.match(/methods\s*\(\s*"([^"]+)"_method/);
+          const method = methodsMatch ? methodsMatch[1].toUpperCase() : "ANY";
+          routes.push({
+            method,
+            path: path6,
+            normalizedPath: normalizePath(path6),
+            file: filePath,
+            line: i + 1
+          });
+        }
+      }
+      const drogonMatch = line.match(/ADD_METHOD_TO\s*\(\s*[^,]+,\s*"([^"]+)"\s*,\s*(\w+)/);
+      if (drogonMatch) {
+        const path6 = drogonMatch[1].startsWith("/") ? drogonMatch[1] : "/" + drogonMatch[1];
+        routes.push({
+          method: drogonMatch[2].toUpperCase(),
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const pathAddMatch = line.match(/PATH_ADD\s*\(\s*"([^"]+)"\s*,\s*(\w+)/);
+      if (pathAddMatch) {
+        const path6 = pathAddMatch[1].startsWith("/") ? pathAddMatch[1] : "/" + pathAddMatch[1];
+        routes.push({
+          method: pathAddMatch[2].toUpperCase(),
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const pistacheMatch = line.match(/router\s*\.\s*(get|post|put|del|patch)\s*\(\s*"([^"]+)"/i);
+      if (pistacheMatch) {
+        const method = pistacheMatch[1].toUpperCase() === "DEL" ? "DELETE" : pistacheMatch[1].toUpperCase();
+        const path6 = pistacheMatch[2];
+        if (path6.startsWith("/")) {
+          routes.push({
+            method,
+            path: path6,
+            normalizedPath: normalizePath(path6),
+            file: filePath,
+            line: i + 1
+          });
+        }
+      }
+      const httplibMatch = line.match(/(?:svr|server)\s*\.\s*(Get|Post|Put|Delete|Patch)\s*\(\s*"([^"]+)"/);
+      if (httplibMatch) {
+        const path6 = httplibMatch[2];
+        if (path6.startsWith("/")) {
+          routes.push({
+            method: httplibMatch[1].toUpperCase(),
+            path: path6,
+            normalizedPath: normalizePath(path6),
+            file: filePath,
+            line: i + 1
+          });
+        }
+      }
+    }
   }
   return routes;
 }
@@ -4499,11 +5408,11 @@ function detectRestApiEdges(files, projectRoot) {
   const allCalls = [];
   const allRoutes = [];
   for (const file of files) {
-    const fullPath = join11(projectRoot, file.filePath);
+    const fullPath = join12(projectRoot, file.filePath);
     if (!resolve6(fullPath).startsWith(resolve6(projectRoot))) continue;
     let source;
     try {
-      source = readFileSync8(fullPath, "utf-8");
+      source = readFileSync9(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -4539,8 +5448,8 @@ function detectRestApiEdges(files, projectRoot) {
 }
 
 // src/cross-language/detectors/subprocess.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { join as join12, resolve as resolve7, basename as basename4 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { join as join13, resolve as resolve7, basename as basename5 } from "path";
 var SCRIPT_EXTENSIONS = [".py", ".js", ".ts", ".go", ".rs"];
 function getLanguage2(filePath) {
   if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "typescript";
@@ -4639,16 +5548,16 @@ function detectSubprocessEdges(files, projectRoot) {
   const knownFiles = new Set(files.map((f) => f.filePath));
   const basenameMap = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const base = basename4(f.filePath);
+    const base = basename5(f.filePath);
     if (!basenameMap.has(base)) basenameMap.set(base, []);
     basenameMap.get(base).push(f.filePath);
   }
   for (const file of files) {
-    const fullPath = join12(projectRoot, file.filePath);
+    const fullPath = join13(projectRoot, file.filePath);
     if (!resolve7(fullPath).startsWith(resolve7(projectRoot))) continue;
     let source;
     try {
-      source = readFileSync9(fullPath, "utf-8");
+      source = readFileSync10(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -4660,7 +5569,7 @@ function detectSubprocessEdges(files, projectRoot) {
         targetFile = call.calledFile;
         confidence = "high";
       } else {
-        const base = basename4(call.calledFile);
+        const base = basename5(call.calledFile);
         const candidates = basenameMap.get(base);
         if (candidates && candidates.length > 0) {
           const exactCandidate = candidates.find((c) => c.endsWith(call.calledFile));
@@ -5039,7 +5948,7 @@ function getArchitectureSummary(graph) {
 }
 
 // src/health/metrics.ts
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -5072,8 +5981,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 = dirname9(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname9(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname10(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname10(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -5120,8 +6029,8 @@ function calculateCohesionScore(graph) {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
     if (sourceAttrs.filePath !== targetAttrs.filePath) {
-      const sourceDir = dirname9(sourceAttrs.filePath);
-      const targetDir = dirname9(targetAttrs.filePath);
+      const sourceDir = dirname10(sourceAttrs.filePath);
+      const targetDir = dirname10(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -5403,8 +6312,8 @@ function calculateDepthScore(graph) {
 }
 
 // src/health/index.ts
-import { readFileSync as readFileSync10, writeFileSync, existsSync as existsSync10, mkdirSync } from "fs";
-import { dirname as dirname10, resolve as resolve8 } from "path";
+import { readFileSync as readFileSync11, writeFileSync, existsSync as existsSync11, mkdirSync } from "fs";
+import { dirname as dirname11, resolve as resolve8 } from "path";
 function calculateHealthScore(graph, projectRoot) {
   const coupling = calculateCouplingScore(graph);
   const cohesion = calculateCohesionScore(graph);
@@ -5519,10 +6428,10 @@ function saveHealthHistory(projectRoot, report) {
     }))
   };
   let history = [];
-  if (existsSync10(historyFile)) {
+  if (existsSync11(historyFile)) {
     try {
       if (!historyFile.startsWith(resolvedRoot)) return;
-      const content = readFileSync10(historyFile, "utf-8");
+      const content = readFileSync11(historyFile, "utf-8");
       history = JSON.parse(content);
     } catch {
     }
@@ -5531,19 +6440,19 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname10(historyFile), { recursive: true });
+  mkdirSync(dirname11(historyFile), { recursive: true });
   if (!historyFile.startsWith(resolvedRoot)) return;
   writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
 }
 function loadHealthHistory(projectRoot) {
   const resolvedRoot = resolve8(projectRoot);
   const historyFile = resolve8(resolvedRoot, ".depwire", "health-history.json");
-  if (!historyFile.startsWith(resolvedRoot) || !existsSync10(historyFile)) {
+  if (!historyFile.startsWith(resolvedRoot) || !existsSync11(historyFile)) {
     return [];
   }
   try {
     if (!historyFile.startsWith(resolvedRoot)) return [];
-    const content = readFileSync10(historyFile, "utf-8");
+    const content = readFileSync11(historyFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -5552,7 +6461,7 @@ function loadHealthHistory(projectRoot) {
 
 // src/dead-code/detector.ts
 import path2 from "path";
-import { readFileSync as readFileSync11, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync12 } from "fs";
 function findDeadSymbols(graph, projectRoot, includeTests = false, debug = false) {
   const deadSymbols = [];
   const context = { graph, projectRoot };
@@ -5685,11 +6594,11 @@ function getPackageEntryPoints(projectRoot) {
   const entryPoints = /* @__PURE__ */ new Set();
   const resolvedRoot = path2.resolve(projectRoot);
   const packageJsonPath = path2.resolve(resolvedRoot, "package.json");
-  if (!packageJsonPath.startsWith(resolvedRoot) || !existsSync11(packageJsonPath)) {
+  if (!packageJsonPath.startsWith(resolvedRoot) || !existsSync12(packageJsonPath)) {
     return entryPoints;
   }
   try {
-    const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync12(packageJsonPath, "utf-8"));
     if (packageJson.main) {
       entryPoints.add(path2.resolve(projectRoot, packageJson.main));
     }
@@ -5740,6 +6649,9 @@ function shouldExclude(attrs, context, includeTests, packageEntryPoints) {
   if (isFrameworkAutoLoadedFile(relativePath)) {
     return "framework";
   }
+  if (isCppExcluded(attrs)) {
+    return "framework";
+  }
   return null;
 }
 function isRealPackageEntryPoint(filePath, packageEntryPoints) {
@@ -5765,6 +6677,19 @@ function isFrameworkAutoLoadedFile(filePath) {
   return filePath.includes("/pages/") || filePath.includes("/routes/") || filePath.includes("/middleware/") || filePath.includes("/commands/") || filePath.includes("/api/") || filePath.includes("/app/") || filePath.includes("/Controllers/") || filePath.includes("/Hubs/") || filePath.includes("/Migrations/") || // Java / Spring / Jakarta
   filePath.includes("/controller/") || filePath.includes("/controllers/") || filePath.includes("/service/") || filePath.includes("/repository/") || filePath.includes("/config/") || filePath.includes("/configuration/");
 }
+function isCppExcluded(attrs) {
+  const filePath = attrs.file || attrs.filePath || "";
+  const name = attrs.name || "";
+  const kind = attrs.kind || "";
+  if (/\.(?:h|hpp|hh|hxx|h\+\+|inl|ipp)$/.test(filePath)) {
+    return true;
+  }
+  if (name === "main") return true;
+  if (name.startsWith("operator")) return true;
+  if (name.startsWith("~")) return true;
+  if (kind === "constant" && /\.(?:h|hpp)$/.test(filePath)) return true;
+  return false;
+}
 
 // src/dead-code/classifier.ts
 import path3 from "path";
@@ -5831,8 +6756,8 @@ function generateReason(symbol, confidence) {
   return "Potentially unused";
 }
 function isBarrelFile(filePath) {
-  const basename8 = path3.basename(filePath);
-  return basename8 === "index.ts" || basename8 === "index.js";
+  const basename9 = path3.basename(filePath);
+  return basename9 === "index.ts" || basename9 === "index.js";
 }
 function isTestFile2(filePath) {
   return filePath.includes("__tests__/") || filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/test/") || filePath.includes("/tests/");
@@ -6011,11 +6936,11 @@ function filterByConfidence(symbols, minConfidence) {
 }
 
 // src/docs/generator.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync14 } from "fs";
-import { join as join16 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync15 } from "fs";
+import { join as join17 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname11 } from "path";
+import { dirname as dirname12 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -6166,7 +7091,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname11(attrs.filePath);
+    const dir = dirname12(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -6191,7 +7116,7 @@ function getDirectoryStats(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname11(attrs.filePath);
+    const dir = dirname12(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -6206,8 +7131,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname11(sourceAttrs.filePath);
-    const targetDir = dirname11(targetAttrs.filePath);
+    const sourceDir = dirname12(sourceAttrs.filePath);
+    const targetDir = dirname12(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -6414,7 +7339,7 @@ function detectCycles(graph) {
 }
 
 // src/docs/conventions.ts
-import { basename as basename5, extname as extname6 } from "path";
+import { basename as basename6, extname as extname7 } from "path";
 function generateConventions(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6452,7 +7377,7 @@ function generateFileOrganization(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename5(attrs.filePath);
+      const fileName = basename6(attrs.filePath);
       if (fileName === "index.ts" || fileName === "index.js" || fileName === "index.tsx" || fileName === "index.jsx") {
         barrelFileCount++;
       }
@@ -6511,7 +7436,7 @@ function generateNamingPatterns(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename5(attrs.filePath, extname6(attrs.filePath));
+      const fileName = basename6(attrs.filePath, extname7(attrs.filePath));
       if (isCamelCase(fileName)) patterns.files.camelCase++;
       else if (isPascalCase(fileName)) patterns.files.PascalCase++;
       else if (isKebabCase(fileName)) patterns.files.kebabCase++;
@@ -7188,7 +8113,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7247,7 +8172,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 = dirname12(attrs.filePath);
+    const dir = dirname13(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -7351,7 +8276,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname12(attrs.filePath);
+    const dir = dirname13(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -7366,7 +8291,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname12(attrs.filePath);
+    const dir = dirname13(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -7381,8 +8306,8 @@ function getDirectoryStats2(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname12(sourceAttrs.filePath);
-    const targetDir = dirname12(targetAttrs.filePath);
+    const sourceDir = dirname13(sourceAttrs.filePath);
+    const targetDir = dirname13(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -7463,7 +8388,7 @@ function detectClusters(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());
     }
@@ -7517,8 +8442,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname12(files[0]);
-  if (files.every((f) => dirname12(f) === commonDir)) {
+  const commonDir = dirname13(files[0]);
+  if (files.every((f) => dirname13(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -7576,7 +8501,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname13, basename as basename6 } from "path";
+import { dirname as dirname14, basename as basename7 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7680,7 +8605,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname13(file.filePath);
+    const dir = dirname14(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -7695,7 +8620,7 @@ function generateDirectoryBreakdown(graph) {
     dirStats.symbolCount += file.symbolCount;
     if (file.totalConnections > dirStats.maxConnections) {
       dirStats.maxConnections = file.totalConnections;
-      dirStats.mostConnectedFile = basename6(file.filePath);
+      dirStats.mostConnectedFile = basename7(file.filePath);
     }
   }
   if (dirMap.size === 0) {
@@ -8323,7 +9248,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename7, dirname as dirname14 } from "path";
+import { basename as basename8, dirname as dirname15 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -8351,8 +9276,8 @@ function getFileCount8(graph) {
   return files.size;
 }
 function isTestFile3(filePath) {
-  const fileName = basename7(filePath).toLowerCase();
-  const dirPath = dirname14(filePath).toLowerCase();
+  const fileName = basename8(filePath).toLowerCase();
+  const dirPath = dirname15(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -8410,13 +9335,13 @@ function generateTestFileInventory(graph) {
   return output;
 }
 function matchTestToSource(testFile) {
-  const testFileName = basename7(testFile);
-  const testDir = dirname14(testFile);
+  const testFileName = basename8(testFile);
+  const testDir = dirname15(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 = dirname14(testDir);
+    const parentDir = dirname15(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -8572,7 +9497,7 @@ function generateTestCoverageMap(graph) {
   const rows = mappings.slice(0, 30).map((m) => [
     `\`${m.sourceFile}\``,
     m.hasTest ? "\u2705" : "\u274C",
-    m.testFile ? `\`${basename7(m.testFile)}\`` : "-",
+    m.testFile ? `\`${basename8(m.testFile)}\`` : "-",
     formatNumber(m.symbolCount)
   ]);
   let output = table(headers, rows);
@@ -8613,7 +9538,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname14(sourceFile).split("/")[0];
+    const dir = dirname15(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -8636,7 +9561,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname15 } from "path";
+import { dirname as dirname16 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -8917,7 +9842,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname15(attrs.filePath);
+    const dir = dirname16(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -8999,7 +9924,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname16 } from "path";
+import { dirname as dirname17 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -9137,7 +10062,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 = dirname16(info.filePath);
+    const dir = dirname17(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -9348,7 +10273,7 @@ function getTopLevelDir2(filePath) {
 }
 
 // src/docs/status.ts
-import { readFileSync as readFileSync12, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync13, existsSync as existsSync13 } from "fs";
 import { resolve as resolve9 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
@@ -9387,11 +10312,11 @@ function extractComments(projectRoot, filePath) {
   if (!fullPath.startsWith(resolvedRoot)) {
     return comments;
   }
-  if (!existsSync12(fullPath)) {
+  if (!existsSync13(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync12(fullPath, "utf-8");
+    const content = readFileSync13(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -9970,16 +10895,16 @@ function generateConfidenceSection(title, description, symbols, projectRoot) {
 }
 
 // src/docs/metadata.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync14, writeFileSync as writeFileSync2 } from "fs";
 import { resolve as resolve10 } from "path";
 function loadMetadata(outputDir) {
   const resolvedDir = resolve10(outputDir);
   const metadataPath = resolve10(resolvedDir, "metadata.json");
-  if (!metadataPath.startsWith(resolvedDir) || !existsSync13(metadataPath)) {
+  if (!metadataPath.startsWith(resolvedDir) || !existsSync14(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync13(metadataPath, "utf-8");
+    const content = readFileSync14(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -10034,7 +10959,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync14(options.outputDir)) {
+    if (!existsSync15(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -10073,7 +10998,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 = join16(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join17(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -10084,7 +11009,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 = join16(options.outputDir, "CONVENTIONS.md");
+          const filePath = join17(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -10095,7 +11020,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 = join16(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join17(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -10106,7 +11031,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 = join16(options.outputDir, "ONBOARDING.md");
+          const filePath = join17(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -10117,7 +11042,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 = join16(options.outputDir, "FILES.md");
+          const filePath = join17(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -10128,7 +11053,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 = join16(options.outputDir, "API_SURFACE.md");
+          const filePath = join17(options.outputDir, "API_SURFACE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
@@ -10139,7 +11064,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 = join16(options.outputDir, "ERRORS.md");
+          const filePath = join17(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -10150,7 +11075,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 = join16(options.outputDir, "TESTS.md");
+          const filePath = join17(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -10161,7 +11086,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 = join16(options.outputDir, "HISTORY.md");
+          const filePath = join17(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -10172,7 +11097,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 = join16(options.outputDir, "CURRENT.md");
+          const filePath = join17(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -10183,7 +11108,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 = join16(options.outputDir, "STATUS.md");
+          const filePath = join17(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -10194,7 +11119,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 = join16(options.outputDir, "HEALTH.md");
+          const filePath = join17(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
@@ -10205,7 +11130,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 = join16(options.outputDir, "DEAD_CODE.md");
+          const filePath = join17(options.outputDir, "DEAD_CODE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEAD_CODE.md");
         } catch (err) {
@@ -10249,7 +11174,7 @@ function getFileCount13(graph) {
 }
 
 // src/simulation/engine.ts
-import { dirname as dirname17, join as join17 } from "path";
+import { dirname as dirname18, join as join18 } from "path";
 function normalizePath2(p) {
   return p.replace(/^\.\//, "").replace(/\/+$/, "");
 }
@@ -10380,7 +11305,7 @@ var SimulationEngine = class {
     }
   }
   applyRename(clone, target, newName, brokenImports) {
-    const destination = join17(dirname17(target), newName);
+    const destination = join18(dirname18(target), newName);
     this.applyMove(clone, target, destination, brokenImports);
   }
   applySplit(clone, target, newFile, symbols, brokenImports) {
@@ -10580,13 +11505,13 @@ var SimulationEngine = class {
 };
 
 // src/security/scanner.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join28 } from "path";
 
 // src/security/checks/dependencies.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync14, readdirSync as readdirSync7 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync15, readdirSync as readdirSync8 } from "fs";
+import { join as join19 } from "path";
 function cvssToSeverity(score) {
   if (score >= 9) return "critical";
   if (score >= 7) return "high";
@@ -10596,18 +11521,18 @@ function cvssToSeverity(score) {
 async function checkDependencies(_files, projectRoot) {
   const findings = [];
   try {
-    if (existsSync15(join18(projectRoot, "package.json"))) {
+    if (existsSync16(join19(projectRoot, "package.json"))) {
       findings.push(...checkNpmAudit(projectRoot));
       findings.push(...checkPackageJsonPatterns(projectRoot));
       findings.push(...checkPostinstallScripts(projectRoot));
     }
-    if (existsSync15(join18(projectRoot, "requirements.txt")) || existsSync15(join18(projectRoot, "pyproject.toml"))) {
+    if (existsSync16(join19(projectRoot, "requirements.txt")) || existsSync16(join19(projectRoot, "pyproject.toml"))) {
       findings.push(...checkPipAudit(projectRoot));
     }
-    if (existsSync15(join18(projectRoot, "Cargo.toml"))) {
+    if (existsSync16(join19(projectRoot, "Cargo.toml"))) {
       findings.push(...checkCargoAudit(projectRoot));
     }
-    if (existsSync15(join18(projectRoot, "go.mod"))) {
+    if (existsSync16(join19(projectRoot, "go.mod"))) {
       findings.push(...checkGoVerify(projectRoot));
     }
   } catch (err) {
@@ -10696,8 +11621,8 @@ function checkNpmAudit(projectRoot) {
 function checkPackageJsonPatterns(projectRoot) {
   const findings = [];
   try {
-    const pkgPath = join18(projectRoot, "package.json");
-    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+    const pkgPath = join19(projectRoot, "package.json");
+    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const [name, version] of Object.entries(allDeps)) {
       if (version.startsWith("^") || version.startsWith("~")) {
@@ -10719,15 +11644,15 @@ function checkPackageJsonPatterns(projectRoot) {
 }
 function checkPostinstallScripts(projectRoot) {
   const findings = [];
-  const nodeModules = join18(projectRoot, "node_modules");
-  if (!existsSync15(nodeModules)) return findings;
+  const nodeModules = join19(projectRoot, "node_modules");
+  if (!existsSync16(nodeModules)) return findings;
   try {
-    const topLevelDeps = readdirSync7(nodeModules).filter((d) => !d.startsWith("."));
+    const topLevelDeps = readdirSync8(nodeModules).filter((d) => !d.startsWith("."));
     for (const dep of topLevelDeps) {
-      const depPkgPath = join18(nodeModules, dep, "package.json");
-      if (!existsSync15(depPkgPath)) continue;
+      const depPkgPath = join19(nodeModules, dep, "package.json");
+      if (!existsSync16(depPkgPath)) continue;
       try {
-        const depPkg = JSON.parse(readFileSync14(depPkgPath, "utf-8"));
+        const depPkg = JSON.parse(readFileSync15(depPkgPath, "utf-8"));
         const scripts = depPkg.scripts || {};
         if (scripts.postinstall || scripts.preinstall || scripts.install) {
           const scriptName = scripts.postinstall ? "postinstall" : scripts.preinstall ? "preinstall" : "install";
@@ -10765,7 +11690,7 @@ function checkPipAudit(projectRoot) {
         id: "",
         severity: cvssToSeverity(vuln.cvss?.score || 5),
         vulnerabilityClass: "dependency-cve",
-        file: existsSync15(join18(projectRoot, "requirements.txt")) ? "requirements.txt" : "pyproject.toml",
+        file: existsSync16(join19(projectRoot, "requirements.txt")) ? "requirements.txt" : "pyproject.toml",
         title: `Vulnerable Python dependency: ${vuln.name}`,
         description: `${vuln.name}@${vuln.version} \u2014 ${vuln.id}: ${vuln.description || "Known vulnerability"}`,
         attackScenario: `An attacker could exploit the vulnerability in ${vuln.name}.`,
@@ -10862,8 +11787,8 @@ function checkGoVerify(projectRoot) {
 }
 
 // src/security/checks/injection.ts
-import { readFileSync as readFileSync15 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync16 } from "fs";
+import { join as join20 } from "path";
 var SKIP_DIRS = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var TEST_PATTERNS = ["test", "spec", "fixture", "mock", "__tests__", "__mocks__"];
 var USER_INPUT_NAMES = /(?:input|user|name|path|query|branch|hash|cmd|command|req\.|params|body|args|url|dir|file|subdirectory)/i;
@@ -11012,6 +11937,43 @@ var PATTERNS = [
     description: "permitAll() applied to a path that appears security-sensitive.",
     attackScenario: "An attacker could access administrative or destructive endpoints without authentication.",
     suggestedFix: 'Use .hasRole("ADMIN") or .authenticated() for sensitive endpoints.'
+  },
+  // C++ injection patterns
+  {
+    regex: /\b(?:strcpy|strcat|sprintf|gets)\s*\(/,
+    title: "C++ buffer overflow risk: unsafe string function",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "Unsafe C string functions (strcpy, strcat, sprintf, gets) with no bounds checking \u2014 buffer overflow risk.",
+    attackScenario: "An attacker could provide oversized input to overflow the buffer, enabling arbitrary code execution.",
+    suggestedFix: "Use bounded alternatives: strncpy, strncat, snprintf, or C++ std::string."
+  },
+  {
+    regex: /printf\s*\(\s*(?!")[a-zA-Z_]\w*/,
+    title: "C++ format string vulnerability",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "printf called with a variable as the format string \u2014 format string attack risk.",
+    attackScenario: "An attacker could inject format specifiers (%x, %n) to read/write arbitrary memory.",
+    suggestedFix: 'Always use a literal format string: printf("%s", userInput).'
+  },
+  {
+    regex: /\bsystem\s*\(\s*(?!")[a-zA-Z_]\w*/,
+    title: "C++ command injection via system()",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "system() called with a variable argument \u2014 potential command injection.",
+    attackScenario: "An attacker could inject shell metacharacters to execute arbitrary commands.",
+    suggestedFix: "Avoid system(). Use execvp with an argument array, or validate input with a strict allowlist."
+  },
+  {
+    regex: /\bpopen\s*\(\s*(?!")[a-zA-Z_]\w*/,
+    title: "C++ command injection via popen()",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "popen() called with a variable argument \u2014 potential command injection.",
+    attackScenario: "An attacker could inject shell metacharacters to execute arbitrary commands.",
+    suggestedFix: "Avoid popen(). Use pipe/fork/exec with argument arrays instead."
   }
 ];
 function shouldSkip(filePath) {
@@ -11028,7 +11990,7 @@ async function checkInjection(files, projectRoot) {
       if (shouldSkip(file.filePath) || isTestFile4(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync15(join19(projectRoot, file.filePath), "utf-8");
+        content = readFileSync16(join20(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -11066,8 +12028,8 @@ async function checkInjection(files, projectRoot) {
 }
 
 // src/security/checks/secrets.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync17 } from "fs";
+import { join as join21 } from "path";
 var SKIP_DIRS2 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var TEST_PATTERNS2 = ["test", "spec", "fixture", "mock", "__tests__", "__mocks__", ".example", ".sample"];
 var SECRET_PATTERNS = [
@@ -11100,7 +12062,7 @@ async function checkSecrets(files, projectRoot) {
       if (shouldSkip2(file.filePath) || isTestFile5(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync16(join20(projectRoot, file.filePath), "utf-8");
+        content = readFileSync17(join21(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -11133,8 +12095,8 @@ async function checkSecrets(files, projectRoot) {
 }
 
 // src/security/checks/path-traversal.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join22 } from "path";
 var SKIP_DIRS3 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var USER_INPUT_VARS = /(?:req\.|params|query|body|input|path|dir|subdirectory|file|userInput|fileName|filePath)/i;
 var PATTERNS2 = [
@@ -11181,7 +12143,7 @@ async function checkPathTraversal(files, projectRoot) {
       if (shouldSkip3(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync17(join21(projectRoot, file.filePath), "utf-8");
+        content = readFileSync18(join22(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -11223,8 +12185,8 @@ async function checkPathTraversal(files, projectRoot) {
 }
 
 // src/security/checks/auth.ts
-import { readFileSync as readFileSync18 } from "fs";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync19 } from "fs";
+import { join as join23 } from "path";
 var SKIP_DIRS4 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip4(filePath) {
   return SKIP_DIRS4.some((d) => filePath.includes(d));
@@ -11240,7 +12202,7 @@ async function checkAuth(files, projectRoot) {
       if (shouldSkip4(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync18(join22(projectRoot, file.filePath), "utf-8");
+        content = readFileSync19(join23(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -11331,8 +12293,8 @@ async function checkAuth(files, projectRoot) {
 }
 
 // src/security/checks/input-validation.ts
-import { readFileSync as readFileSync19 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { join as join24 } from "path";
 var SKIP_DIRS5 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip5(filePath) {
   return SKIP_DIRS5.some((d) => filePath.includes(d));
@@ -11344,7 +12306,7 @@ async function checkInputValidation(files, projectRoot) {
       if (shouldSkip5(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync19(join23(projectRoot, file.filePath), "utf-8");
+        content = readFileSync20(join24(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -11421,8 +12383,8 @@ async function checkInputValidation(files, projectRoot) {
 }
 
 // src/security/checks/information-disclosure.ts
-import { readFileSync as readFileSync20 } from "fs";
-import { join as join24 } from "path";
+import { readFileSync as readFileSync21 } from "fs";
+import { join as join25 } from "path";
 var SKIP_DIRS6 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip6(filePath) {
   return SKIP_DIRS6.some((d) => filePath.includes(d));
@@ -11434,7 +12396,7 @@ async function checkInformationDisclosure(files, projectRoot) {
       if (shouldSkip6(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync20(join24(projectRoot, file.filePath), "utf-8");
+        content = readFileSync21(join25(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -11504,8 +12466,8 @@ async function checkInformationDisclosure(files, projectRoot) {
 }
 
 // src/security/checks/cryptography.ts
-import { readFileSync as readFileSync21 } from "fs";
-import { join as join25 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join26 } from "path";
 var SKIP_DIRS7 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 var USER_INPUT_NAMES2 = /(?:input|user|name|path|query|param|request|body|args|url)/i;
 function shouldSkip7(filePath) {
@@ -11522,7 +12484,7 @@ async function checkCryptography(files, projectRoot) {
       if (shouldSkip7(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync21(join25(projectRoot, file.filePath), "utf-8");
+        content = readFileSync22(join26(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -11624,6 +12586,32 @@ async function checkCryptography(files, projectRoot) {
             suggestedFix: "Generate a unique random salt per user using crypto.randomBytes(16)."
           });
         }
+        if (/\brand\s*\(\s*\)/.test(line) && isCryptoFile) {
+          findings.push({
+            id: "",
+            severity: "medium",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Weak random: rand() in security context",
+            description: "rand() is not cryptographically secure \u2014 its output can be predicted.",
+            attackScenario: "An attacker could predict rand() values to forge tokens or bypass security checks.",
+            suggestedFix: "Use std::random_device or platform-specific CSPRNG (e.g., /dev/urandom, BCryptGenRandom)."
+          });
+        }
+        if (/(?:const\s+(?:char|std::string)\s*\*?\s*(?:password|secret|api_key|apiKey|token)\s*=\s*["'])/i.test(line)) {
+          findings.push({
+            id: "",
+            severity: "high",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Hardcoded credentials in C++ source",
+            description: "A password, secret, or API key is hardcoded as a string literal.",
+            attackScenario: "An attacker with access to the binary or source could extract the credential.",
+            suggestedFix: "Load credentials from environment variables or a secure vault at runtime."
+          });
+        }
       }
     }
   } catch {
@@ -11632,8 +12620,8 @@ async function checkCryptography(files, projectRoot) {
 }
 
 // src/security/checks/frontend.ts
-import { readFileSync as readFileSync22 } from "fs";
-import { join as join26 } from "path";
+import { readFileSync as readFileSync23 } from "fs";
+import { join as join27 } from "path";
 var SKIP_DIRS8 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip8(filePath) {
   return SKIP_DIRS8.some((d) => filePath.includes(d));
@@ -11649,7 +12637,7 @@ async function checkFrontend(files, projectRoot) {
       if (!isFrontendFile(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync22(join26(projectRoot, file.filePath), "utf-8");
+        content = readFileSync23(join27(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -12109,13 +13097,13 @@ async function scanSecurity(projectRoot, graph, options = {}) {
   };
 }
 function detectPackageManager(projectRoot) {
-  if (existsSync16(join27(projectRoot, "package.json"))) return "npm";
-  if (existsSync16(join27(projectRoot, "requirements.txt"))) return "pip";
-  if (existsSync16(join27(projectRoot, "pyproject.toml"))) return "pip";
-  if (existsSync16(join27(projectRoot, "Cargo.toml"))) return "cargo";
-  if (existsSync16(join27(projectRoot, "go.mod"))) return "go";
-  if (existsSync16(join27(projectRoot, "pom.xml"))) return "maven";
-  if (existsSync16(join27(projectRoot, "build.gradle")) || existsSync16(join27(projectRoot, "build.gradle.kts"))) return "gradle";
+  if (existsSync17(join28(projectRoot, "package.json"))) return "npm";
+  if (existsSync17(join28(projectRoot, "requirements.txt"))) return "pip";
+  if (existsSync17(join28(projectRoot, "pyproject.toml"))) return "pip";
+  if (existsSync17(join28(projectRoot, "Cargo.toml"))) return "cargo";
+  if (existsSync17(join28(projectRoot, "go.mod"))) return "go";
+  if (existsSync17(join28(projectRoot, "pom.xml"))) return "maven";
+  if (existsSync17(join28(projectRoot, "build.gradle")) || existsSync17(join28(projectRoot, "build.gradle.kts"))) return "gradle";
   return "unknown";
 }