depwire-cli 0.9.30 → 1.0.1

package/dist/{chunk-WUSXCZXA.js → chunk-LV32EDYQ.js}

@@ -32,7 +32,9 @@ function scanDirectory(rootDir, baseDir = rootDir) {
         const isGo = entry.endsWith(".go") && !entry.endsWith("_test.go");
         const isRust = entry.endsWith(".rs");
         const isC = entry.endsWith(".c") || entry.endsWith(".h");
-        if (isTypeScript || isJavaScript || isPython || isGo || isRust || isC) {
+        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) {
           files.push(relative(rootDir, fullPath));
         }
       }
@@ -70,6 +72,10 @@ function findProjectRoot(startDir = process.cwd()) {
     // C/C++ (cmake-based)
     "configure.ac",
     // C/C++ (autotools)
+    "pom.xml",
+    // Java (Maven)
+    "build.gradle",
+    // Java (Gradle)
     ".git"
     // Any git repo
   ];
@@ -103,11 +109,11 @@ function findProjectRoot(startDir = process.cwd()) {
 }
 
 // src/parser/index.ts
-import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { join as join8, resolve as resolve3 } from "path";
+import { readFileSync as readFileSync7, statSync as statSync4 } from "fs";
+import { join as join10, resolve as resolve5 } from "path";
 
 // src/parser/detect.ts
-import { extname as extname3 } from "path";
+import { extname as extname5, basename as basename3 } from "path";
 
 // src/parser/wasm-init.ts
 import { Parser, Language } from "web-tree-sitter";
@@ -134,7 +140,9 @@ async function initParser() {
     "python": "tree-sitter-python.wasm",
     "go": "tree-sitter-go.wasm",
     "rust": "tree-sitter-rust.wasm",
-    "c": "tree-sitter-c.wasm"
+    "c": "tree-sitter-c.wasm",
+    "c_sharp": "tree-sitter-c_sharp.wasm",
+    "java": "tree-sitter-java.wasm"
   };
   for (const [name, file] of Object.entries(grammarFiles)) {
     const wasmPath = path.join(grammarsDir, file);
@@ -2782,6 +2790,1312 @@ var cParser = {
   parseFile: parseCFile
 };
 
+// src/parser/csharp.ts
+import { dirname as dirname7, join as join8, resolve as resolve3, basename } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+function parseCSharpFile(filePath, sourceCode, projectRoot) {
+  if (filePath.endsWith(".csproj")) {
+    return parseCsprojFile(filePath, sourceCode, projectRoot);
+  }
+  const parser = getParser("c_sharp");
+  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(),
+    isCsproj: false
+  };
+  walkNode7(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode7(node, context) {
+  processNode7(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode7(child, context);
+    }
+  }
+}
+function processNode7(node, context) {
+  switch (node.type) {
+    case "namespace_declaration":
+      processNamespaceDeclaration(node, context);
+      break;
+    case "file_scoped_namespace_declaration":
+      processFileScopedNamespace(node, context);
+      break;
+    case "class_declaration":
+      processClassDeclaration3(node, context);
+      break;
+    case "interface_declaration":
+      processInterfaceDeclaration2(node, context);
+      break;
+    case "struct_declaration":
+      processStructDeclaration(node, context);
+      break;
+    case "enum_declaration":
+      processEnumDeclaration2(node, context);
+      break;
+    case "record_declaration":
+      processRecordDeclaration(node, context);
+      break;
+    case "delegate_declaration":
+      processDelegateDeclaration(node, context);
+      break;
+    case "method_declaration":
+      processMethodDeclaration2(node, context);
+      break;
+    case "constructor_declaration":
+      processConstructorDeclaration(node, context);
+      break;
+    case "property_declaration":
+      processPropertyDeclaration(node, context);
+      break;
+    case "event_field_declaration":
+      processEventFieldDeclaration(node, context);
+      break;
+    case "indexer_declaration":
+      processIndexerDeclaration(node, context);
+      break;
+    case "using_directive":
+      processUsingDirective(node, context);
+      break;
+    case "global_statement":
+      processGlobalStatement(node, context);
+      break;
+    case "invocation_expression":
+      processCallExpression7(node, context);
+      break;
+  }
+}
+function processNamespaceDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  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;
+  context.currentScope.push(name);
+  const body = findChildByType7(node, "declaration_list");
+  if (body) {
+    walkNode7(body, context);
+  }
+  context.currentScope.pop();
+  context.currentNamespace = oldNamespace;
+}
+function processFileScopedNamespace(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  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
+  });
+  context.currentNamespace = name;
+}
+function processClassDeclaration3(node, context) {
+  processTypeDeclaration2(node, context, "class");
+}
+function processInterfaceDeclaration2(node, context) {
+  processTypeDeclaration2(node, context, "interface");
+}
+function processStructDeclaration(node, context) {
+  processTypeDeclaration2(node, context, "class");
+}
+function processRecordDeclaration(node, context) {
+  processTypeDeclaration2(node, context, "class");
+}
+function processTypeDeclaration2(node, context, kind) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  let name = nodeText6(nameNode, context);
+  const angleBracketIdx = name.indexOf("<");
+  if (angleBracketIdx > 0) {
+    name = name.substring(0, angleBracketIdx);
+  }
+  const exported = hasModifier(node, context, "public") || hasModifier(node, context, "internal");
+  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 baseList = findChildByType7(node, "base_list");
+  if (baseList) {
+    for (let i = 0; i < baseList.childCount; i++) {
+      const child = baseList.child(i);
+      if (!child) continue;
+      if (child.type === "simple_base_type" || child.type === "identifier" || child.type === "generic_name" || child.type === "qualified_name") {
+        let baseName = extractBaseTypeName(child, context);
+        if (baseName) {
+          const baseId = resolveSymbol6(baseName, context);
+          if (baseId) {
+            const edgeKind = baseName.startsWith("I") && baseName.length > 1 && baseName[1] === baseName[1].toUpperCase() ? "implements" : "inherits";
+            context.edges.push({
+              source: symbolId,
+              target: baseId,
+              kind: edgeKind,
+              filePath: context.filePath,
+              line: child.startPosition.row + 1
+            });
+          }
+        }
+      }
+    }
+  }
+  const oldClass = context.currentClass;
+  context.currentClass = name;
+  context.currentScope.push(name);
+  const body = findChildByType7(node, "declaration_list");
+  if (body) {
+    walkNode7(body, context);
+  }
+  context.currentScope.pop();
+  context.currentClass = oldClass;
+}
+function processEnumDeclaration2(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  const exported = hasModifier(node, context, "public") || hasModifier(node, context, "internal");
+  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
+  });
+  const body = findChildByType7(node, "enum_member_declaration_list");
+  if (body) {
+    const members = findChildrenByType2(body, "enum_member_declaration");
+    for (const member of members) {
+      const memberNameNode = member.childForFieldName("name");
+      if (!memberNameNode) continue;
+      const memberName = nodeText6(memberNameNode, context);
+      const memberId = `${context.filePath}::${name}.${memberName}`;
+      context.symbols.push({
+        id: memberId,
+        name: memberName,
+        kind: "constant",
+        filePath: context.filePath,
+        startLine: member.startPosition.row + 1,
+        endLine: member.endPosition.row + 1,
+        exported,
+        scope: name
+      });
+    }
+  }
+}
+function processDelegateDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  let name = nodeText6(nameNode, context);
+  const angleBracketIdx = name.indexOf("<");
+  if (angleBracketIdx > 0) name = name.substring(0, angleBracketIdx);
+  const exported = hasModifier(node, context, "public") || hasModifier(node, context, "internal");
+  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 processMethodDeclaration2(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  const exported = hasModifier(node, context, "public");
+  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) {
+    walkNode7(body, context);
+  }
+  context.currentScope.pop();
+}
+function processConstructorDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  const exported = hasModifier(node, context, "public");
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "method",
+    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) {
+    walkNode7(body, context);
+  }
+  context.currentScope.pop();
+}
+function processPropertyDeclaration(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  const exported = hasModifier(node, context, "public");
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "property",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported,
+    scope
+  });
+}
+function processEventFieldDeclaration(node, context) {
+  const varDecl = findChildByType7(node, "variable_declaration");
+  if (!varDecl) return;
+  const declarator = findChildByType7(varDecl, "variable_declarator");
+  if (!declarator) return;
+  const nameNode = declarator.childForFieldName("name") || findChildByType7(declarator, "identifier");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  const exported = hasModifier(node, context, "public");
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "property",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported,
+    scope
+  });
+}
+function processIndexerDeclaration(node, context) {
+  const exported = hasModifier(node, context, "public");
+  const scope = context.currentClass || void 0;
+  const name = "this[]";
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "property",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported,
+    scope
+  });
+}
+function processUsingDirective(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText6(nameNode, context);
+  const resolvedPath = resolveCSharpNamespace(name, context.filePath, context.projectRoot);
+  if (resolvedPath) {
+    const sourceId = `${context.filePath}::__file__`;
+    const targetId = `${resolvedPath}::__file__`;
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processGlobalStatement(node, context) {
+  const symbolId = `${context.filePath}::__toplevel__`;
+  if (context.symbols.find((s) => s.id === symbolId)) return;
+  context.symbols.push({
+    id: symbolId,
+    name: "__toplevel__",
+    kind: "function",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true
+  });
+}
+function processCallExpression7(node, context) {
+  const functionNode = node.childForFieldName("function");
+  if (!functionNode) return;
+  let calleeName = null;
+  if (functionNode.type === "identifier") {
+    calleeName = nodeText6(functionNode, context);
+  } else if (functionNode.type === "member_access_expression") {
+    const nameNode = functionNode.childForFieldName("name");
+    if (nameNode) {
+      calleeName = nodeText6(nameNode, context);
+    }
+  }
+  if (!calleeName) return;
+  const builtins = ["ToString", "Equals", "GetHashCode", "GetType", "Console", "Write", "WriteLine", "Format", "Parse", "TryParse"];
+  if (builtins.includes(calleeName)) return;
+  const callerId = getCurrentSymbolId7(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol6(calleeName, context);
+  if (calleeId) {
+    context.edges.push({
+      source: callerId,
+      target: calleeId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function parseCsprojFile(filePath, sourceCode, projectRoot) {
+  const symbols = [];
+  const edges = [];
+  const lines = sourceCode.split("\n");
+  const projectName = basename(filePath, ".csproj");
+  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];
+    const lineNum = i + 1;
+    const projectRefMatch = line.match(/<ProjectReference\s+Include\s*=\s*"([^"]+)"/);
+    if (projectRefMatch) {
+      const refPath = projectRefMatch[1];
+      const csprojDir = dirname7(join8(projectRoot, filePath));
+      const resolvedRef = resolve3(csprojDir, refPath);
+      const relativeRef = resolvedRef.startsWith(projectRoot + "/") ? resolvedRef.substring(projectRoot.length + 1) : null;
+      if (relativeRef && existsSync8(resolvedRef)) {
+        edges.push({
+          source: `${filePath}::__file__`,
+          target: `${relativeRef}::__file__`,
+          kind: "imports",
+          filePath,
+          line: lineNum
+        });
+      }
+    }
+    const packageRefMatch = line.match(/<PackageReference\s+Include\s*=\s*"([^"]+)"/);
+    if (packageRefMatch) {
+      const packageName = packageRefMatch[1];
+      const versionMatch = line.match(/Version\s*=\s*"([^"]+)"/);
+      const version = versionMatch ? versionMatch[1] : "unknown";
+      symbols.push({
+        id: `${filePath}::pkg:${packageName}`,
+        name: `${packageName}@${version}`,
+        kind: "import",
+        filePath,
+        startLine: lineNum,
+        endLine: lineNum,
+        exported: false
+      });
+    }
+  }
+  return { filePath, symbols, edges };
+}
+function resolveCSharpNamespace(namespace, currentFile, projectRoot) {
+  const namespacePath = namespace.replace(/\./g, "/");
+  const candidates = [
+    join8(projectRoot, namespacePath),
+    join8(projectRoot, "src", namespacePath)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync8(candidate)) {
+      try {
+        const stats = statSync2(candidate);
+        if (stats.isDirectory()) {
+          const csFiles = readdirSync5(candidate).filter((f) => f.endsWith(".cs"));
+          if (csFiles.length > 0) {
+            const fullPath = join8(candidate, csFiles[0]);
+            return fullPath.substring(projectRoot.length + 1);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function resolveSymbol6(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 hasModifier(node, context, modifier) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === "modifier" && nodeText6(child, context) === modifier) {
+      return true;
+    }
+  }
+  if (modifier === "internal") {
+    const hasExplicitAccess = ["public", "private", "protected", "internal"].some((m) => {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.type === "modifier" && nodeText6(child, context) === m) return true;
+      }
+      return false;
+    });
+    return !hasExplicitAccess;
+  }
+  return false;
+}
+function extractBaseTypeName(node, context) {
+  const text = nodeText6(node, context).trim();
+  if (!text || text === ":" || text === ",") return null;
+  const angleBracketIdx = text.indexOf("<");
+  const name = angleBracketIdx > 0 ? text.substring(0, angleBracketIdx) : text;
+  const dotIdx = name.lastIndexOf(".");
+  return dotIdx >= 0 ? name.substring(dotIdx + 1) : name;
+}
+function findChildByType7(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 findChildrenByType2(node, type) {
+  const results = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) results.push(child);
+  }
+  return results;
+}
+function nodeText6(node, context) {
+  return context.sourceCode.substring(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId7(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope[context.currentScope.length - 1]}`;
+}
+var csharpParser = {
+  name: "csharp",
+  extensions: [".cs", ".csx", ".csproj"],
+  parseFile: parseCSharpFile
+};
+
+// src/parser/java.ts
+import { dirname as dirname8, join as join9, resolve as resolve4, basename as basename2 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync6, statSync as statSync3 } from "fs";
+function parseJavaFile(filePath, sourceCode, projectRoot) {
+  if (filePath.endsWith("pom.xml")) {
+    return parsePomXml(filePath, sourceCode, projectRoot);
+  }
+  if (filePath.endsWith("build.gradle") || filePath.endsWith("build.gradle.kts")) {
+    return parseGradleBuild(filePath, sourceCode, projectRoot);
+  }
+  const parser = getParser("java");
+  const tree = parser.parse(sourceCode, null, { bufferSize: 1024 * 1024 });
+  const context = {
+    filePath,
+    projectRoot,
+    sourceCode,
+    symbols: [],
+    edges: [],
+    currentScope: [],
+    currentClass: null,
+    currentPackage: null,
+    imports: /* @__PURE__ */ new Map(),
+    isBuildFile: false
+  };
+  walkNode8(tree.rootNode, context);
+  return {
+    filePath,
+    symbols: context.symbols,
+    edges: context.edges
+  };
+}
+function walkNode8(node, context) {
+  processNode8(node, context);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      walkNode8(child, context);
+    }
+  }
+}
+function processNode8(node, context) {
+  switch (node.type) {
+    case "package_declaration":
+      processPackageDeclaration(node, context);
+      break;
+    case "import_declaration":
+      processImportDeclaration2(node, context);
+      break;
+    case "class_declaration":
+      processClassDeclaration4(node, context);
+      break;
+    case "interface_declaration":
+      processInterfaceDeclaration3(node, context);
+      break;
+    case "enum_declaration":
+      processEnumDeclaration3(node, context);
+      break;
+    case "annotation_type_declaration":
+      processAnnotationTypeDeclaration(node, context);
+      break;
+    case "record_declaration":
+      processRecordDeclaration2(node, context);
+      break;
+    case "method_declaration":
+      processMethodDeclaration3(node, context);
+      break;
+    case "constructor_declaration":
+      processConstructorDeclaration2(node, context);
+      break;
+    case "field_declaration":
+      processFieldDeclaration(node, context);
+      break;
+    case "constant_declaration":
+      processConstantDeclaration(node, context);
+      break;
+    case "annotation_type_element_declaration":
+      processAnnotationElement(node, context);
+      break;
+    case "method_invocation":
+      processCallExpression8(node, context);
+      break;
+    case "object_creation_expression":
+      processObjectCreation(node, context);
+      break;
+    case "lambda_expression":
+      processLambdaExpression(node, context);
+      break;
+  }
+}
+function processPackageDeclaration(node, context) {
+  const scopedIdent = findDescendantByTypes(node, ["scoped_identifier", "identifier"]);
+  if (!scopedIdent) return;
+  const name = nodeText7(scopedIdent, context);
+  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
+  });
+  context.currentPackage = name;
+}
+function processImportDeclaration2(node, context) {
+  const text = nodeText7(node, context).trim();
+  const isStatic = text.includes("import static");
+  const isWildcard = text.includes(".*");
+  const scopedIdent = findDescendantByTypes(node, ["scoped_identifier", "identifier"]);
+  if (!scopedIdent) return;
+  let importPath = nodeText7(scopedIdent, context);
+  const asterisk = findChildByType8(node, "asterisk");
+  if (asterisk) {
+    importPath = importPath + ".*";
+  }
+  const resolvedPath = resolveJavaImport(importPath, context.filePath, context.projectRoot);
+  if (resolvedPath) {
+    const sourceId = `${context.filePath}::__file__`;
+    const targetId = `${resolvedPath}::__file__`;
+    context.edges.push({
+      source: sourceId,
+      target: targetId,
+      kind: "imports",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+    const parts = importPath.split(".");
+    if (!isWildcard) {
+      const simpleName = parts[parts.length - 1];
+      context.imports.set(simpleName, `${resolvedPath}::${simpleName}`);
+    }
+  }
+  const symbolId = `${context.filePath}::import:${importPath}`;
+  context.symbols.push({
+    id: symbolId,
+    name: importPath,
+    kind: "import",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: false
+  });
+}
+function processClassDeclaration4(node, context) {
+  processTypeDeclaration3(node, context, "class");
+}
+function processInterfaceDeclaration3(node, context) {
+  processTypeDeclaration3(node, context, "interface");
+}
+function processRecordDeclaration2(node, context) {
+  processTypeDeclaration3(node, context, "class");
+}
+function processAnnotationTypeDeclaration(node, context) {
+  processTypeDeclaration3(node, context, "interface");
+}
+function processTypeDeclaration3(node, context, kind) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  let name = nodeText7(nameNode, context);
+  const angleBracketIdx = name.indexOf("<");
+  if (angleBracketIdx > 0) {
+    name = name.substring(0, angleBracketIdx);
+  }
+  const exported = hasModifier2(node, context, "public");
+  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 superclass = node.childForFieldName("superclass");
+  if (superclass) {
+    let baseName = extractTypeName3(superclass, context);
+    if (baseName) {
+      const baseId = resolveSymbol7(baseName, context);
+      if (baseId) {
+        context.edges.push({
+          source: symbolId,
+          target: baseId,
+          kind: "inherits",
+          filePath: context.filePath,
+          line: superclass.startPosition.row + 1
+        });
+      }
+    }
+  }
+  const interfaces = node.childForFieldName("interfaces");
+  if (interfaces) {
+    processInterfaceList(interfaces, symbolId, context);
+  }
+  const extendsInterfaces = node.childForFieldName("extends_interfaces") || findChildByType8(node, "extends_interfaces");
+  if (extendsInterfaces) {
+    processInterfaceList(extendsInterfaces, symbolId, context);
+  }
+  const oldClass = context.currentClass;
+  context.currentClass = name;
+  context.currentScope.push(name);
+  const body = node.childForFieldName("body") || findChildByType8(node, "class_body") || findChildByType8(node, "interface_body") || findChildByType8(node, "enum_body") || findChildByType8(node, "annotation_type_body") || findChildByType8(node, "record_declaration_body");
+  if (body) {
+    walkNode8(body, context);
+  }
+  context.currentScope.pop();
+  context.currentClass = oldClass;
+}
+function processInterfaceList(node, sourceId, context) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === "type_identifier" || child.type === "generic_type" || child.type === "scoped_type_identifier") {
+      const baseName = extractTypeName3(child, context);
+      if (baseName) {
+        const baseId = resolveSymbol7(baseName, context);
+        if (baseId) {
+          context.edges.push({
+            source: sourceId,
+            target: baseId,
+            kind: "implements",
+            filePath: context.filePath,
+            line: child.startPosition.row + 1
+          });
+        }
+      }
+    }
+  }
+}
+function processEnumDeclaration3(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText7(nameNode, context);
+  const exported = hasModifier2(node, context, "public");
+  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
+  });
+  const body = node.childForFieldName("body") || findChildByType8(node, "enum_body");
+  if (body) {
+    const constants = findChildrenByType3(body, "enum_constant");
+    for (const constant of constants) {
+      const constNameNode = constant.childForFieldName("name");
+      if (!constNameNode) continue;
+      const constName = nodeText7(constNameNode, context);
+      const constId = `${context.filePath}::${name}.${constName}`;
+      context.symbols.push({
+        id: constId,
+        name: constName,
+        kind: "constant",
+        filePath: context.filePath,
+        startLine: constant.startPosition.row + 1,
+        endLine: constant.endPosition.row + 1,
+        exported,
+        scope: name
+      });
+    }
+    const oldClass = context.currentClass;
+    context.currentClass = name;
+    context.currentScope.push(name);
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child && child.type !== "enum_constant") {
+        walkNode8(child, context);
+      }
+    }
+    context.currentScope.pop();
+    context.currentClass = oldClass;
+  }
+}
+function processMethodDeclaration3(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText7(nameNode, context);
+  const exported = hasModifier2(node, context, "public");
+  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) {
+    walkNode8(body, context);
+  }
+  context.currentScope.pop();
+}
+function processConstructorDeclaration2(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText7(nameNode, context);
+  const exported = hasModifier2(node, context, "public");
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "method",
+    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) {
+    walkNode8(body, context);
+  }
+  context.currentScope.pop();
+}
+function processFieldDeclaration(node, context) {
+  const declarator = findDescendantByTypes(node, ["variable_declarator"]);
+  if (!declarator) return;
+  const nameNode = declarator.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText7(nameNode, context);
+  const exported = hasModifier2(node, context, "public");
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  const isConstant = hasModifier2(node, context, "static") && hasModifier2(node, context, "final");
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: isConstant ? "constant" : "property",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported,
+    scope
+  });
+}
+function processConstantDeclaration(node, context) {
+  const declarator = findDescendantByTypes(node, ["variable_declarator"]);
+  if (!declarator) return;
+  const nameNode = declarator.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText7(nameNode, context);
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${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: true,
+    // Interface constants are always public
+    scope
+  });
+}
+function processAnnotationElement(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const name = nodeText7(nameNode, context);
+  const scope = context.currentClass || void 0;
+  const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${context.filePath}::${name}`;
+  context.symbols.push({
+    id: symbolId,
+    name,
+    kind: "method",
+    filePath: context.filePath,
+    startLine: node.startPosition.row + 1,
+    endLine: node.endPosition.row + 1,
+    exported: true,
+    scope
+  });
+}
+function processCallExpression8(node, context) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return;
+  const calleeName = nodeText7(nameNode, context);
+  const builtins = [
+    "toString",
+    "equals",
+    "hashCode",
+    "getClass",
+    "println",
+    "printf",
+    "format",
+    "parseInt",
+    "valueOf",
+    "length",
+    "size",
+    "get",
+    "set",
+    "add",
+    "remove",
+    "contains",
+    "isEmpty",
+    "stream",
+    "collect",
+    "map",
+    "filter",
+    "forEach",
+    "of",
+    "orElse",
+    "orElseThrow",
+    "isPresent",
+    "ifPresent",
+    "close",
+    "flush",
+    "write",
+    "read"
+  ];
+  if (builtins.includes(calleeName)) return;
+  const callerId = getCurrentSymbolId8(context);
+  if (!callerId) return;
+  const calleeId = resolveSymbol7(calleeName, context);
+  if (calleeId) {
+    context.edges.push({
+      source: callerId,
+      target: calleeId,
+      kind: "calls",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+}
+function processObjectCreation(node, context) {
+  const typeNode = node.childForFieldName("type");
+  if (!typeNode) return;
+  const typeName = extractTypeName3(typeNode, context);
+  if (!typeName) return;
+  const callerId = getCurrentSymbolId8(context);
+  if (!callerId) return;
+  const targetId = resolveSymbol7(typeName, context);
+  if (targetId) {
+    context.edges.push({
+      source: callerId,
+      target: targetId,
+      kind: "references",
+      filePath: context.filePath,
+      line: node.startPosition.row + 1
+    });
+  }
+  const classBody = findChildByType8(node, "class_body");
+  if (classBody) {
+    const anonName = `<anonymous:${typeName}>`;
+    const anonId = `${context.filePath}::${anonName}:${node.startPosition.row + 1}`;
+    context.symbols.push({
+      id: anonId,
+      name: anonName,
+      kind: "class",
+      filePath: context.filePath,
+      startLine: node.startPosition.row + 1,
+      endLine: node.endPosition.row + 1,
+      exported: false,
+      scope: context.currentClass || void 0
+    });
+    const oldClass = context.currentClass;
+    context.currentClass = anonName;
+    context.currentScope.push(anonName);
+    walkNode8(classBody, context);
+    context.currentScope.pop();
+    context.currentClass = oldClass;
+  }
+}
+function processLambdaExpression(node, context) {
+  const parent = node.parent;
+  if (!parent) return;
+  if (parent.type === "variable_declarator") {
+    const nameNode = parent.childForFieldName("name");
+    if (nameNode) {
+      const name = nodeText7(nameNode, context);
+      const scope = context.currentClass || void 0;
+      const symbolId = scope ? `${context.filePath}::${scope}.${name}` : `${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: false,
+        scope
+      });
+    }
+  }
+}
+function parsePomXml(filePath, sourceCode, projectRoot) {
+  const symbols = [];
+  const edges = [];
+  const lines = sourceCode.split("\n");
+  const projectName = basename2(dirname8(join9(projectRoot, filePath)));
+  symbols.push({
+    id: `${filePath}::${projectName}`,
+    name: projectName,
+    kind: "module",
+    filePath,
+    startLine: 1,
+    endLine: lines.length,
+    exported: true
+  });
+  let inDependency = false;
+  let groupId = "";
+  let artifactId = "";
+  let version = "";
+  let depStartLine = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    if (/<dependency>/.test(line)) {
+      inDependency = true;
+      groupId = "";
+      artifactId = "";
+      version = "";
+      depStartLine = lineNum;
+    }
+    if (inDependency) {
+      const gMatch = line.match(/<groupId>([^<]+)<\/groupId>/);
+      if (gMatch) groupId = gMatch[1];
+      const aMatch = line.match(/<artifactId>([^<]+)<\/artifactId>/);
+      if (aMatch) artifactId = aMatch[1];
+      const vMatch = line.match(/<version>([^<]+)<\/version>/);
+      if (vMatch) version = vMatch[1];
+    }
+    if (/<\/dependency>/.test(line) && inDependency) {
+      inDependency = false;
+      if (groupId && artifactId) {
+        const depName = `${groupId}:${artifactId}`;
+        const displayVersion = version || "managed";
+        symbols.push({
+          id: `${filePath}::dep:${depName}`,
+          name: `${depName}@${displayVersion}`,
+          kind: "import",
+          filePath,
+          startLine: depStartLine,
+          endLine: lineNum,
+          exported: false
+        });
+      }
+    }
+    const moduleMatch = line.match(/<module>([^<]+)<\/module>/);
+    if (moduleMatch) {
+      const modulePath = moduleMatch[1];
+      const pomDir = dirname8(join9(projectRoot, filePath));
+      const resolvedModule = resolve4(pomDir, modulePath);
+      const relativeModule = resolvedModule.startsWith(projectRoot + "/") ? resolvedModule.substring(projectRoot.length + 1) : null;
+      if (relativeModule) {
+        const modulePom = join9(relativeModule, "pom.xml");
+        if (existsSync9(join9(projectRoot, modulePom))) {
+          edges.push({
+            source: `${filePath}::__file__`,
+            target: `${modulePom}::__file__`,
+            kind: "imports",
+            filePath,
+            line: lineNum
+          });
+        }
+      }
+    }
+  }
+  return { filePath, symbols, edges };
+}
+function parseGradleBuild(filePath, sourceCode, projectRoot) {
+  const symbols = [];
+  const edges = [];
+  const lines = sourceCode.split("\n");
+  const projectName = basename2(dirname8(join9(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 depMatch = line.match(
+      /(?:implementation|api|compileOnly|runtimeOnly|testImplementation|testRuntimeOnly|annotationProcessor)\s*[\(]?\s*['"]([^'"]+)['"]\s*[\)]?/
+    );
+    if (depMatch) {
+      const depCoord = depMatch[1];
+      if (!depCoord.startsWith(":")) {
+        symbols.push({
+          id: `${filePath}::dep:${depCoord}`,
+          name: depCoord,
+          kind: "import",
+          filePath,
+          startLine: lineNum,
+          endLine: lineNum,
+          exported: false
+        });
+      }
+    }
+    const projectMatch = line.match(/project\s*\(\s*['":]+([^'")\s]+)['"]*\s*\)/);
+    if (projectMatch) {
+      const moduleName = projectMatch[1].replace(/^:/, "");
+      const candidates = [
+        join9(moduleName, "build.gradle"),
+        join9(moduleName, "build.gradle.kts")
+      ];
+      for (const candidate of candidates) {
+        if (existsSync9(join9(projectRoot, candidate))) {
+          edges.push({
+            source: `${filePath}::__file__`,
+            target: `${candidate}::__file__`,
+            kind: "imports",
+            filePath,
+            line: lineNum
+          });
+          break;
+        }
+      }
+    }
+  }
+  return { filePath, symbols, edges };
+}
+function resolveJavaImport(importPath, currentFile, projectRoot) {
+  const cleanPath2 = importPath.replace(/\.\*$/, "");
+  const javaPath = cleanPath2.replace(/\./g, "/") + ".java";
+  const sourceRoots = [
+    "",
+    "src/main/java",
+    "src",
+    "app/src/main/java"
+  ];
+  for (const root of sourceRoots) {
+    const candidate = root ? join9(root, javaPath) : javaPath;
+    const fullPath = join9(projectRoot, candidate);
+    if (existsSync9(fullPath)) {
+      return candidate;
+    }
+  }
+  if (importPath.endsWith(".*")) {
+    const packagePath = cleanPath2.replace(/\./g, "/");
+    for (const root of sourceRoots) {
+      const candidate = root ? join9(root, packagePath) : packagePath;
+      const fullPath = join9(projectRoot, candidate);
+      if (existsSync9(fullPath)) {
+        try {
+          const stats = statSync3(fullPath);
+          if (stats.isDirectory()) {
+            const javaFiles = readdirSync6(fullPath).filter((f) => f.endsWith(".java"));
+            if (javaFiles.length > 0) {
+              return join9(candidate, javaFiles[0]);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return null;
+}
+function resolveSymbol7(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 hasModifier2(node, context, modifier) {
+  const modifiers = node.childForFieldName("modifiers") || findChildByType8(node, "modifiers");
+  if (modifiers) {
+    for (let i = 0; i < modifiers.childCount; i++) {
+      const child = modifiers.child(i);
+      if (child && nodeText7(child, context) === modifier) {
+        return true;
+      }
+    }
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === modifier) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractTypeName3(node, context) {
+  const text = nodeText7(node, context).trim();
+  if (!text) return null;
+  const angleBracketIdx = text.indexOf("<");
+  const name = angleBracketIdx > 0 ? text.substring(0, angleBracketIdx) : text;
+  const dotIdx = name.lastIndexOf(".");
+  return dotIdx >= 0 ? name.substring(dotIdx + 1) : name;
+}
+function findChildByType8(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 findChildrenByType3(node, type) {
+  const results = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === type) results.push(child);
+  }
+  return results;
+}
+function findDescendantByTypes(node, types) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (types.includes(child.type)) return child;
+    const found = findDescendantByTypes(child, types);
+    if (found) return found;
+  }
+  return null;
+}
+function nodeText7(node, context) {
+  return context.sourceCode.substring(node.startIndex, node.endIndex);
+}
+function getCurrentSymbolId8(context) {
+  if (context.currentScope.length === 0) return null;
+  return `${context.filePath}::${context.currentScope[context.currentScope.length - 1]}`;
+}
+var javaParser = {
+  name: "java",
+  extensions: [".java", "pom.xml", "build.gradle", "build.gradle.kts"],
+  parseFile: parseJavaFile
+};
+
 // src/parser/detect.ts
 var parsers = [
   typescriptParser,
@@ -2789,11 +4103,14 @@ var parsers = [
   javascriptParser,
   goParser,
   rustParser,
-  cParser
+  cParser,
+  csharpParser,
+  javaParser
 ];
 function getParserForFile(filePath) {
-  const ext = extname3(filePath).toLowerCase();
-  return parsers.find((p) => p.extensions.includes(ext)) || null;
+  const ext = extname5(filePath).toLowerCase();
+  const fileName = basename3(filePath);
+  return parsers.find((p) => p.extensions.includes(ext) || p.extensions.includes(fileName)) || null;
 }
 
 // src/parser/index.ts
@@ -2801,7 +4118,7 @@ import { minimatch } from "minimatch";
 var MAX_FILE_SIZE = 1e6;
 function shouldParseFile(fullPath) {
   try {
-    const stats = statSync2(fullPath);
+    const stats = statSync4(fullPath);
     if (stats.size > MAX_FILE_SIZE) {
       console.error(`[Parser] Skipping ${fullPath} \u2014 file too large (${(stats.size / 1024).toFixed(0)}KB)`);
       return false;
@@ -2819,8 +4136,8 @@ async function parseProject(projectRoot, options) {
   let errorFiles = 0;
   for (const file of files) {
     try {
-      const fullPath = join8(projectRoot, file);
-      if (!resolve3(fullPath).startsWith(resolve3(projectRoot))) {
+      const fullPath = join10(projectRoot, file);
+      if (!resolve5(fullPath).startsWith(resolve5(projectRoot))) {
         skippedFiles++;
         continue;
       }
@@ -2849,7 +4166,7 @@ async function parseProject(projectRoot, options) {
         skippedFiles++;
         continue;
       }
-      const sourceCode = readFileSync5(fullPath, "utf-8");
+      const sourceCode = readFileSync7(fullPath, "utf-8");
       const parsed = parser.parseFile(file, sourceCode, projectRoot);
       parsedFiles.push(parsed);
     } catch (err) {
@@ -2872,13 +4189,15 @@ async function parseProject(projectRoot, options) {
 }
 
 // src/cross-language/detectors/rest-api.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join9, resolve as resolve4 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join11, 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";
   if (filePath.endsWith(".py")) return "python";
   if (filePath.endsWith(".go")) return "go";
+  if (filePath.endsWith(".cs") || filePath.endsWith(".csx")) return "csharp";
+  if (filePath.endsWith(".java")) return "java";
   return "unknown";
 }
 function normalizePath(routePath) {
@@ -3015,9 +4334,136 @@ function extractRouteDefinitions(source, filePath) {
         }
       }
     }
+    if (lang === "csharp") {
+      const attrMatch = line.match(/\[\s*Http(Get|Post|Put|Delete|Patch)\s*\(\s*"([^"]+)"\s*\)\s*\]/);
+      if (attrMatch) {
+        routes.push({
+          method: attrMatch[1].toUpperCase(),
+          path: attrMatch[2],
+          normalizedPath: normalizePath(attrMatch[2]),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const routeAttrMatch = line.match(/\[\s*Route\s*\(\s*"([^"]+)"\s*\)\s*\]/);
+      if (routeAttrMatch) {
+        let routePath = routeAttrMatch[1];
+        if (routePath.includes("[controller]")) {
+          const classMatch = source.match(/class\s+(\w+?)Controller\s/);
+          if (classMatch) {
+            routePath = routePath.replace("[controller]", classMatch[1].toLowerCase());
+          }
+        }
+        if (!routePath.startsWith("/")) routePath = "/" + routePath;
+        routes.push({
+          method: "ANY",
+          path: routePath,
+          normalizedPath: normalizePath(routePath),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const minimalMatch = line.match(/app\s*\.\s*Map(Get|Post|Put|Delete|Patch)\s*\(\s*"([^"]+)"/);
+      if (minimalMatch) {
+        const path6 = minimalMatch[2];
+        if (path6.startsWith("/")) {
+          routes.push({
+            method: minimalMatch[1].toUpperCase(),
+            path: path6,
+            normalizedPath: normalizePath(path6),
+            file: filePath,
+            line: i + 1
+          });
+        }
+      }
+    }
+    if (lang === "java") {
+      const springMethodMatch = line.match(/@(Get|Post|Put|Delete|Patch)Mapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/);
+      if (springMethodMatch) {
+        const method = springMethodMatch[1].toUpperCase();
+        let path6 = springMethodMatch[2];
+        const classPrefix = findClassLevelPrefix(source);
+        if (classPrefix) path6 = classPrefix + path6;
+        if (!path6.startsWith("/")) path6 = "/" + path6;
+        routes.push({
+          method,
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      if (!springMethodMatch) {
+        const springNoPathMatch = line.match(/@(Get|Post|Put|Delete|Patch)Mapping\s*$/);
+        if (springNoPathMatch) {
+          const method = springNoPathMatch[1].toUpperCase();
+          const classPrefix = findClassLevelPrefix(source);
+          if (classPrefix) {
+            routes.push({
+              method,
+              path: classPrefix,
+              normalizedPath: normalizePath(classPrefix),
+              file: filePath,
+              line: i + 1
+            });
+          }
+        }
+      }
+      const requestMappingMatch = line.match(/@RequestMapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/);
+      if (requestMappingMatch) {
+        let path6 = requestMappingMatch[1];
+        if (!path6.startsWith("/")) path6 = "/" + path6;
+        const methodMatch = line.match(/method\s*=\s*RequestMethod\.(\w+)/);
+        const method = methodMatch ? methodMatch[1].toUpperCase() : "ANY";
+        routes.push({
+          method,
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const jaxPathMatch = line.match(/@Path\s*\(\s*["']([^"']+)["']\s*\)/);
+      if (jaxPathMatch) {
+        let path6 = jaxPathMatch[1];
+        if (!path6.startsWith("/")) path6 = "/" + path6;
+        const nextLine = i + 1 < lines.length ? lines[i + 1] : "";
+        const prevLine = i > 0 ? lines[i - 1] : "";
+        const jaxMethodMatch = (nextLine + prevLine).match(/@(GET|POST|PUT|DELETE|PATCH)/);
+        const method = jaxMethodMatch ? jaxMethodMatch[1] : "ANY";
+        routes.push({
+          method,
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+      const webFluxMatch = line.match(/(?:route|andRoute)\s*\(\s*(GET|POST|PUT|DELETE|PATCH)\s*\(\s*["']([^"']+)["']\s*\)/);
+      if (webFluxMatch) {
+        const path6 = webFluxMatch[2].startsWith("/") ? webFluxMatch[2] : "/" + webFluxMatch[2];
+        routes.push({
+          method: webFluxMatch[1].toUpperCase(),
+          path: path6,
+          normalizedPath: normalizePath(path6),
+          file: filePath,
+          line: i + 1
+        });
+      }
+    }
   }
   return routes;
 }
+function findClassLevelPrefix(source) {
+  const match = source.match(/@RequestMapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/);
+  if (match) {
+    let path6 = match[1];
+    if (!path6.startsWith("/")) path6 = "/" + path6;
+    if (path6.endsWith("/") && path6.length > 1) path6 = path6.slice(0, -1);
+    return path6;
+  }
+  return null;
+}
 function matchPaths(callPath, routeNormalized) {
   const normalizedCall = normalizePath(stripTrailingSlash(callPath));
   const normalizedRoute = stripTrailingSlash(routeNormalized);
@@ -3042,7 +4488,7 @@ function getConfidence(callPath, callMethod, routePath, routeMethod) {
   const normalizedCall = normalizePath(stripTrailingSlash(callPath));
   const normalizedRoute = normalizePath(stripTrailingSlash(routePath));
   const exactPath = normalizedCall === normalizedRoute;
-  const methodMatch = callMethod === routeMethod;
+  const methodMatch = callMethod === routeMethod || routeMethod === "ANY";
   if (exactPath && methodMatch) return "high";
   if (exactPath) return "medium";
   if (methodMatch) return "medium";
@@ -3053,11 +4499,11 @@ function detectRestApiEdges(files, projectRoot) {
   const allCalls = [];
   const allRoutes = [];
   for (const file of files) {
-    const fullPath = join9(projectRoot, file.filePath);
-    if (!resolve4(fullPath).startsWith(resolve4(projectRoot))) continue;
+    const fullPath = join11(projectRoot, file.filePath);
+    if (!resolve6(fullPath).startsWith(resolve6(projectRoot))) continue;
     let source;
     try {
-      source = readFileSync6(fullPath, "utf-8");
+      source = readFileSync8(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -3093,8 +4539,8 @@ function detectRestApiEdges(files, projectRoot) {
 }
 
 // src/cross-language/detectors/subprocess.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join10, resolve as resolve5, basename } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join12, resolve as resolve7, basename as basename4 } from "path";
 var SCRIPT_EXTENSIONS = [".py", ".js", ".ts", ".go", ".rs"];
 function getLanguage2(filePath) {
   if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "typescript";
@@ -3193,16 +4639,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 = basename(f.filePath);
+    const base = basename4(f.filePath);
     if (!basenameMap.has(base)) basenameMap.set(base, []);
     basenameMap.get(base).push(f.filePath);
   }
   for (const file of files) {
-    const fullPath = join10(projectRoot, file.filePath);
-    if (!resolve5(fullPath).startsWith(resolve5(projectRoot))) continue;
+    const fullPath = join12(projectRoot, file.filePath);
+    if (!resolve7(fullPath).startsWith(resolve7(projectRoot))) continue;
     let source;
     try {
-      source = readFileSync7(fullPath, "utf-8");
+      source = readFileSync9(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -3214,7 +4660,7 @@ function detectSubprocessEdges(files, projectRoot) {
         targetFile = call.calledFile;
         confidence = "high";
       } else {
-        const base = basename(call.calledFile);
+        const base = basename4(call.calledFile);
         const candidates = basenameMap.get(base);
         if (candidates && candidates.length > 0) {
           const exactCandidate = candidates.find((c) => c.endsWith(call.calledFile));
@@ -3593,7 +5039,7 @@ function getArchitectureSummary(graph) {
 }
 
 // src/health/metrics.ts
-import { dirname as dirname7 } from "path";
+import { dirname as dirname9 } from "path";
 function scoreToGrade(score) {
   if (score >= 90) return "A";
   if (score >= 80) return "B";
@@ -3626,8 +5072,8 @@ function calculateCouplingScore(graph) {
       totalEdges++;
       fileConnections.set(sourceAttrs.filePath, (fileConnections.get(sourceAttrs.filePath) || 0) + 1);
       fileConnections.set(targetAttrs.filePath, (fileConnections.get(targetAttrs.filePath) || 0) + 1);
-      const sourceDir = dirname7(sourceAttrs.filePath).split("/")[0];
-      const targetDir = dirname7(targetAttrs.filePath).split("/")[0];
+      const sourceDir = dirname9(sourceAttrs.filePath).split("/")[0];
+      const targetDir = dirname9(targetAttrs.filePath).split("/")[0];
       if (sourceDir !== targetDir) {
         crossDirEdges++;
       }
@@ -3674,8 +5120,8 @@ function calculateCohesionScore(graph) {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
     if (sourceAttrs.filePath !== targetAttrs.filePath) {
-      const sourceDir = dirname7(sourceAttrs.filePath);
-      const targetDir = dirname7(targetAttrs.filePath);
+      const sourceDir = dirname9(sourceAttrs.filePath);
+      const targetDir = dirname9(targetAttrs.filePath);
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { internal: 0, total: 0 });
       }
@@ -3957,8 +5403,8 @@ function calculateDepthScore(graph) {
 }
 
 // src/health/index.ts
-import { readFileSync as readFileSync8, writeFileSync, existsSync as existsSync8, mkdirSync } from "fs";
-import { dirname as dirname8, resolve as resolve6 } from "path";
+import { readFileSync as readFileSync10, writeFileSync, existsSync as existsSync10, mkdirSync } from "fs";
+import { dirname as dirname10, resolve as resolve8 } from "path";
 function calculateHealthScore(graph, projectRoot) {
   const coupling = calculateCouplingScore(graph);
   const cohesion = calculateCohesionScore(graph);
@@ -4057,8 +5503,8 @@ function getHealthTrend(projectRoot, currentScore) {
   }
 }
 function saveHealthHistory(projectRoot, report) {
-  const resolvedRoot = resolve6(projectRoot);
-  const historyFile = resolve6(resolvedRoot, ".depwire", "health-history.json");
+  const resolvedRoot = resolve8(projectRoot);
+  const historyFile = resolve8(resolvedRoot, ".depwire", "health-history.json");
   if (!historyFile.startsWith(resolvedRoot)) {
     return;
   }
@@ -4073,10 +5519,10 @@ function saveHealthHistory(projectRoot, report) {
     }))
   };
   let history = [];
-  if (existsSync8(historyFile)) {
+  if (existsSync10(historyFile)) {
     try {
       if (!historyFile.startsWith(resolvedRoot)) return;
-      const content = readFileSync8(historyFile, "utf-8");
+      const content = readFileSync10(historyFile, "utf-8");
       history = JSON.parse(content);
     } catch {
     }
@@ -4085,19 +5531,19 @@ function saveHealthHistory(projectRoot, report) {
   if (history.length > 50) {
     history = history.slice(-50);
   }
-  mkdirSync(dirname8(historyFile), { recursive: true });
+  mkdirSync(dirname10(historyFile), { recursive: true });
   if (!historyFile.startsWith(resolvedRoot)) return;
   writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf-8");
 }
 function loadHealthHistory(projectRoot) {
-  const resolvedRoot = resolve6(projectRoot);
-  const historyFile = resolve6(resolvedRoot, ".depwire", "health-history.json");
-  if (!historyFile.startsWith(resolvedRoot) || !existsSync8(historyFile)) {
+  const resolvedRoot = resolve8(projectRoot);
+  const historyFile = resolve8(resolvedRoot, ".depwire", "health-history.json");
+  if (!historyFile.startsWith(resolvedRoot) || !existsSync10(historyFile)) {
     return [];
   }
   try {
     if (!historyFile.startsWith(resolvedRoot)) return [];
-    const content = readFileSync8(historyFile, "utf-8");
+    const content = readFileSync10(historyFile, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
@@ -4106,7 +5552,7 @@ function loadHealthHistory(projectRoot) {
 
 // src/dead-code/detector.ts
 import path2 from "path";
-import { readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync11 } from "fs";
 function findDeadSymbols(graph, projectRoot, includeTests = false, debug = false) {
   const deadSymbols = [];
   const context = { graph, projectRoot };
@@ -4218,8 +5664,10 @@ function isRelevantForDeadCodeDetection(attrs) {
     "class",
     "interface",
     "type",
+    "type_alias",
     "enum",
     "const",
+    "constant",
     "let",
     "var",
     "method",
@@ -4237,11 +5685,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) || !existsSync9(packageJsonPath)) {
+  if (!packageJsonPath.startsWith(resolvedRoot) || !existsSync11(packageJsonPath)) {
     return entryPoints;
   }
   try {
-    const packageJson = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
     if (packageJson.main) {
       entryPoints.add(path2.resolve(projectRoot, packageJson.main));
     }
@@ -4314,7 +5762,8 @@ function isTypeDeclarationFile(filePath) {
   return filePath.endsWith(".d.ts");
 }
 function isFrameworkAutoLoadedFile(filePath) {
-  return filePath.includes("/pages/") || filePath.includes("/routes/") || filePath.includes("/middleware/") || filePath.includes("/commands/") || filePath.includes("/api/") || filePath.includes("/app/");
+  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/");
 }
 
 // src/dead-code/classifier.ts
@@ -4382,8 +5831,8 @@ function generateReason(symbol, confidence) {
   return "Potentially unused";
 }
 function isBarrelFile(filePath) {
-  const basename5 = path3.basename(filePath);
-  return basename5 === "index.ts" || basename5 === "index.js";
+  const basename8 = path3.basename(filePath);
+  return basename8 === "index.ts" || basename8 === "index.js";
 }
 function isTestFile2(filePath) {
   return filePath.includes("__tests__/") || filePath.includes(".test.") || filePath.includes(".spec.") || filePath.includes("/test/") || filePath.includes("/tests/");
@@ -4562,11 +6011,11 @@ function filterByConfidence(symbols, minConfidence) {
 }
 
 // src/docs/generator.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync12 } from "fs";
-import { join as join14 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync14 } from "fs";
+import { join as join16 } from "path";
 
 // src/docs/architecture.ts
-import { dirname as dirname9 } from "path";
+import { dirname as dirname11 } from "path";
 
 // src/docs/templates.ts
 function header(text, level = 1) {
@@ -4717,7 +6166,7 @@ function generateModuleStructure(graph) {
 function getDirectoryStats(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, {
@@ -4742,7 +6191,7 @@ function getDirectoryStats(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());
     }
@@ -4757,8 +6206,8 @@ function getDirectoryStats(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname9(sourceAttrs.filePath);
-    const targetDir = dirname9(targetAttrs.filePath);
+    const sourceDir = dirname11(sourceAttrs.filePath);
+    const targetDir = dirname11(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -4965,7 +6414,7 @@ function detectCycles(graph) {
 }
 
 // src/docs/conventions.ts
-import { basename as basename2, extname as extname4 } from "path";
+import { basename as basename5, extname as extname6 } from "path";
 function generateConventions(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5003,7 +6452,7 @@ function generateFileOrganization(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename2(attrs.filePath);
+      const fileName = basename5(attrs.filePath);
       if (fileName === "index.ts" || fileName === "index.js" || fileName === "index.tsx" || fileName === "index.jsx") {
         barrelFileCount++;
       }
@@ -5062,7 +6511,7 @@ function generateNamingPatterns(graph) {
   graph.forEachNode((node, attrs) => {
     if (!files.has(attrs.filePath)) {
       files.add(attrs.filePath);
-      const fileName = basename2(attrs.filePath, extname4(attrs.filePath));
+      const fileName = basename5(attrs.filePath, extname6(attrs.filePath));
       if (isCamelCase(fileName)) patterns.files.camelCase++;
       else if (isPascalCase(fileName)) patterns.files.PascalCase++;
       else if (isKebabCase(fileName)) patterns.files.kebabCase++;
@@ -5739,7 +7188,7 @@ function detectCyclesDetailed(graph) {
 }
 
 // src/docs/onboarding.ts
-import { dirname as dirname10 } from "path";
+import { dirname as dirname12 } from "path";
 function generateOnboarding(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -5798,7 +7247,7 @@ function generateQuickOrientation(graph) {
   const primaryLang = Object.entries(languages2).sort((a, b) => b[1] - a[1])[0];
   const dirs = /* @__PURE__ */ new Set();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname12(attrs.filePath);
     if (dir !== ".") {
       const topLevel = dir.split("/")[0];
       dirs.add(topLevel);
@@ -5902,7 +7351,7 @@ function generateModuleMap(graph) {
 function getDirectoryStats2(graph) {
   const dirMap = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname12(attrs.filePath);
     if (dir === ".") return;
     if (!dirMap.has(dir)) {
       dirMap.set(dir, {
@@ -5917,7 +7366,7 @@ function getDirectoryStats2(graph) {
   });
   const filesPerDir = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname12(attrs.filePath);
     if (!filesPerDir.has(dir)) {
       filesPerDir.set(dir, /* @__PURE__ */ new Set());
     }
@@ -5932,8 +7381,8 @@ function getDirectoryStats2(graph) {
   graph.forEachEdge((edge, attrs, source, target) => {
     const sourceAttrs = graph.getNodeAttributes(source);
     const targetAttrs = graph.getNodeAttributes(target);
-    const sourceDir = dirname10(sourceAttrs.filePath);
-    const targetDir = dirname10(targetAttrs.filePath);
+    const sourceDir = dirname12(sourceAttrs.filePath);
+    const targetDir = dirname12(targetAttrs.filePath);
     if (sourceDir !== targetDir) {
       if (!dirEdges.has(sourceDir)) {
         dirEdges.set(sourceDir, { in: 0, out: 0 });
@@ -6014,7 +7463,7 @@ function detectClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname10(attrs.filePath);
+    const dir = dirname12(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -6068,8 +7517,8 @@ function inferClusterName(files) {
   if (sortedWords.length > 0 && sortedWords[0][1] > 1) {
     return capitalizeFirst2(sortedWords[0][0]);
   }
-  const commonDir = dirname10(files[0]);
-  if (files.every((f) => dirname10(f) === commonDir)) {
+  const commonDir = dirname12(files[0]);
+  if (files.every((f) => dirname12(f) === commonDir)) {
     return capitalizeFirst2(commonDir.split("/").pop() || "Core");
   }
   return "Core";
@@ -6127,7 +7576,7 @@ function generateDepwireUsage(projectRoot) {
 }
 
 // src/docs/files.ts
-import { dirname as dirname11, basename as basename3 } from "path";
+import { dirname as dirname13, basename as basename6 } from "path";
 function generateFiles(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6231,7 +7680,7 @@ function generateDirectoryBreakdown(graph) {
   const fileStats = getFileStats2(graph);
   const dirMap = /* @__PURE__ */ new Map();
   for (const file of fileStats) {
-    const dir = dirname11(file.filePath);
+    const dir = dirname13(file.filePath);
     const topDir = dir === "." ? "." : dir.split("/")[0];
     if (!dirMap.has(topDir)) {
       dirMap.set(topDir, {
@@ -6246,7 +7695,7 @@ function generateDirectoryBreakdown(graph) {
     dirStats.symbolCount += file.symbolCount;
     if (file.totalConnections > dirStats.maxConnections) {
       dirStats.maxConnections = file.totalConnections;
-      dirStats.mostConnectedFile = basename3(file.filePath);
+      dirStats.mostConnectedFile = basename6(file.filePath);
     }
   }
   if (dirMap.size === 0) {
@@ -6874,7 +8323,7 @@ function generateRecommendations(graph) {
 }
 
 // src/docs/tests.ts
-import { basename as basename4, dirname as dirname12 } from "path";
+import { basename as basename7, dirname as dirname14 } from "path";
 function generateTests(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -6902,8 +8351,8 @@ function getFileCount8(graph) {
   return files.size;
 }
 function isTestFile3(filePath) {
-  const fileName = basename4(filePath).toLowerCase();
-  const dirPath = dirname12(filePath).toLowerCase();
+  const fileName = basename7(filePath).toLowerCase();
+  const dirPath = dirname14(filePath).toLowerCase();
   if (dirPath.includes("test") || dirPath.includes("spec") || dirPath.includes("__tests__")) {
     return true;
   }
@@ -6961,13 +8410,13 @@ function generateTestFileInventory(graph) {
   return output;
 }
 function matchTestToSource(testFile) {
-  const testFileName = basename4(testFile);
-  const testDir = dirname12(testFile);
+  const testFileName = basename7(testFile);
+  const testDir = dirname14(testFile);
   let sourceFileName = testFileName.replace(/\.test\./g, ".").replace(/\.spec\./g, ".").replace(/_test\./g, ".").replace(/_spec\./g, ".");
   const possiblePaths = [];
   possiblePaths.push(testDir + "/" + sourceFileName);
   if (testDir.endsWith("/test") || testDir.endsWith("/tests") || testDir.endsWith("/__tests__")) {
-    const parentDir = dirname12(testDir);
+    const parentDir = dirname14(testDir);
     possiblePaths.push(parentDir + "/" + sourceFileName);
   }
   if (testDir.includes("test")) {
@@ -7123,7 +8572,7 @@ function generateTestCoverageMap(graph) {
   const rows = mappings.slice(0, 30).map((m) => [
     `\`${m.sourceFile}\``,
     m.hasTest ? "\u2705" : "\u274C",
-    m.testFile ? `\`${basename4(m.testFile)}\`` : "-",
+    m.testFile ? `\`${basename7(m.testFile)}\`` : "-",
     formatNumber(m.symbolCount)
   ]);
   let output = table(headers, rows);
@@ -7164,7 +8613,7 @@ function generateTestStatistics(graph) {
 `;
   const dirTestCoverage = /* @__PURE__ */ new Map();
   for (const sourceFile of sourceFiles) {
-    const dir = dirname12(sourceFile).split("/")[0];
+    const dir = dirname14(sourceFile).split("/")[0];
     if (!dirTestCoverage.has(dir)) {
       dirTestCoverage.set(dir, { total: 0, tested: 0 });
     }
@@ -7187,7 +8636,7 @@ function generateTestStatistics(graph) {
 }
 
 // src/docs/history.ts
-import { dirname as dirname13 } from "path";
+import { dirname as dirname15 } from "path";
 import { execSync } from "child_process";
 function generateHistory(graph, projectRoot, version) {
   let output = "";
@@ -7468,7 +8917,7 @@ function generateFeatureClusters(graph) {
   const dirFiles = /* @__PURE__ */ new Map();
   const fileEdges = /* @__PURE__ */ new Map();
   graph.forEachNode((node, attrs) => {
-    const dir = dirname13(attrs.filePath);
+    const dir = dirname15(attrs.filePath);
     if (!dirFiles.has(dir)) {
       dirFiles.set(dir, /* @__PURE__ */ new Set());
     }
@@ -7550,7 +8999,7 @@ function capitalizeFirst3(str) {
 }
 
 // src/docs/current.ts
-import { dirname as dirname14 } from "path";
+import { dirname as dirname16 } from "path";
 function generateCurrent(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7688,7 +9137,7 @@ function generateCompleteFileIndex(graph) {
   fileInfos.sort((a, b) => a.filePath.localeCompare(b.filePath));
   const dirGroups = /* @__PURE__ */ new Map();
   for (const info of fileInfos) {
-    const dir = dirname14(info.filePath);
+    const dir = dirname16(info.filePath);
     const topDir = dir === "." ? "root" : dir.split("/")[0];
     if (!dirGroups.has(topDir)) {
       dirGroups.set(topDir, []);
@@ -7899,8 +9348,8 @@ function getTopLevelDir2(filePath) {
 }
 
 // src/docs/status.ts
-import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
-import { resolve as resolve7 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync12 } from "fs";
+import { resolve as resolve9 } from "path";
 function generateStatus(graph, projectRoot, version) {
   let output = "";
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -7933,16 +9382,16 @@ function getFileCount11(graph) {
 }
 function extractComments(projectRoot, filePath) {
   const comments = [];
-  const resolvedRoot = resolve7(projectRoot);
-  const fullPath = resolve7(resolvedRoot, filePath);
+  const resolvedRoot = resolve9(projectRoot);
+  const fullPath = resolve9(resolvedRoot, filePath);
   if (!fullPath.startsWith(resolvedRoot)) {
     return comments;
   }
-  if (!existsSync10(fullPath)) {
+  if (!existsSync12(fullPath)) {
     return comments;
   }
   try {
-    const content = readFileSync10(fullPath, "utf-8");
+    const content = readFileSync12(fullPath, "utf-8");
     const lines = content.split("\n");
     const patterns = [
       { type: "TODO", regex: /(?:\/\/|#|\/\*)\s*TODO:?\s*(.+)/i },
@@ -8521,16 +9970,16 @@ function generateConfidenceSection(title, description, symbols, projectRoot) {
 }
 
 // src/docs/metadata.ts
-import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve10 } from "path";
 function loadMetadata(outputDir) {
-  const resolvedDir = resolve8(outputDir);
-  const metadataPath = resolve8(resolvedDir, "metadata.json");
-  if (!metadataPath.startsWith(resolvedDir) || !existsSync11(metadataPath)) {
+  const resolvedDir = resolve10(outputDir);
+  const metadataPath = resolve10(resolvedDir, "metadata.json");
+  if (!metadataPath.startsWith(resolvedDir) || !existsSync13(metadataPath)) {
     return null;
   }
   try {
-    const content = readFileSync11(metadataPath, "utf-8");
+    const content = readFileSync13(metadataPath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     console.error("Failed to load metadata:", err);
@@ -8538,8 +9987,8 @@ function loadMetadata(outputDir) {
   }
 }
 function saveMetadata(outputDir, metadata) {
-  const resolvedDir = resolve8(outputDir);
-  const metadataPath = resolve8(resolvedDir, "metadata.json");
+  const resolvedDir = resolve10(outputDir);
+  const metadataPath = resolve10(resolvedDir, "metadata.json");
   if (!metadataPath.startsWith(resolvedDir)) {
     throw new Error(`Path traversal attempt blocked: ${metadataPath}`);
   }
@@ -8585,7 +10034,7 @@ async function generateDocs(graph, projectRoot, version, parseTime, options) {
   const generated = [];
   const errors = [];
   try {
-    if (!existsSync12(options.outputDir)) {
+    if (!existsSync14(options.outputDir)) {
       mkdirSync2(options.outputDir, { recursive: true });
       if (options.verbose) {
         console.log(`Created output directory: ${options.outputDir}`);
@@ -8624,7 +10073,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 = join14(options.outputDir, "ARCHITECTURE.md");
+          const filePath = join16(options.outputDir, "ARCHITECTURE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ARCHITECTURE.md");
         } catch (err) {
@@ -8635,7 +10084,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 = join14(options.outputDir, "CONVENTIONS.md");
+          const filePath = join16(options.outputDir, "CONVENTIONS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CONVENTIONS.md");
         } catch (err) {
@@ -8646,7 +10095,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 = join14(options.outputDir, "DEPENDENCIES.md");
+          const filePath = join16(options.outputDir, "DEPENDENCIES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEPENDENCIES.md");
         } catch (err) {
@@ -8657,7 +10106,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 = join14(options.outputDir, "ONBOARDING.md");
+          const filePath = join16(options.outputDir, "ONBOARDING.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ONBOARDING.md");
         } catch (err) {
@@ -8668,7 +10117,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 = join14(options.outputDir, "FILES.md");
+          const filePath = join16(options.outputDir, "FILES.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("FILES.md");
         } catch (err) {
@@ -8679,7 +10128,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 = join14(options.outputDir, "API_SURFACE.md");
+          const filePath = join16(options.outputDir, "API_SURFACE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("API_SURFACE.md");
         } catch (err) {
@@ -8690,7 +10139,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 = join14(options.outputDir, "ERRORS.md");
+          const filePath = join16(options.outputDir, "ERRORS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("ERRORS.md");
         } catch (err) {
@@ -8701,7 +10150,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 = join14(options.outputDir, "TESTS.md");
+          const filePath = join16(options.outputDir, "TESTS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("TESTS.md");
         } catch (err) {
@@ -8712,7 +10161,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 = join14(options.outputDir, "HISTORY.md");
+          const filePath = join16(options.outputDir, "HISTORY.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HISTORY.md");
         } catch (err) {
@@ -8723,7 +10172,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 = join14(options.outputDir, "CURRENT.md");
+          const filePath = join16(options.outputDir, "CURRENT.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("CURRENT.md");
         } catch (err) {
@@ -8734,7 +10183,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 = join14(options.outputDir, "STATUS.md");
+          const filePath = join16(options.outputDir, "STATUS.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("STATUS.md");
         } catch (err) {
@@ -8745,7 +10194,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 = join14(options.outputDir, "HEALTH.md");
+          const filePath = join16(options.outputDir, "HEALTH.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("HEALTH.md");
         } catch (err) {
@@ -8756,7 +10205,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 = join14(options.outputDir, "DEAD_CODE.md");
+          const filePath = join16(options.outputDir, "DEAD_CODE.md");
           writeFileSync3(filePath, content, "utf-8");
           generated.push("DEAD_CODE.md");
         } catch (err) {
@@ -8800,7 +10249,7 @@ function getFileCount13(graph) {
 }
 
 // src/simulation/engine.ts
-import { dirname as dirname15, join as join15 } from "path";
+import { dirname as dirname17, join as join17 } from "path";
 function normalizePath2(p) {
   return p.replace(/^\.\//, "").replace(/\/+$/, "");
 }
@@ -8931,7 +10380,7 @@ var SimulationEngine = class {
     }
   }
   applyRename(clone, target, newName, brokenImports) {
-    const destination = join15(dirname15(target), newName);
+    const destination = join17(dirname17(target), newName);
     this.applyMove(clone, target, destination, brokenImports);
   }
   applySplit(clone, target, newFile, symbols, brokenImports) {
@@ -9131,13 +10580,13 @@ var SimulationEngine = class {
 };
 
 // src/security/scanner.ts
-import { existsSync as existsSync14 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join27 } from "path";
 
 // src/security/checks/dependencies.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync as readdirSync5 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync14, readdirSync as readdirSync7 } from "fs";
+import { join as join18 } from "path";
 function cvssToSeverity(score) {
   if (score >= 9) return "critical";
   if (score >= 7) return "high";
@@ -9147,18 +10596,18 @@ function cvssToSeverity(score) {
 async function checkDependencies(_files, projectRoot) {
   const findings = [];
   try {
-    if (existsSync13(join16(projectRoot, "package.json"))) {
+    if (existsSync15(join18(projectRoot, "package.json"))) {
       findings.push(...checkNpmAudit(projectRoot));
       findings.push(...checkPackageJsonPatterns(projectRoot));
       findings.push(...checkPostinstallScripts(projectRoot));
     }
-    if (existsSync13(join16(projectRoot, "requirements.txt")) || existsSync13(join16(projectRoot, "pyproject.toml"))) {
+    if (existsSync15(join18(projectRoot, "requirements.txt")) || existsSync15(join18(projectRoot, "pyproject.toml"))) {
       findings.push(...checkPipAudit(projectRoot));
     }
-    if (existsSync13(join16(projectRoot, "Cargo.toml"))) {
+    if (existsSync15(join18(projectRoot, "Cargo.toml"))) {
       findings.push(...checkCargoAudit(projectRoot));
     }
-    if (existsSync13(join16(projectRoot, "go.mod"))) {
+    if (existsSync15(join18(projectRoot, "go.mod"))) {
       findings.push(...checkGoVerify(projectRoot));
     }
   } catch (err) {
@@ -9247,8 +10696,8 @@ function checkNpmAudit(projectRoot) {
 function checkPackageJsonPatterns(projectRoot) {
   const findings = [];
   try {
-    const pkgPath = join16(projectRoot, "package.json");
-    const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+    const pkgPath = join18(projectRoot, "package.json");
+    const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const [name, version] of Object.entries(allDeps)) {
       if (version.startsWith("^") || version.startsWith("~")) {
@@ -9270,15 +10719,15 @@ function checkPackageJsonPatterns(projectRoot) {
 }
 function checkPostinstallScripts(projectRoot) {
   const findings = [];
-  const nodeModules = join16(projectRoot, "node_modules");
-  if (!existsSync13(nodeModules)) return findings;
+  const nodeModules = join18(projectRoot, "node_modules");
+  if (!existsSync15(nodeModules)) return findings;
   try {
-    const topLevelDeps = readdirSync5(nodeModules).filter((d) => !d.startsWith("."));
+    const topLevelDeps = readdirSync7(nodeModules).filter((d) => !d.startsWith("."));
     for (const dep of topLevelDeps) {
-      const depPkgPath = join16(nodeModules, dep, "package.json");
-      if (!existsSync13(depPkgPath)) continue;
+      const depPkgPath = join18(nodeModules, dep, "package.json");
+      if (!existsSync15(depPkgPath)) continue;
       try {
-        const depPkg = JSON.parse(readFileSync12(depPkgPath, "utf-8"));
+        const depPkg = JSON.parse(readFileSync14(depPkgPath, "utf-8"));
         const scripts = depPkg.scripts || {};
         if (scripts.postinstall || scripts.preinstall || scripts.install) {
           const scriptName = scripts.postinstall ? "postinstall" : scripts.preinstall ? "preinstall" : "install";
@@ -9316,7 +10765,7 @@ function checkPipAudit(projectRoot) {
         id: "",
         severity: cvssToSeverity(vuln.cvss?.score || 5),
         vulnerabilityClass: "dependency-cve",
-        file: existsSync13(join16(projectRoot, "requirements.txt")) ? "requirements.txt" : "pyproject.toml",
+        file: existsSync15(join18(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}.`,
@@ -9413,8 +10862,8 @@ function checkGoVerify(projectRoot) {
 }
 
 // src/security/checks/injection.ts
-import { readFileSync as readFileSync13 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join19 } 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;
@@ -9499,6 +10948,70 @@ var PATTERNS = [
     description: "Database query built using fmt.Sprintf directly passed to db.Query.",
     attackScenario: "An attacker could inject SQL through interpolated values.",
     suggestedFix: 'Use parameterized queries: db.Query("SELECT ... WHERE id = ?", id)'
+  },
+  // Java-specific injection patterns
+  {
+    regex: /(?:executeQuery|executeUpdate|execute)\s*\(\s*["']?\s*(?:SELECT|INSERT|UPDATE|DELETE)\b[^"']*["']?\s*\+/i,
+    title: "Java SQL injection via string concatenation",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "SQL query built using string concatenation \u2014 vulnerable to SQL injection.",
+    attackScenario: "An attacker could inject SQL through concatenated user input to read, modify, or delete database data.",
+    suggestedFix: "Use PreparedStatement with parameterized queries: preparedStatement.setString(1, userInput)"
+  },
+  {
+    regex: /Runtime\.getRuntime\(\)\.exec\s*\(/,
+    title: "Java command injection via Runtime.exec",
+    vulnClass: "shell-injection",
+    baseSeverity: "high",
+    description: "Runtime.exec() executes a system command \u2014 vulnerable if user input reaches the argument.",
+    attackScenario: "An attacker could inject shell metacharacters to execute arbitrary commands on the server.",
+    suggestedFix: "Use ProcessBuilder with an argument array. Validate all input against a strict allowlist."
+  },
+  {
+    regex: /new\s+ProcessBuilder\s*\([^)]*(?:input|user|param|query|request|body|arg)/i,
+    title: "Java command injection via ProcessBuilder with user input",
+    vulnClass: "shell-injection",
+    baseSeverity: "medium",
+    description: "ProcessBuilder called with arguments that may originate from user input.",
+    attackScenario: "An attacker could inject malicious arguments to the spawned process.",
+    suggestedFix: "Validate all arguments against a strict allowlist before passing to ProcessBuilder."
+  },
+  {
+    regex: /new\s+ObjectInputStream\s*\(/,
+    title: "Java insecure deserialization via ObjectInputStream",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    description: "ObjectInputStream.readObject() deserializes arbitrary Java objects \u2014 potential RCE.",
+    attackScenario: "An attacker could craft a malicious serialized object to achieve remote code execution.",
+    suggestedFix: "Use a whitelist-based ObjectInputFilter, or switch to JSON/Protobuf for data exchange."
+  },
+  {
+    regex: /DocumentBuilderFactory\.newInstance\(\)/,
+    title: "Java XML External Entity (XXE) risk",
+    vulnClass: "code-injection",
+    baseSeverity: "medium",
+    description: "DocumentBuilderFactory without FEATURE_SECURE_PROCESSING may allow XXE attacks.",
+    attackScenario: "An attacker could inject external entity references in XML to read server files or perform SSRF.",
+    suggestedFix: "Set FEATURE_SECURE_PROCESSING and disable external DTDs/entities: factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true)"
+  },
+  {
+    regex: /\.csrf\(\)\s*\.\s*disable\(\)/,
+    title: "Spring Security CSRF protection disabled",
+    vulnClass: "code-injection",
+    baseSeverity: "medium",
+    description: "CSRF protection has been explicitly disabled in Spring Security configuration.",
+    attackScenario: "An attacker could forge cross-site requests to perform actions on behalf of authenticated users.",
+    suggestedFix: "Only disable CSRF for stateless APIs using JWT. Keep CSRF enabled for session-based authentication."
+  },
+  {
+    regex: /\.permitAll\(\).*(?:admin|manage|delete|config|setting)/i,
+    title: "Spring Security permitAll on sensitive path",
+    vulnClass: "code-injection",
+    baseSeverity: "high",
+    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.'
   }
 ];
 function shouldSkip(filePath) {
@@ -9515,7 +11028,7 @@ async function checkInjection(files, projectRoot) {
       if (shouldSkip(file.filePath) || isTestFile4(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync13(join17(projectRoot, file.filePath), "utf-8");
+        content = readFileSync15(join19(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -9553,8 +11066,8 @@ async function checkInjection(files, projectRoot) {
 }
 
 // src/security/checks/secrets.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync16 } from "fs";
+import { join as join20 } 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 = [
@@ -9587,7 +11100,7 @@ async function checkSecrets(files, projectRoot) {
       if (shouldSkip2(file.filePath) || isTestFile5(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync14(join18(projectRoot, file.filePath), "utf-8");
+        content = readFileSync16(join20(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -9620,8 +11133,8 @@ async function checkSecrets(files, projectRoot) {
 }
 
 // src/security/checks/path-traversal.ts
-import { readFileSync as readFileSync15 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync17 } from "fs";
+import { join as join21 } 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 = [
@@ -9668,7 +11181,7 @@ async function checkPathTraversal(files, projectRoot) {
       if (shouldSkip3(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync15(join19(projectRoot, file.filePath), "utf-8");
+        content = readFileSync17(join21(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -9710,8 +11223,8 @@ async function checkPathTraversal(files, projectRoot) {
 }
 
 // src/security/checks/auth.ts
-import { readFileSync as readFileSync16 } from "fs";
-import { join as join20 } from "path";
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join22 } from "path";
 var SKIP_DIRS4 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip4(filePath) {
   return SKIP_DIRS4.some((d) => filePath.includes(d));
@@ -9727,7 +11240,7 @@ async function checkAuth(files, projectRoot) {
       if (shouldSkip4(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync16(join20(projectRoot, file.filePath), "utf-8");
+        content = readFileSync18(join22(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -9818,8 +11331,8 @@ async function checkAuth(files, projectRoot) {
 }
 
 // src/security/checks/input-validation.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { join as join21 } from "path";
+import { readFileSync as readFileSync19 } from "fs";
+import { join as join23 } from "path";
 var SKIP_DIRS5 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip5(filePath) {
   return SKIP_DIRS5.some((d) => filePath.includes(d));
@@ -9831,7 +11344,7 @@ async function checkInputValidation(files, projectRoot) {
       if (shouldSkip5(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync17(join21(projectRoot, file.filePath), "utf-8");
+        content = readFileSync19(join23(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -9908,8 +11421,8 @@ async function checkInputValidation(files, projectRoot) {
 }
 
 // src/security/checks/information-disclosure.ts
-import { readFileSync as readFileSync18 } from "fs";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { join as join24 } from "path";
 var SKIP_DIRS6 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip6(filePath) {
   return SKIP_DIRS6.some((d) => filePath.includes(d));
@@ -9921,7 +11434,7 @@ async function checkInformationDisclosure(files, projectRoot) {
       if (shouldSkip6(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync18(join22(projectRoot, file.filePath), "utf-8");
+        content = readFileSync20(join24(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -9991,9 +11504,10 @@ async function checkInformationDisclosure(files, projectRoot) {
 }
 
 // src/security/checks/cryptography.ts
-import { readFileSync as readFileSync19 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync21 } from "fs";
+import { join as join25 } 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) {
   return SKIP_DIRS7.some((d) => filePath.includes(d));
 }
@@ -10008,7 +11522,7 @@ async function checkCryptography(files, projectRoot) {
       if (shouldSkip7(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync19(join23(projectRoot, file.filePath), "utf-8");
+        content = readFileSync21(join25(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -10017,7 +11531,7 @@ async function checkCryptography(files, projectRoot) {
       for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         if (line.trimStart().startsWith("//") || line.trimStart().startsWith("#")) continue;
-        if (/createHash\s*\(\s*['"]md5['"]\s*\)/.test(line) || /hashlib\.md5\s*\(/.test(line)) {
+        if (/createHash\s*\(\s*['"]md5['"]\s*\)/.test(line) || /hashlib\.md5\s*\(/.test(line) || /MessageDigest\.getInstance\s*\(\s*["']MD5["']\s*\)/.test(line)) {
           findings.push({
             id: "",
             severity: isCryptoFile ? "high" : "medium",
@@ -10030,7 +11544,7 @@ async function checkCryptography(files, projectRoot) {
             suggestedFix: "Use SHA-256 or SHA-3 for integrity checks. Use bcrypt, scrypt, or argon2 for password hashing."
           });
         }
-        if (/createHash\s*\(\s*['"]sha1['"]\s*\)/.test(line) || /hashlib\.sha1\s*\(/.test(line)) {
+        if (/createHash\s*\(\s*['"]sha1['"]\s*\)/.test(line) || /hashlib\.sha1\s*\(/.test(line) || /MessageDigest\.getInstance\s*\(\s*["']SHA-?1["']\s*\)/.test(line)) {
           findings.push({
             id: "",
             severity: isCryptoFile ? "high" : "medium",
@@ -10043,6 +11557,34 @@ async function checkCryptography(files, projectRoot) {
             suggestedFix: "Use SHA-256 or SHA-3 for integrity checks. Use bcrypt, scrypt, or argon2 for password hashing."
           });
         }
+        if (/Cipher\.getInstance\s*\(\s*["']DES/.test(line)) {
+          findings.push({
+            id: "",
+            severity: "high",
+            vulnerabilityClass: "cryptography",
+            file: file.filePath,
+            line: i + 1,
+            title: "Weak cipher algorithm: DES",
+            description: "DES uses a 56-bit key and can be brute-forced in hours.",
+            attackScenario: "An attacker could brute-force DES-encrypted data to reveal plaintext.",
+            suggestedFix: 'Use AES-256 with GCM mode: Cipher.getInstance("AES/GCM/NoPadding")'
+          });
+        }
+        if (/(?:log|logger|LOG)\s*\.\s*(?:info|debug|warn|error|trace)\s*\([^)]*\+/.test(line)) {
+          if (USER_INPUT_NAMES2.test(line)) {
+            findings.push({
+              id: "",
+              severity: "medium",
+              vulnerabilityClass: "cryptography",
+              file: file.filePath,
+              line: i + 1,
+              title: "Potential log injection",
+              description: "User-controlled input concatenated directly into log output.",
+              attackScenario: "An attacker could inject newlines or control characters to forge log entries or hide malicious activity.",
+              suggestedFix: 'Use parameterized logging: log.info("User: {}", userInput) instead of string concatenation.'
+            });
+          }
+        }
         if (/Math\.random\(\)/.test(line) && isCryptoFile) {
           findings.push({
             id: "",
@@ -10090,8 +11632,8 @@ async function checkCryptography(files, projectRoot) {
 }
 
 // src/security/checks/frontend.ts
-import { readFileSync as readFileSync20 } from "fs";
-import { join as join24 } from "path";
+import { readFileSync as readFileSync22 } from "fs";
+import { join as join26 } from "path";
 var SKIP_DIRS8 = ["node_modules/", "dist/", ".git/", ".wrangler/", "src/security/checks/"];
 function shouldSkip8(filePath) {
   return SKIP_DIRS8.some((d) => filePath.includes(d));
@@ -10107,7 +11649,7 @@ async function checkFrontend(files, projectRoot) {
       if (!isFrontendFile(file.filePath)) continue;
       let content;
       try {
-        content = readFileSync20(join24(projectRoot, file.filePath), "utf-8");
+        content = readFileSync22(join26(projectRoot, file.filePath), "utf-8");
       } catch {
         continue;
       }
@@ -10567,11 +12109,13 @@ async function scanSecurity(projectRoot, graph, options = {}) {
   };
 }
 function detectPackageManager(projectRoot) {
-  if (existsSync14(join25(projectRoot, "package.json"))) return "npm";
-  if (existsSync14(join25(projectRoot, "requirements.txt"))) return "pip";
-  if (existsSync14(join25(projectRoot, "pyproject.toml"))) return "pip";
-  if (existsSync14(join25(projectRoot, "Cargo.toml"))) return "cargo";
-  if (existsSync14(join25(projectRoot, "go.mod"))) return "go";
+  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";
   return "unknown";
 }