depgraph-core 1.0.2 → 1.5.0

package/depgraph.js

@@ -83,205 +83,1481 @@ var require_javascript = __commonJS({
   "dist/languages/javascript.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.jsEntityPatterns = void 0;
     var registry_1 = require_registry();
     var constants_1 = require_constants();
     function estimateComplexity(code, name) {
-      const bodyMatch = code.match(new RegExp(`function\\s+${name}[^{]*{([\\s\\S]*?)
-}`, "m"));
-      if (!bodyMatch)
+      const lines = code.split("\n");
+      const nameRegex = new RegExp(`(?:(?:async\\s+)?function(?:\\s*\\*|\\s+)|(?:const|let|var)\\s+)${name}\\b|\\b${name}\\s*(?:<[^>]*>)?\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => nameRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
+        return "low";
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+          if (char === "{") {
+            braceCount++;
+            started = true;
+          } else if (char === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0) {
+          break;
+        }
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|else\s+if|for|while|switch|case|catch|&&|\|\||\?\?)\b|\?[^:]*:/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.jsEntityPatterns = [
+      // React components: wrapped in memo/forwardRef
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?(?:const|let|var)\s+([A-Z]\w*)\s*=\s*(?:React\.)?(?:memo|forwardRef)\(/gm,
+        type: "component"
+      },
+      // React components: PascalCase arrow functions
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?(?:const|let|var)\s+([A-Z]\w*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_]\w*)\s*=>/gm,
+        type: "component"
+      },
+      // React components: PascalCase function declarations
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "component"
+      },
+      // React hooks: camelCase starting with "use" (arrow functions or const assignments)
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?(?:const|let|var)\s+(use[A-Z]\w*)\s*=/gm,
+        type: "hook"
+      },
+      // React hooks: camelCase starting with "use" (function declarations)
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(use[A-Z]\w*)\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "hook"
+      },
+      // regular and async function declarations (including generator functions)
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function(?:\s*\*\s*|\s+)([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "function"
+      },
+      // arrow functions assigned to const / let / var
+      {
+        regex: /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_]\w*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_]\w*)\s*=>/gm,
+        type: "function"
+      },
+      // function expressions assigned to const / let / var
+      {
+        regex: /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_]\w*)\s*=\s*(?:async\s*)?function/gm,
+        type: "function"
+      },
+      // classes (regular, exported, abstract)
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_]\w*)/gm,
+        type: "class"
+      },
+      // TypeScript interfaces
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?interface\s+([A-Za-z_]\w*)/gm,
+        type: "interface"
+      },
+      // TypeScript types
+      {
+        regex: /^(?:export\s+)?(?:default\s+)?type\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*=/gm,
+        type: "type"
+      },
+      // TypeScript enums (regular or const enum)
+      {
+        regex: /^(?:export\s+)?(?:const\s+)?enum\s+([A-Za-z_]\w*)/gm,
+        type: "class"
+      },
+      // Express / router routes (capture group 1 = method, group 2 = path — skipped in gitdiff context matching)
+      {
+        regex: /(?:app|router|server)\.(get|post|put|delete|patch|options|head)\s*\(\s*['"]([^'"]+)['"]/gm,
+        type: "api"
+      }
+    ];
+    function extractEntities(code, filePath) {
+      const entities = [];
+      for (const { regex, type } of exports2.jsEntityPatterns) {
+        let match;
+        regex.lastIndex = 0;
+        while ((match = regex.exec(code)) !== null) {
+          const upToMatch = code.slice(0, match.index);
+          const line = upToMatch.split("\n").length;
+          if (type === "api") {
+            entities.push({
+              name: `${match[1].toUpperCase()} ${match[2]}`,
+              type: "api",
+              line,
+              complexity: "low"
+            });
+          } else {
+            const name = match[1];
+            if (entities.some((e) => e.name === name))
+              continue;
+            entities.push({
+              name,
+              type,
+              line,
+              complexity: estimateComplexity(code, name)
+            });
+          }
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const imports = [];
+      const combinedPattern = /^import\s+(?:type\s+)?([A-Za-z_$]\w*)\s*,\s*(?:\{([^}]+)\}|\*\s+as\s+([A-Za-z_$]\w*))\s+from\s+['"]([^'"]+)['"]/gm;
+      let match;
+      while ((match = combinedPattern.exec(code)) !== null) {
+        const defaultName = match[1];
+        const namedClause = match[2];
+        const nsName = match[3];
+        const source = match[4];
+        const names = [defaultName];
+        if (namedClause) {
+          const parsedNamed = namedClause.split(",").map((n) => n.trim().replace(/^type\s+/, "").replace(/\s+as\s+\w+$/, "").trim()).filter((n) => n.length > 0);
+          names.push(...parsedNamed);
+        }
+        if (nsName) {
+          names.push(nsName);
+        }
+        imports.push({
+          source,
+          names: [...new Set(names)],
+          isLocal: source.startsWith(".") || source.startsWith("/")
+        });
+      }
+      const namedPattern = /^import\s+(?:type\s+)?\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/gm;
+      while ((match = namedPattern.exec(code)) !== null) {
+        const source = match[2];
+        if (imports.some((i) => i.source === source))
+          continue;
+        const names = match[1].split(",").map((n) => n.trim().replace(/^type\s+/, "").replace(/\s+as\s+\w+$/, "").trim()).filter((n) => n.length > 0);
+        imports.push({
+          source,
+          names: [...new Set(names)],
+          isLocal: source.startsWith(".") || source.startsWith("/")
+        });
+      }
+      const defaultPattern = /^import\s+(?:type\s+)?([A-Za-z_$]\w*)\s+from\s+['"]([^'"]+)['"]/gm;
+      while ((match = defaultPattern.exec(code)) !== null) {
+        const source = match[2];
+        if (imports.some((i) => i.source === source))
+          continue;
+        imports.push({
+          source,
+          names: [match[1]],
+          isLocal: source.startsWith(".") || source.startsWith("/")
+        });
+      }
+      const nsPattern = /^import\s+\*\s+as\s+([A-Za-z_$]\w*)\s+from\s+['"]([^'"]+)['"]/gm;
+      while ((match = nsPattern.exec(code)) !== null) {
+        const source = match[2];
+        if (imports.some((i) => i.source === source))
+          continue;
+        imports.push({
+          source,
+          names: [match[1]],
+          isLocal: source.startsWith(".") || source.startsWith("/")
+        });
+      }
+      const requirePattern = /(?:const|let|var)\s+\{?([^}=]+)\}?\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
+      while ((match = requirePattern.exec(code)) !== null) {
+        const rawNames = match[1];
+        const source = match[2];
+        const names = rawNames.split(",").map((n) => n.trim().replace(/^\w+:\s*/, "").trim()).filter((n) => n.length > 0);
+        imports.push({
+          source,
+          names: [...new Set(names)],
+          isLocal: source.startsWith(".") || source.startsWith("/")
+        });
+      }
+      const reexportPattern = /^export\s+(?:\{([^}]+)\}|\*\s+as\s+([A-Za-z_$]\w*)|\*)\s+from\s+['"]([^'"]+)['"]/gm;
+      while ((match = reexportPattern.exec(code)) !== null) {
+        const namedClause = match[1];
+        const nsAlias = match[2];
+        const source = match[3];
+        let names = [];
+        if (namedClause) {
+          names = namedClause.split(",").map((n) => n.trim().replace(/^type\s+/, "").replace(/\s+as\s+\w+$/, "").trim()).filter((n) => n.length > 0);
+        } else if (nsAlias) {
+          names = [nsAlias];
+        } else {
+          names = ["*"];
+        }
+        imports.push({
+          source,
+          names: [...new Set(names)],
+          isLocal: source.startsWith(".") || source.startsWith("/")
+        });
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const exports3 = [];
+      const namedPattern = /^export\s+(?:default\s+)?(?:async\s+|abstract\s+)?(?:function(?:\s*\*|\s+)|class|const|let|var|type|interface|enum)\s+([A-Za-z_$]\w*)/gm;
+      let match;
+      while ((match = namedPattern.exec(code)) !== null) {
+        exports3.push(match[1]);
+      }
+      const defaultIdentPattern = /^export\s+default\s+([A-Za-z_$]\w*)\s*(?:;|$)/gm;
+      while ((match = defaultIdentPattern.exec(code)) !== null) {
+        if (!["function", "class", "interface", "abstract"].includes(match[1])) {
+          exports3.push(match[1]);
+        }
+      }
+      const listPattern = /^export\s+\{([^}]+)\}(?!\s*from)/gm;
+      while ((match = listPattern.exec(code)) !== null) {
+        const names = match[1].split(",").map((n) => n.trim().replace(/^type\s+/, "").replace(/^\w+\s+as\s+/, "").trim()).filter((n) => n.length > 0);
+        exports3.push(...names);
+      }
+      const reexportPattern = /^export\s+\{([^}]+)\}\s+from/gm;
+      while ((match = reexportPattern.exec(code)) !== null) {
+        const names = match[1].split(",").map((n) => n.trim().replace(/^type\s+/, "").replace(/^\w+\s+as\s+/, "").trim()).filter((n) => n.length > 0);
+        exports3.push(...names);
+      }
+      return [...new Set(exports3)];
+    }
+    var JavaScriptParser = {
+      lang: "js",
+      extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.jsEntityPatterns
+    };
+    (0, registry_1.registerParser)(JavaScriptParser);
+  }
+});
+
+// dist/languages/python.js
+var require_python = __commonJS({
+  "dist/languages/python.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.pyEntityPatterns = void 0;
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const defRegex = new RegExp(`^[ \\t]*(?:async\\s+)?def\\s+${escapeRegex(name)}\\s*\\(`, "m");
+      const defLine = lines.findIndex((l) => defRegex.test(l));
+      if (defLine === -1)
+        return "low";
+      let bodyStart = defLine;
+      while (bodyStart < lines.length && !lines[bodyStart].includes(":")) {
+        bodyStart++;
+      }
+      bodyStart++;
+      const bodyLines = [];
+      for (let i = bodyStart; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === "")
+          continue;
+        if (!line.match(/^\s+/))
+          break;
+        bodyLines.push(line);
+      }
+      const branches = (bodyLines.join("\n").match(/\b(if|elif|else|for|while|except|and|or|match|case)\b/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.pyEntityPatterns = [
+      // functions and methods (including async def)
+      {
+        regex: /^[ \t]*(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(/gm,
+        type: "function"
+      },
+      // classes (with optional generic parameters [T] and base classes (Base))
+      {
+        regex: /^[ \t]*class\s+([A-Za-z_]\w*)(?:\s*\[[^\]]*\])?(?:\s*\([^)]*\))?\s*:/gm,
+        type: "class"
+      }
+    ];
+    function extractEntities(code, filePath) {
+      const entities = [];
+      for (const { regex, type } of exports2.pyEntityPatterns) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+          const name = match[1];
+          if (type === "function" && name.startsWith("__") && name.endsWith("__"))
+            continue;
+          const upToMatch = code.slice(0, match.index);
+          const line = upToMatch.split("\n").length;
+          if (entities.some((e) => e.name === name && e.line === line))
+            continue;
+          entities.push({
+            name,
+            type,
+            line,
+            complexity: type === "function" ? estimateComplexity(code, name) : "low"
+          });
+        }
+      }
+      return entities;
+    }
+    function stripAlias(name) {
+      return name.replace(/\s+as\s+[A-Za-z_]\w*$/, "").trim();
+    }
+    function extractImports(code) {
+      const imports = [];
+      const normalised = code.replace(/^(from\s+[\w.]+\s+import\s*)\(\s*([\s\S]*?)\)/gm, (_, prefix, body) => prefix + body.replace(/\s*\n\s*/g, ", "));
+      const fromPattern = /^from\s+([\w.]+)\s+import\s+(.+)$/gm;
+      let match;
+      while ((match = fromPattern.exec(normalised)) !== null) {
+        const source = match[1];
+        const rawNames = match[2].replace(/#.*$/, "");
+        const names = rawNames.split(",").map((n) => stripAlias(n.trim())).filter((n) => n.length > 0 && n !== "*");
+        imports.push({ source, names, isLocal: source.startsWith(".") });
+      }
+      const importPattern = /^import\s+([^#\n]+)/gm;
+      while ((match = importPattern.exec(normalised)) !== null) {
+        const modules = match[1].split(",").map((m) => m.trim());
+        for (const mod of modules) {
+          if (!mod)
+            continue;
+          const cleanMod = stripAlias(mod);
+          if (!cleanMod)
+            continue;
+          imports.push({
+            source: cleanMod,
+            names: [cleanMod],
+            isLocal: cleanMod.startsWith(".")
+          });
+        }
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const allMatch = code.match(/__all__\s*=\s*[\[\(]([\s\S]*?)[\]\)]/);
+      if (!allMatch)
+        return [];
+      return allMatch[1].split(",").map((n) => n.trim().replace(/['"]/g, "").replace(/#.*$/, "").trim()).filter((n) => n.length > 0);
+    }
+    var PythonParser = {
+      lang: "py",
+      extensions: [".py"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.pyEntityPatterns
+    };
+    (0, registry_1.registerParser)(PythonParser);
+  }
+});
+
+// dist/languages/go.js
+var require_go = __commonJS({
+  "dist/languages/go.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.goEntityPatterns = void 0;
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const funcRegex = new RegExp(`func\\s+(?:\\([^)]*\\)\\s+)?${name}\\s*(?:\\[[^\\]]*\\])?\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => funcRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
+        return "low";
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+          if (char === "{") {
+            braceCount++;
+            started = true;
+          } else if (char === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0) {
+          break;
+        }
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|else\s+if|for|switch|case|select|&&|\|\|)\b/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.goEntityPatterns = [
+      // functions and methods with optional receiver and type parameters (generics)
+      {
+        regex: /^func\s+(?:\([^)]*\)\s+)?([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s*\(/gm,
+        type: "function"
+      },
+      // type declarations (structs, interfaces) with optional type parameters
+      {
+        regex: /^type\s+([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s+(?:struct|interface)/gm,
+        type: "class"
+      },
+      // type aliases and custom types (e.g. type HandlerFunc func(...), type MyInt int)
+      {
+        regex: /^type\s+([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s+(?!(?:struct|interface)\b)[A-Za-z_\[\]\*]/gm,
+        type: "type"
+      }
+    ];
+    function extractEntities(code, filePath) {
+      const entities = [];
+      for (const { regex, type } of exports2.goEntityPatterns) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+          const name = match[1];
+          if (entities.some((e) => e.name === name))
+            continue;
+          const upToMatch = code.slice(0, match.index);
+          const line = upToMatch.split("\n").length;
+          entities.push({
+            name,
+            type,
+            line,
+            complexity: type === "function" ? estimateComplexity(code, name) : "low"
+          });
+        }
+      }
+      const blockTypePattern = /^type\s*\(\s*\n?([\s\S]*?)\n\s*\)/gm;
+      let blockMatch;
+      while ((blockMatch = blockTypePattern.exec(code)) !== null) {
+        const blockContent = blockMatch[1];
+        const blockStartLine = code.slice(0, blockMatch.index).split("\n").length;
+        const lines = blockContent.split("\n");
+        let braceDepth = 0;
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i].trim();
+          if (braceDepth === 0 && line.length > 0 && !line.startsWith("//")) {
+            const structInterfaceMatch = line.match(/^([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s+(struct|interface)/);
+            if (structInterfaceMatch) {
+              const name = structInterfaceMatch[1];
+              if (!entities.some((e) => e.name === name)) {
+                entities.push({
+                  name,
+                  type: "class",
+                  line: blockStartLine + i + 1,
+                  complexity: "low"
+                });
+              }
+            } else {
+              const aliasMatch = line.match(/^([A-Za-z_]\w*)\s*(?:\[[^\]]*\])?\s+(?:=\s*)?(?!(?:struct|interface)\b)[A-Za-z_\[\]\*]/);
+              if (aliasMatch) {
+                const name = aliasMatch[1];
+                if (!entities.some((e) => e.name === name)) {
+                  entities.push({
+                    name,
+                    type: "type",
+                    line: blockStartLine + i + 1,
+                    complexity: "low"
+                  });
+                }
+              }
+            }
+          }
+          for (const ch of line) {
+            if (ch === "{")
+              braceDepth++;
+            else if (ch === "}")
+              braceDepth--;
+          }
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const imports = [];
+      const singlePattern = /^import\s+(?:([A-Za-z_.\w]+)\s+)?["']([^"']+)["']/gm;
+      let match;
+      while ((match = singlePattern.exec(code)) !== null) {
+        const alias = match[1];
+        const source = match[2];
+        const pkgName = alias && alias !== "_" && alias !== "." ? alias : source.split("/").pop() || source;
+        imports.push({
+          source,
+          names: [pkgName],
+          isLocal: source.startsWith(".") || source.startsWith("/")
+        });
+      }
+      const blockPattern = /import\s*\(\s*([\s\S]*?)\s*\)/gm;
+      while ((match = blockPattern.exec(code)) !== null) {
+        const lines = match[1].split("\n");
+        for (const line of lines) {
+          const cleanLine = line.replace(/\/\/.*$/, "").trim();
+          const pkgMatch = cleanLine.match(/^(?:([A-Za-z_.\w]+)\s+)?["']([^"']+)["']/);
+          if (pkgMatch) {
+            const alias = pkgMatch[1];
+            const source = pkgMatch[2];
+            const pkgName = alias && alias !== "_" && alias !== "." ? alias : source.split("/").pop() || source;
+            imports.push({
+              source,
+              names: [pkgName],
+              isLocal: source.startsWith(".") || source.startsWith("/")
+            });
+          }
+        }
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const exports3 = [];
+      const funcPattern = /^func\s+(?:\([^)]*\)\s+)?([A-Z]\w*)\s*(?:\[[^\]]*\])?\s*\(/gm;
+      let match;
+      while ((match = funcPattern.exec(code)) !== null) {
+        exports3.push(match[1]);
+      }
+      const typePattern = /^type\s+([A-Z]\w*)/gm;
+      while ((match = typePattern.exec(code)) !== null) {
+        exports3.push(match[1]);
+      }
+      const blockTypePattern = /^type\s*\(\s*\n?([\s\S]*?)\n\s*\)/gm;
+      let blockTypeMatch;
+      while ((blockTypeMatch = blockTypePattern.exec(code)) !== null) {
+        const lines = blockTypeMatch[1].split("\n");
+        let braceDepth = 0;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (braceDepth === 0 && trimmed.length > 0 && !trimmed.startsWith("//")) {
+            const m = trimmed.match(/^([A-Z]\w*)/);
+            if (m)
+              exports3.push(m[1]);
+          }
+          for (const ch of trimmed) {
+            if (ch === "{")
+              braceDepth++;
+            else if (ch === "}")
+              braceDepth--;
+          }
+        }
+      }
+      const constVarPattern = /^(?:const|var)\s+([A-Z]\w*)/gm;
+      while ((match = constVarPattern.exec(code)) !== null) {
+        exports3.push(match[1]);
+      }
+      const blockConstVarPattern = /^(?:const|var)\s*\(\s*\n?([\s\S]*?)\n\s*\)/gm;
+      while ((match = blockConstVarPattern.exec(code)) !== null) {
+        const lines = match[1].split("\n");
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("//")) {
+            const m = trimmed.match(/^([A-Z]\w*)/);
+            if (m)
+              exports3.push(m[1]);
+          }
+        }
+      }
+      return [...new Set(exports3)];
+    }
+    var GoParser = {
+      lang: "go",
+      extensions: [".go"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.goEntityPatterns
+    };
+    (0, registry_1.registerParser)(GoParser);
+  }
+});
+
+// dist/languages/csharp.js
+var require_csharp = __commonJS({
+  "dist/languages/csharp.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.csharpEntityPatterns = void 0;
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const methodRegex = new RegExp(`(?:(?:public|private|protected|internal|static|async|virtual|override|abstract|sealed|partial)\\s+)+[\\w<>\\[\\],?]+\\s+${name}\\s*(?:<[^>]*>)?\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => methodRegex.test(l) || new RegExp(`\\b${name}\\s*\\(`, "m").test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
+        return "low";
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const char of line) {
+          if (char === "{") {
+            braceCount++;
+            started = true;
+          } else if (char === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0) {
+          break;
+        }
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|else\s+if|for|foreach|while|do|switch|case|catch|&&|\|\||\?\?)\b|\?[^:]*:/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.csharpEntityPatterns = [
+      // Classes, structs, records, interfaces, enums
+      {
+        regex: /^[ \t]*(?:(?:public|private|protected|internal|static|abstract|sealed|partial)\s+)*(?:class|interface|enum|struct|record(?:\s+(?:class|struct))?)\s+([A-Za-z_]\w*)/gm,
+        type: "class"
+      },
+      // Methods (constructors, instance methods, async/static methods)
+      {
+        regex: /^[ \t]*(?:(?:public|private|protected|internal|static|async|virtual|override|abstract|sealed|partial)\s+)+(?:(?:async\s+)?[\w<>[\]?,]+\s+)?([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "function"
+      }
+    ];
+    function extractEntities(code, filePath) {
+      const entities = [];
+      for (const { regex, type } of exports2.csharpEntityPatterns) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+          const name = match[1];
+          if (["if", "for", "foreach", "while", "switch", "catch", "lock", "using", "get", "set"].includes(name)) {
+            continue;
+          }
+          const upToMatch = code.slice(0, match.index);
+          const line = upToMatch.split("\n").length;
+          if (entities.some((e) => e.name === name && e.line === line))
+            continue;
+          entities.push({
+            name,
+            type,
+            line,
+            complexity: type === "function" ? estimateComplexity(code, name) : "low"
+          });
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const imports = [];
+      const usingPattern = /^[ \t]*(?:global\s+)?using\s+(?:static\s+)?(?:([A-Za-z_]\w*)\s*=\s*)?([A-Za-z_][\w.]*(?:<[^>]*>)?)\s*;/gm;
+      let match;
+      while ((match = usingPattern.exec(code)) !== null) {
+        const alias = match[1];
+        const targetFqn = match[2].trim();
+        const simpleName = alias || targetFqn.split(".").pop() || targetFqn;
+        const isLocal = !targetFqn.startsWith("System") && !targetFqn.startsWith("Microsoft");
+        imports.push({
+          source: targetFqn,
+          names: [simpleName],
+          isLocal
+        });
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const exports3 = [];
+      const typePattern = /^[ \t]*(?:public|internal)\s+(?:(?:static|abstract|sealed|partial)\s+)*(?:class|interface|enum|struct|record(?:\s+(?:class|struct))?)\s+([A-Za-z_]\w*)/gm;
+      let match;
+      while ((match = typePattern.exec(code)) !== null) {
+        exports3.push(match[1]);
+      }
+      const methodPattern = /^[ \t]*(?:public|internal)\s+(?:(?:static|async|virtual|override|abstract|sealed|partial)\s+)*(?:[\w<>[\]?,]+\s+)?([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(/gm;
+      while ((match = methodPattern.exec(code)) !== null) {
+        const name = match[1];
+        if (!["if", "for", "foreach", "while", "switch", "catch", "lock", "using", "get", "set"].includes(name)) {
+          exports3.push(name);
+        }
+      }
+      return [...new Set(exports3)];
+    }
+    var CSharpParser = {
+      lang: "cs",
+      extensions: [".cs"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.csharpEntityPatterns
+    };
+    (0, registry_1.registerParser)(CSharpParser);
+  }
+});
+
+// dist/languages/java.js
+var require_java = __commonJS({
+  "dist/languages/java.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.javaEntityPatterns = void 0;
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const defRegex = new RegExp(`(?:^|\\s)${escapeRegex(name)}\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => defRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
+        return "low";
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const ch of line) {
+          if (ch === "{") {
+            braceCount++;
+            started = true;
+          } else if (ch === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0)
+          break;
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|else\s+if|else|for|while|do|switch|case|catch|&&|\|\|)\b/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.javaEntityPatterns = [
+      // class / abstract class / final class
+      {
+        regex: /^[ \t]*(?:(?:public|protected|private|abstract|final|static)\s+)*class\s+([A-Za-z_]\w*)(?:\s*<[^{]*?)?\s*(?:extends\s+\S+\s*)?(?:implements\s+[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // interface
+      {
+        regex: /^[ \t]*(?:(?:public|protected|private|abstract|static)\s+)*interface\s+([A-Za-z_]\w*)(?:\s*<[^{]*?)?\s*(?:extends\s+[^{]+)?\s*\{/gm,
+        type: "interface"
+      },
+      // record (Java 14+)
+      {
+        regex: /^[ \t]*(?:(?:public|protected|private|final|static)\s+)*record\s+([A-Za-z_]\w*)\s*\(/gm,
+        type: "class"
+      },
+      // enum
+      {
+        regex: /^[ \t]*(?:(?:public|protected|private|static)\s+)*enum\s+([A-Za-z_]\w*)\s*(?:implements\s+[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // annotation type
+      {
+        regex: /^[ \t]*(?:(?:public|protected|private|abstract|static)\s+)*@interface\s+([A-Za-z_]\w*)\s*\{/gm,
+        type: "interface"
+      },
+      // method declarations (with return type before the name)
+      {
+        regex: /^[ \t]*(?:(?:public|protected|private|static|final|abstract|synchronized|native|default|override)\s+)*(?:<[^>]*>\s+)?(?:[\w.<>\[\]]+\s+)+([A-Za-z_]\w*)\s*\([^)]*\)\s*(?:throws\s+[\w,\s]+)?\s*\{/gm,
+        type: "function"
+      }
+    ];
+    function extractEntities(code, _filePath) {
+      const entities = [];
+      for (const { regex, type } of exports2.javaEntityPatterns) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+          const name = match[1];
+          if (["if", "else", "for", "while", "do", "switch", "try", "catch", "return", "new", "void", "this", "super"].includes(name))
+            continue;
+          const upToMatch = code.slice(0, match.index);
+          const line = upToMatch.split("\n").length;
+          if (entities.some((e) => e.name === name && e.line === line))
+            continue;
+          entities.push({
+            name,
+            type,
+            line,
+            complexity: type === "function" ? estimateComplexity(code, name) : "low"
+          });
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const imports = [];
+      const importPattern = /^import\s+((?:static)\s+)?([\w.]+(?:\.\*)?)?\s*;/gm;
+      let match;
+      while ((match = importPattern.exec(code)) !== null) {
+        const isStatic = Boolean(match[1]);
+        const fullPath = (match[2] || "").trim();
+        if (!fullPath)
+          continue;
+        const isWildcard = fullPath.endsWith(".*");
+        const cleanPath = isWildcard ? fullPath.slice(0, -2) : fullPath;
+        const segments = cleanPath.split(".");
+        let source;
+        let name;
+        if (isStatic) {
+          name = segments.pop() || cleanPath;
+          source = segments.join(".") || cleanPath;
+        } else {
+          name = segments[segments.length - 1] || cleanPath;
+          source = cleanPath;
+        }
+        imports.push({
+          source,
+          names: [name],
+          isLocal: false
+        });
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const exports3 = [];
+      const typePattern = /^public\s+(?:(?:abstract|final|static)\s+)*(?:class|interface|enum|record|@interface)\s+([A-Za-z_]\w*)/gm;
+      let match;
+      while ((match = typePattern.exec(code)) !== null) {
+        exports3.push(match[1]);
+      }
+      const methodPattern = /^[ \t]*public\s+(?:(?:static|final|abstract|synchronized|native|default)\s+)*(?:<[^>]*>\s+)?(?:[\w.<>\[\]]+\s+)+([A-Za-z_]\w*)\s*\(/gm;
+      while ((match = methodPattern.exec(code)) !== null) {
+        const name = match[1];
+        if (!["if", "for", "while", "switch", "class", "interface", "enum"].includes(name)) {
+          exports3.push(name);
+        }
+      }
+      return [...new Set(exports3)];
+    }
+    var JavaParser = {
+      lang: "java",
+      extensions: [".java"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.javaEntityPatterns
+    };
+    (0, registry_1.registerParser)(JavaParser);
+  }
+});
+
+// dist/languages/kotlin.js
+var require_kotlin = __commonJS({
+  "dist/languages/kotlin.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.kotlinEntityPatterns = void 0;
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const defRegex = new RegExp(`(?:^|\\s)fun\\s+(?:<[^>]*>\\s+)?(?:\\w[\\w.]*\\.)?${escapeRegex(name)}\\s*(?:\\(|<)`, "m");
+      const defLineIdx = lines.findIndex((l) => defRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
+        return "low";
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const ch of line) {
+          if (ch === "{") {
+            braceCount++;
+            started = true;
+          } else if (ch === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0)
+          break;
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|else\s+if|else|for|while|when|catch|&&|\|\|)\b/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.kotlinEntityPatterns = [
+      // class declarations (including data class, sealed class, abstract class, inner class)
+      // The trailing brace is optional: abstract classes may have no body on the same line.
+      // We anchor by requiring the class name to be followed by whitespace, <, (, :, { or EOL.
+      {
+        regex: /^[ \t]*(?:(?:public|private|protected|internal|abstract|sealed|data|open|inner|inline|value|annotation)\s+)*class\s+([A-Za-z_]\w*)(?=[\s<(:,{\n]|$)/gm,
+        type: "class"
+      },
+      // object declarations (singleton objects and companion objects)
+      {
+        regex: /^[ \t]*(?:(?:public|private|protected|internal)\s+)*(?:companion\s+)?object\s+([A-Za-z_]\w*)\s*(?::\s*[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // interface declarations
+      {
+        regex: /^[ \t]*(?:(?:public|private|protected|internal|sealed|fun)\s+)*interface\s+([A-Za-z_]\w*)(?:\s*<[^{]*)?(?:\s*:\s*[^{]+)?\s*\{/gm,
+        type: "interface"
+      },
+      // enum class
+      {
+        regex: /^[ \t]*(?:(?:public|private|protected|internal)\s+)*enum\s+class\s+([A-Za-z_]\w*)\s*(?:\([^)]*\))?\s*\{/gm,
+        type: "class"
+      },
+      // function declarations (including suspend, inline, operator, extension functions)
+      {
+        regex: /^[ \t]*(?:(?:public|private|protected|internal|override|open|final|abstract|suspend|inline|operator|infix|tailrec|external|actual|expect)\s+)*fun\s+(?:<[^>]*>\s+)?(?:[\w.]+\.)?([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "function"
+      }
+    ];
+    function extractEntities(code, _filePath) {
+      const entities = [];
+      for (const { regex, type } of exports2.kotlinEntityPatterns) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+          const name = match[1];
+          if (!name)
+            continue;
+          const upToMatch = code.slice(0, match.index);
+          const line = upToMatch.split("\n").length;
+          if (entities.some((e) => e.name === name && e.line === line))
+            continue;
+          entities.push({
+            name,
+            type,
+            line,
+            complexity: type === "function" ? estimateComplexity(code, name) : "low"
+          });
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const imports = [];
+      const importPattern = /^import\s+([\w.]+?)(\.\*)?\s*(?:as\s+(\w+))?\s*$/gm;
+      let match;
+      while ((match = importPattern.exec(code)) !== null) {
+        const fullPath = match[1];
+        const isWild = Boolean(match[2]);
+        const alias = match[3];
+        if (isWild)
+          continue;
+        const lastName = fullPath.split(".").pop() || fullPath;
+        const localName = alias || lastName;
+        imports.push({
+          source: fullPath,
+          names: [localName],
+          isLocal: false
+        });
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const exports3 = [];
+      const patterns = [
+        /^(?:(?:public|open|abstract|sealed|data|inline|value)\s+)*class\s+([A-Za-z_]\w*)/gm,
+        /^(?:(?:public)\s+)?object\s+([A-Za-z_]\w*)/gm,
+        /^(?:(?:public|sealed|fun)\s+)*interface\s+([A-Za-z_]\w*)/gm,
+        /^(?:(?:public|open|inline|suspend|operator|infix|tailrec)\s+)*fun\s+(?:<[^>]*>\s+)?([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(/gm
+      ];
+      for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(code)) !== null) {
+          if (match[1])
+            exports3.push(match[1]);
+        }
+      }
+      return [...new Set(exports3)];
+    }
+    var KotlinParser = {
+      lang: "kotlin",
+      extensions: [".kt", ".kts"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.kotlinEntityPatterns
+    };
+    (0, registry_1.registerParser)(KotlinParser);
+  }
+});
+
+// dist/languages/php.js
+var require_php = __commonJS({
+  "dist/languages/php.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.phpEntityPatterns = void 0;
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const defRegex = new RegExp(`(?:^|\\s)function\\s+${escapeRegex(name)}\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => defRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
         return "low";
-      const body = bodyMatch[1];
-      const branches = (body.match(/\b(if|else|for|while|switch|catch|&&|\|\|)\b/g) || []).length;
+      let braceCount = 0;
+      let started = false;
+      const bodyLines = [];
+      for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
+        for (const ch of line) {
+          if (ch === "{") {
+            braceCount++;
+            started = true;
+          } else if (ch === "}") {
+            braceCount--;
+          }
+        }
+        bodyLines.push(line);
+        if (started && braceCount <= 0)
+          break;
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|elseif|else|for|foreach|while|do|switch|case|catch|&&|\|\|)\b/g) || []).length;
       if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
         return "low";
       if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
         return "medium";
       return "high";
     }
-    function extractEntities(code, filePath) {
+    exports2.phpEntityPatterns = [
+      // class (abstract class, final class, readonly class, etc.)
+      {
+        regex: /^[ \t]*(?:(?:abstract|final|readonly)\s+)*class\s+([A-Za-z_]\w*)(?:\s+extends\s+\S+)?(?:\s+implements\s+[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // interface
+      {
+        regex: /^[ \t]*interface\s+([A-Za-z_]\w*)(?:\s+extends\s+[^{]+)?\s*\{/gm,
+        type: "interface"
+      },
+      // trait
+      {
+        regex: /^[ \t]*trait\s+([A-Za-z_]\w*)\s*\{/gm,
+        type: "class"
+      },
+      // enum (PHP 8.1+)
+      {
+        regex: /^[ \t]*enum\s+([A-Za-z_]\w*)(?:\s*:\s*\w+)?(?:\s+implements\s+[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // function and method declarations
+      {
+        regex: /^[ \t]*(?:(?:public|protected|private|static|abstract|final|readonly)\s+)*function\s+([A-Za-z_]\w*)\s*\(/gm,
+        type: "function"
+      }
+    ];
+    function extractEntities(code, _filePath) {
       const entities = [];
-      const lines = code.split("\n");
-      const patterns = [
-        // React components (PascalCase arrow functions)
-        {
-          regex: /^(?:export\s+)?const\s+([A-Z]\w+)\s*=\s*(?:\([^)]*\)|[^=])\s*=>/gm,
-          type: "component"
-        },
-        // React hooks (camelCase starting with "use")
-        {
-          regex: /^(?:export\s+)?(?:const\s+)?(use[A-Z]\w+)\s*=/gm,
-          type: "hook"
-        },
-        // regular functions
-        {
-          regex: /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)\s*\(/gm,
-          type: "function"
-        },
-        // arrow functions assigned to const
-        {
-          regex: /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/gm,
-          type: "function"
-        },
-        // classes
-        {
-          regex: /^(?:export\s+)?(?:default\s+)?class\s+(\w+)/gm,
-          type: "class"
-        },
-        // TypeScript interfaces
-        {
-          regex: /^(?:export\s+)?interface\s+(\w+)/gm,
-          type: "interface"
-        },
-        // TypeScript types
-        {
-          regex: /^(?:export\s+)?type\s+(\w+)\s*=/gm,
-          type: "type"
-        },
-        // Express routes
-        {
-          regex: /(?:app|router)\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/gm,
-          type: "api"
+      for (const { regex, type } of exports2.phpEntityPatterns) {
+        regex.lastIndex = 0;
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+          const name = match[1];
+          if (!name)
+            continue;
+          const upToMatch = code.slice(0, match.index);
+          const line = upToMatch.split("\n").length;
+          if (entities.some((e) => e.name === name && e.line === line))
+            continue;
+          entities.push({
+            name,
+            type,
+            line,
+            complexity: type === "function" ? estimateComplexity(code, name) : "low"
+          });
+        }
+      }
+      return entities;
+    }
+    function extractImports(code) {
+      const imports = [];
+      const usePattern = /^use\s+([\w\\]+(?:\s*\{[^}]*\})?)\s*(?:as\s+(\w+)\s*)?;/gm;
+      let match;
+      while ((match = usePattern.exec(code)) !== null) {
+        const raw = match[1].trim();
+        const alias = match[2]?.trim();
+        if (raw.includes("{")) {
+          const prefixMatch = raw.match(/^([\w\\]+)\\?\s*\{([^}]*)\}/);
+          if (prefixMatch) {
+            const prefix = prefixMatch[1];
+            const items = prefixMatch[2].split(",");
+            for (const item of items) {
+              const parts = item.trim().split(/\s+as\s+/i);
+              const fullName = (prefix + "\\" + parts[0].trim()).replace(/\\+/g, "\\");
+              const lastName = parts[1] || parts[0].trim().split("\\").pop() || fullName;
+              imports.push({ source: fullName, names: [lastName.trim()], isLocal: false });
+            }
+          }
+        } else {
+          const fullPath = raw;
+          const lastName = alias || fullPath.split("\\").pop() || fullPath;
+          imports.push({ source: fullPath, names: [lastName.trim()], isLocal: false });
         }
+      }
+      const includePattern = /(?:require|include)(?:_once)?\s*[^;'"]*?['"]([^'"]+)['"]/gm;
+      while ((match = includePattern.exec(code)) !== null) {
+        const source = match[1];
+        const name = source.split("/").pop()?.replace(/\.php$/i, "") || source;
+        imports.push({ source, names: [name], isLocal: true });
+      }
+      return imports;
+    }
+    function extractExports(code) {
+      const exports3 = [];
+      const patterns = [
+        /^(?:(?:abstract|final|readonly)\s+)*class\s+([A-Za-z_]\w*)/gm,
+        /^interface\s+([A-Za-z_]\w*)/gm,
+        /^trait\s+([A-Za-z_]\w*)/gm,
+        /^enum\s+([A-Za-z_]\w*)/gm,
+        /^function\s+([A-Za-z_]\w*)\s*\(/gm
       ];
-      for (const { regex, type } of patterns) {
+      for (const pattern of patterns) {
         let match;
+        while ((match = pattern.exec(code)) !== null) {
+          if (match[1])
+            exports3.push(match[1]);
+        }
+      }
+      return [...new Set(exports3)];
+    }
+    var PhpParser = {
+      lang: "php",
+      extensions: [".php", ".phtml", ".php3", ".php4", ".php5", ".php7"],
+      extractEntities,
+      extractImports,
+      extractExports,
+      entityPatterns: exports2.phpEntityPatterns
+    };
+    (0, registry_1.registerParser)(PhpParser);
+  }
+});
+
+// dist/languages/ruby.js
+var require_ruby = __commonJS({
+  "dist/languages/ruby.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.rubyEntityPatterns = void 0;
+    var registry_1 = require_registry();
+    var constants_1 = require_constants();
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function sanitizeMethodName(name) {
+      if (name.endsWith("!"))
+        return `${name.slice(0, -1)}_bang`;
+      if (name.endsWith("?"))
+        return `${name.slice(0, -1)}_pred`;
+      if (name.endsWith("="))
+        return `${name.slice(0, -1)}_eq`;
+      return name;
+    }
+    function estimateComplexity(code, name) {
+      const lines = code.split("\n");
+      const defRegex = new RegExp(`^[ \\t]*def\\s+(?:self\\.)?${escapeRegex(name)}(?:[!?=])?\\s*(\\(|$)`, "m");
+      const defLineIdx = lines.findIndex((l) => defRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      const bodyLines = [];
+      let depth = 0;
+      for (let i = defLineIdx; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (/\b(def|class|module|do\b|begin|if(?!.*\bend\b)|unless(?!.*\bend\b)|while(?!.*\bend\b)|until(?!.*\bend\b)|for\s|case\b)\b/.test(trimmed)) {
+          depth++;
+        }
+        if (/\bend\b/.test(trimmed)) {
+          depth--;
+          if (depth <= 0) {
+            bodyLines.push(line);
+            break;
+          }
+        }
+        bodyLines.push(line);
+      }
+      const body = bodyLines.join("\n");
+      const branches = (body.match(/\b(if|elsif|else|unless|while|until|for|rescue|when|and|or|&&|\|\|)\b/g) || []).length;
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
+        return "low";
+      if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
+        return "medium";
+      return "high";
+    }
+    exports2.rubyEntityPatterns = [
+      // class declarations (class Foo, class Foo < Bar)
+      {
+        regex: /^[ \t]*class\s+([A-Z]\w*(?:::[A-Z]\w*)*)\s*(?:<\s*\S+)?\s*$/gm,
+        type: "class"
+      },
+      // module declarations
+      {
+        regex: /^[ \t]*module\s+([A-Z]\w*(?:::[A-Z]\w*)*)\s*$/gm,
+        type: "class"
+      },
+      // singleton methods: def self.method_name[!?=]
+      {
+        regex: /^[ \t]*def\s+self\.([A-Za-z_]\w*[!?=]?)\s*(?:\(|$)/gm,
+        type: "function"
+      },
+      // instance methods: def method_name[!?=]
+      {
+        regex: /^[ \t]*def\s+([A-Za-z_]\w*[!?=]?)\s*(?:\(|$)/gm,
+        type: "function"
+      }
+    ];
+    function extractEntities(code, _filePath) {
+      const entities = [];
+      for (const { regex, type } of exports2.rubyEntityPatterns) {
         regex.lastIndex = 0;
+        let match;
         while ((match = regex.exec(code)) !== null) {
+          const rawName = match[1];
+          if (!rawName)
+            continue;
+          const name = type === "function" ? sanitizeMethodName(rawName) : rawName;
           const upToMatch = code.slice(0, match.index);
           const line = upToMatch.split("\n").length;
-          if (type === "api") {
-            entities.push({
-              name: `${match[1].toUpperCase()} ${match[2]}`,
-              type: "api",
-              line,
-              complexity: "low"
-            });
-          } else {
-            const name = match[1];
-            if (entities.some((e) => e.name === name))
-              continue;
-            entities.push({
-              name,
-              type,
-              line,
-              complexity: estimateComplexity(code, name)
-            });
-          }
+          if (entities.some((e) => e.name === name && e.line === line))
+            continue;
+          entities.push({
+            name,
+            type,
+            line,
+            complexity: type === "function" ? estimateComplexity(code, rawName) : "low"
+          });
         }
       }
       return entities;
     }
     function extractImports(code) {
       const imports = [];
-      const namedPattern = /^import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/gm;
+      const requirePattern = /^[ \t]*require\s+['"]([^'"]+)['"]/gm;
       let match;
-      while ((match = namedPattern.exec(code)) !== null) {
-        const names = match[1].split(",").map((n) => n.trim().replace(/\s+as\s+\w+/, ""));
-        const source = match[2];
-        imports.push({
-          source,
-          names,
-          isLocal: source.startsWith(".")
-        });
+      while ((match = requirePattern.exec(code)) !== null) {
+        const source = match[1];
+        const name = source.split("/").pop() || source;
+        imports.push({ source, names: [name], isLocal: false });
       }
-      const defaultPattern = /^import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/gm;
-      while ((match = defaultPattern.exec(code)) !== null) {
-        imports.push({
-          source: match[2],
-          names: [match[1]],
-          isLocal: match[2].startsWith(".")
-        });
+      const relPattern = /^[ \t]*require_relative\s+['"]([^'"]+)['"]/gm;
+      while ((match = relPattern.exec(code)) !== null) {
+        const source = match[1];
+        const name = source.split("/").pop() || source;
+        imports.push({ source, names: [name], isLocal: true });
       }
-      const requirePattern = /(?:const|let|var)\s+\{?([^}=]+)\}?\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm;
-      while ((match = requirePattern.exec(code)) !== null) {
-        const names = match[1].split(",").map((n) => n.trim());
-        imports.push({
-          source: match[2],
-          names,
-          isLocal: match[2].startsWith(".")
-        });
+      const loadPattern = /^[ \t]*load\s+['"]([^'"]+)['"]/gm;
+      while ((match = loadPattern.exec(code)) !== null) {
+        const source = match[1];
+        const name = source.split("/").pop()?.replace(/\.rb$/, "") || source;
+        imports.push({ source, names: [name], isLocal: true });
+      }
+      const mixinPattern = /^[ \t]*(?:include|extend|prepend)\s+([A-Z]\w*(?:::[A-Z]\w*)*)/gm;
+      while ((match = mixinPattern.exec(code)) !== null) {
+        const source = match[1];
+        const name = source.split("::").pop() || source;
+        imports.push({ source, names: [name], isLocal: false });
       }
       return imports;
     }
     function extractExports(code) {
       const exports3 = [];
-      const namedPattern = /^export\s+(?:default\s+)?(?:async\s+)?(?:function|class|const|let|var|type|interface)\s+(\w+)/gm;
+      const typePattern = /^(?:class|module)\s+([A-Z]\w*(?:::[A-Z]\w*)*)/gm;
       let match;
-      while ((match = namedPattern.exec(code)) !== null) {
+      while ((match = typePattern.exec(code)) !== null) {
         exports3.push(match[1]);
       }
-      const listPattern = /^export\s+\{([^}]+)\}/gm;
-      while ((match = listPattern.exec(code)) !== null) {
-        const names = match[1].split(",").map((n) => n.trim());
-        exports3.push(...names);
+      const attrPattern = /^[ \t]*attr_(?:reader|writer|accessor)\s+(.+)$/gm;
+      while ((match = attrPattern.exec(code)) !== null) {
+        const syms = match[1].split(",").map((s) => s.trim().replace(/^:/, ""));
+        exports3.push(...syms.filter(Boolean));
+      }
+      const pubFuncPattern = /^[ \t]*(?:module_function|public)\s+def\s+([A-Za-z_]\w*[!?=]?)/gm;
+      while ((match = pubFuncPattern.exec(code)) !== null) {
+        exports3.push(sanitizeMethodName(match[1]));
       }
       return [...new Set(exports3)];
     }
-    var JavaScriptParser = {
-      lang: "js",
-      extensions: [".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"],
+    var RubyParser = {
+      lang: "ruby",
+      extensions: [".rb", ".rake", ".gemspec"],
       extractEntities,
       extractImports,
-      extractExports
+      extractExports,
+      entityPatterns: exports2.rubyEntityPatterns
     };
-    (0, registry_1.registerParser)(JavaScriptParser);
+    (0, registry_1.registerParser)(RubyParser);
   }
 });
 
-// dist/languages/python.js
-var require_python = __commonJS({
-  "dist/languages/python.js"(exports2) {
+// dist/languages/swift.js
+var require_swift = __commonJS({
+  "dist/languages/swift.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.swiftEntityPatterns = void 0;
     var registry_1 = require_registry();
     var constants_1 = require_constants();
+    function escapeRegex(s) {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
     function estimateComplexity(code, name) {
       const lines = code.split("\n");
-      const defLine = lines.findIndex((l) => l.match(new RegExp(`def\\s+${name}\\s*\\(`)));
-      if (defLine === -1)
+      const defRegex = new RegExp(`(?:^|\\s)(?:func\\s+${escapeRegex(name)}|init|deinit|subscript)\\s*(?:<[^>]*>)?\\s*\\(`, "m");
+      const defLineIdx = lines.findIndex((l) => defRegex.test(l));
+      if (defLineIdx === -1)
+        return "low";
+      let startLine = defLineIdx;
+      while (startLine < lines.length && !lines[startLine].includes("{")) {
+        startLine++;
+      }
+      if (startLine >= lines.length)
         return "low";
+      let braceCount = 0;
+      let started = false;
       const bodyLines = [];
-      for (let i = defLine + 1; i < lines.length; i++) {
+      for (let i = startLine; i < lines.length; i++) {
         const line = lines[i];
-        if (line.trim() === "")
-          continue;
-        if (!line.match(/^\s+/))
-          break;
+        for (const ch of line) {
+          if (ch === "{") {
+            braceCount++;
+            started = true;
+          } else if (ch === "}") {
+            braceCount--;
+          }
+        }
         bodyLines.push(line);
+        if (started && braceCount <= 0)
+          break;
       }
       const body = bodyLines.join("\n");
-      const branches = (body.match(/\b(if|elif|else|for|while|except|and|or)\b/g) || []).length;
+      const branches = (body.match(/\b(if|else\s+if|else|for\s|while|repeat|switch|case|catch|guard|&&|\|\|)\b/g) || []).length;
       if (branches <= constants_1.COMPLEXITY_THRESHOLDS.low)
         return "low";
       if (branches <= constants_1.COMPLEXITY_THRESHOLDS.medium)
         return "medium";
       return "high";
     }
-    function extractEntities(code, filePath) {
+    exports2.swiftEntityPatterns = [
+      // class (including final class, open class, public class)
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate|open|final|@MainActor)\s+)*class\s+([A-Za-z_]\w*)(?:\s*<[^{]*?)?\s*(?::\s*[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // struct
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate)\s+)*struct\s+([A-Za-z_]\w*)(?:\s*<[^{]*?)?\s*(?::\s*[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // enum
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate|indirect)\s+)*enum\s+([A-Za-z_]\w*)(?:\s*<[^{]*?)?\s*(?::\s*[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // protocol
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate)\s+)*protocol\s+([A-Za-z_]\w*)(?:\s*<[^{]*?)?\s*(?::\s*[^{]+)?\s*\{/gm,
+        type: "interface"
+      },
+      // actor (Swift 5.5+)
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate|distributed)\s+)*actor\s+([A-Za-z_]\w*)(?:\s*:\s*[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // extension (cross-file method container, same type as class in Python extractor)
+      // Supports: extension Foo, extension Array where Element: Comparable
+      {
+        regex: /^[ \t]*extension\s+([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)(?:\s*<[^>{]*>)?(?:\s*:\s*[^{]+)?(?:\s+where\s+[^{]+)?\s*\{/gm,
+        type: "class"
+      },
+      // function declarations (including mutating, static, class func, override, async, throws)
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate|open|override|static|class|mutating|nonmutating|dynamic|final|required|convenience|async|throws|rethrows|nonisolated|@discardableResult|@objc|@MainActor)\s+)*func\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "function"
+      },
+      // init declarations
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate|override|required|convenience)\s+)*init\??\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "function"
+      },
+      // deinit
+      {
+        regex: /^[ \t]*deinit\s*\{/gm,
+        type: "function"
+      },
+      // subscript
+      {
+        regex: /^[ \t]*(?:(?:public|internal|private|fileprivate|static|override)\s+)*subscript\s*(?:<[^>]*>)?\s*\(/gm,
+        type: "function"
+      }
+    ];
+    function extractEntities(code, _filePath) {
       const entities = [];
-      const patterns = [
-        // regular functions
-        {
-          regex: /^(?:async\s+)?def\s+(\w+)\s*\(/gm,
-          type: "function"
-        },
-        // classes
-        {
-          regex: /^class\s+(\w+)(?:\s*\([^)]*\))?\s*:/gm,
-          type: "class"
-        }
-      ];
-      for (const { regex, type } of patterns) {
+      for (const { regex, type } of exports2.swiftEntityPatterns) {
         regex.lastIndex = 0;
         let match;
         while ((match = regex.exec(code)) !== null) {
-          const name = match[1];
-          if (type === "function" && name.startsWith("__") && name.endsWith("__"))
-            continue;
-          if (entities.some((e) => e.name === name))
-            continue;
+          const name = match[1] ?? (/\binit\b/.test(match[0]) ? "init" : /\bdeinit\b/.test(match[0]) ? "deinit" : "subscript");
           const upToMatch = code.slice(0, match.index);
           const line = upToMatch.split("\n").length;
+          if (entities.some((e) => e.name === name && e.line === line))
+            continue;
           entities.push({
             name,
             type,
@@ -294,40 +1570,53 @@ var require_python = __commonJS({
     }
     function extractImports(code) {
       const imports = [];
-      const fromPattern = /^from\s+([\w.]+)\s+import\s+(.+)$/gm;
+      const importPattern = /^[ \t]*import\s+(?:(?:class|struct|enum|func|var|let|typealias)\s+)?([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)/gm;
       let match;
-      while ((match = fromPattern.exec(code)) !== null) {
-        const source = match[1];
-        const names = match[2].split(",").map((n) => n.trim()).filter((n) => n.length > 0);
-        const isLocal = source.startsWith(".");
-        imports.push({ source, names, isLocal });
-      }
-      const importPattern = /^import\s+([\w.]+)/gm;
       while ((match = importPattern.exec(code)) !== null) {
-        const source = match[1];
+        const fullPath = match[1];
+        const moduleName = fullPath.split(".")[0];
+        if (["class", "struct", "enum", "func", "var", "let", "typealias"].includes(moduleName))
+          continue;
         imports.push({
-          source,
-          names: [source],
+          source: moduleName,
+          names: [moduleName],
           isLocal: false
-          // bare imports are always external
         });
       }
       return imports;
     }
     function extractExports(code) {
-      const allMatch = code.match(/__all__\s*=\s*\[([^\]]+)\]/);
-      if (!allMatch)
-        return [];
-      return allMatch[1].split(",").map((n) => n.trim().replace(/['"]/g, "")).filter((n) => n.length > 0);
+      const exports3 = [];
+      const publicPatterns = [
+        // public/open class, struct, enum, protocol, actor, extension
+        /^(?:(?:public|open|final)\s+)*(?:class|struct|enum|protocol|actor)\s+([A-Za-z_]\w*)/gm,
+        // public extension is not really an export, but surfaces it for graph linking
+        /^(?:public\s+)?extension\s+([A-Za-z_]\w*)/gm,
+        // public func
+        /^[ \t]*(?:public|open)\s+(?:(?:static|class|override|mutating|async|throws|nonisolated)\s+)*func\s+([A-Za-z_]\w*)/gm,
+        // public var / let
+        /^[ \t]*(?:public|open)\s+(?:(?:static|class|lazy|private\(set\)|internal\(set\))\s+)*(?:var|let)\s+([A-Za-z_]\w*)/gm,
+        // public init
+        /^[ \t]*(?:public|open)\s+(?:required\s+|convenience\s+)?init/gm
+      ];
+      for (const pattern of publicPatterns) {
+        let match;
+        while ((match = pattern.exec(code)) !== null) {
+          if (match[1])
+            exports3.push(match[1]);
+        }
+      }
+      return [...new Set(exports3)];
     }
-    var PythonParser = {
-      lang: "py",
-      extensions: [".py"],
+    var SwiftParser = {
+      lang: "swift",
+      extensions: [".swift"],
       extractEntities,
       extractImports,
-      extractExports
+      extractExports,
+      entityPatterns: exports2.swiftEntityPatterns
     };
-    (0, registry_1.registerParser)(PythonParser);
+    (0, registry_1.registerParser)(SwiftParser);
   }
 });
 
@@ -405,13 +1694,17 @@ var require_parser = __commonJS({
       const parser = (0, registry_1.getLanguageParser)(ext);
       if (!parser)
         return null;
+      const isHashCommentLang = [".py", ".rb", ".sh", ".bash", ".ps1"].includes(ext);
+      const commentChar = isHashCommentLang ? "#" : "//";
       const cleanCode = code.split("\n").map((line) => {
-        const commentIndex = line.indexOf("//");
+        const commentIndex = line.indexOf(commentChar);
         if (commentIndex === -1)
           return line;
         const before = line.slice(0, commentIndex);
-        const inString = (before.match(/"/g) || []).length % 2 !== 0 || (before.match(/'/g) || []).length % 2 !== 0;
-        return inString ? line : line.slice(0, commentIndex);
+        const inDouble = (before.match(/"/g) || []).length % 2 !== 0;
+        const inSingle = (before.match(/'/g) || []).length % 2 !== 0;
+        const inBacktick = (before.match(/`/g) || []).length % 2 !== 0;
+        return inDouble || inSingle || inBacktick ? line : line.slice(0, commentIndex);
       }).join("\n");
       const lines = code.split("\n").length;
       const entities = parser.extractEntities(cleanCode, filePath);
@@ -812,6 +2105,157 @@ var require_output = __commonJS({
   }
 });
 
+// dist/stages/gitdiff.js
+var require_gitdiff = __commonJS({
+  "dist/stages/gitdiff.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getChangedEntities = getChangedEntities;
+    var child_process_1 = require("child_process");
+    var path_1 = __importDefault2(require("path"));
+    var registry_1 = require_registry();
+    function getChangedEntities(options) {
+      const diff = runGitDiff(options);
+      if (!diff)
+        return [];
+      return parseDiff(diff, options.projectDir);
+    }
+    function runGitDiff(options) {
+      const { projectDir: projectDir2, mode, commit, from, to } = options;
+      let command;
+      if (mode === "uncommitted") {
+        command = "git diff HEAD";
+      } else if (mode === "last-commit") {
+        if (commit) {
+          command = `git diff ${commit}~1 ${commit}`;
+        } else {
+          command = "git diff HEAD~1 HEAD";
+        }
+      } else if (mode === "branches") {
+        if (!from || !to) {
+          console.warn("\u26A0 --from and --to are required for branch comparison");
+          return null;
+        }
+        command = `git diff ${from}...${to}`;
+      } else {
+        return null;
+      }
+      try {
+        const result = (0, child_process_1.execSync)(command, {
+          cwd: projectDir2,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        return result || null;
+      } catch (err) {
+        console.warn(`\u26A0 Git command failed: ${command}`);
+        console.warn(`  Make sure ${projectDir2} is a git repository`);
+        return null;
+      }
+    }
+    function parseDiff(diff, projectDir2) {
+      const entities = [];
+      const lines = diff.split("\n");
+      let currentFile = "";
+      let changeType = "modified";
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith("diff --git")) {
+          const fileMatch = line.match(/b\/(.+)$/);
+          if (fileMatch) {
+            currentFile = fileMatch[1];
+          }
+          changeType = "modified";
+          continue;
+        }
+        if (line.startsWith("new file mode")) {
+          changeType = "added";
+          continue;
+        }
+        if (line.startsWith("deleted file mode")) {
+          changeType = "deleted";
+          continue;
+        }
+        if (line.startsWith("index ")) {
+          if (changeType === "modified")
+            changeType = "modified";
+          continue;
+        }
+        if (line.startsWith("@@")) {
+          const contextMatch = line.match(/@@[^@]*@@\s*(.+)$/);
+          if (contextMatch) {
+            const context = contextMatch[1].trim();
+            const entity = extractEntityFromContext(context, currentFile);
+            if (entity) {
+              const description = buildDescription(lines, i, entity.name);
+              const alreadyFound = entities.some((e) => e.name === entity.name && e.file === currentFile);
+              if (!alreadyFound) {
+                entities.push({
+                  name: entity.name,
+                  file: currentFile,
+                  changeType,
+                  description
+                });
+              }
+            }
+          }
+          continue;
+        }
+      }
+      return entities;
+    }
+    function extractEntityFromContext(context, file) {
+      const ext = path_1.default.extname(file).toLowerCase();
+      const parser = (0, registry_1.getLanguageParser)(ext);
+      if (parser?.entityPatterns) {
+        for (const { regex, type } of parser.entityPatterns) {
+          if (type === "api")
+            continue;
+          const singleLineRegex = new RegExp(regex.source, regex.flags.replace("g", ""));
+          const m = singleLineRegex.exec(context);
+          if (m?.[1])
+            return { name: m[1], type };
+        }
+        return null;
+      }
+      if ([".java", ".cs"].includes(ext)) {
+        const m = context.match(/(?:public|private|protected|static|override|async|virtual)\s+\S+\s+(\w+)\s*\(/);
+        if (m)
+          return { name: m[1], type: "method" };
+      }
+      return null;
+    }
+    function buildDescription(lines, contextIdx, entityName) {
+      const added = [];
+      const removed = [];
+      for (let i = contextIdx + 1; i < Math.min(contextIdx + 20, lines.length); i++) {
+        const line = lines[i];
+        if (line.startsWith("@@") || line.startsWith("diff"))
+          break;
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+          added.push(line.slice(1).trim());
+        }
+        if (line.startsWith("-") && !line.startsWith("---")) {
+          removed.push(line.slice(1).trim());
+        }
+      }
+      if (added.length === 0 && removed.length > 0) {
+        return `${entityName}: ${removed.length} line(s) removed`;
+      }
+      if (added.length > 0 && removed.length === 0) {
+        return `${entityName}: ${added.length} line(s) added`;
+      }
+      if (added.length > 0 && removed.length > 0) {
+        return `${entityName}: ${removed.length} line(s) changed to ${added.length} new line(s)`;
+      }
+      return `${entityName}: modified`;
+    }
+  }
+});
+
 // dist/main.js
 var __importDefault = exports && exports.__importDefault || function(mod) {
   return mod && mod.__esModule ? mod : { "default": mod };
@@ -819,6 +2263,13 @@ var __importDefault = exports && exports.__importDefault || function(mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 require_javascript();
 require_python();
+require_go();
+require_csharp();
+require_java();
+require_kotlin();
+require_php();
+require_ruby();
+require_swift();
 var fs_1 = __importDefault(require("fs"));
 var collector_1 = require_collector();
 var parser_1 = require_parser();
@@ -826,6 +2277,7 @@ var graph_1 = require_graph();
 var metrics_1 = require_metrics();
 var impact_1 = require_impact();
 var output_1 = require_output();
+var gitdiff_1 = require_gitdiff();
 var args = process.argv.slice(2);
 var noColor = args.includes("--no-color");
 var verbose = args.includes("--verbose");
@@ -846,11 +2298,11 @@ function getFlag(flag) {
 }
 function printHelp() {
   console.log(`
-${bold("DepGraph Compiler")} ${dim("v1.0.2")}
+${bold("DepGraph")} ${dim("v1.5.0")}
 ${dim("Dependency mapping \xB7 Impact simulation \xB7 Developer intelligence")}
 
 ${bold("USAGE")}
-  node depgraph.js ${cyan("<projectDir>")} ${dim("[options]")}
+  depgraph ${cyan("<projectDir>")} ${dim("[options]")}
 
 ${bold("OPTIONS")}
   ${cyan("--output")}  ${dim("<file>")}        Output path  ${dim("(default: ./depgraph-output.json)")}
@@ -859,24 +2311,43 @@ ${bold("OPTIONS")}
   ${cyan("--no-color")}               Disable colors ${dim("(for CI)")}
   ${cyan("--help, -h")}               Show this help message
 
+${bold("GIT FLAGS")}
+  ${cyan("--git-impact")}              Auto-detect changes from git diff
+  ${cyan("--commit")}  ${dim("<sha>")}          Analyze a specific commit
+  ${cyan("--from")}    ${dim("<branch>")}        Compare from this branch
+  ${cyan("--to")}      ${dim("<branch>")}        Compare to this branch
+
 ${bold("EXAMPLES")}
   ${dim("# Map a project")}
-  node depgraph.js ./my-app
+  depgraph ./my-app
 
   ${dim("# Map with custom output")}
-  node depgraph.js ./my-app --output ./reports/graph.json
+  depgraph ./my-app --output ./reports/graph.json
 
   ${dim("# Simulate a change")}
-  node depgraph.js ./my-app --impact "getUserById" "removing userId param"
+  depgraph ./my-app --impact "getUserById" "removing userId param"
 
   ${dim("# CI mode")}
-  node depgraph.js ./src --no-color --output ./ci/depgraph.json
+  depgraph ./src --no-color --output ./ci/depgraph.json
+
+${bold("GIT EXAMPLES")}
+  ${dim("# Analyze uncommitted changes")}
+  depgraph ./src --git-impact
+
+  ${dim("# Analyze last commit")}
+  depgraph ./src --git-impact --commit HEAD
+
+  ${dim("# Compare two branches")}
+  depgraph ./src --git-impact --from main --to feature/my-branch
+
+  ${dim("# Specific commit")}
+  depgraph ./src --git-impact --commit abc1234
 `);
 }
 function printBanner() {
   console.log(`
 ${bold("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501")}
-${bold("  DepGraph Compiler")}  ${dim("v1.0.0")}
+${bold("  DepGraph")}  ${dim("v1.0.0")}
 ${bold("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501")}
 `);
 }
@@ -936,6 +2407,11 @@ var projectDir = args[0];
 var outputPath = getFlag("--output") ?? "./depgraph-output.json";
 var impactTarget = getFlag("--impact");
 var impactDesc = impactTarget ? args[args.indexOf("--impact") + 2] ?? "no description provided" : void 0;
+var gitImpact = args.includes("--git-impact");
+var gitCommit = getFlag("--commit");
+var gitFrom = getFlag("--from");
+var gitTo = getFlag("--to");
+var gitMode = gitFrom && gitTo ? "branches" : gitCommit ? "last-commit" : "uncommitted";
 printBanner();
 console.log(`${bold("\u{1F50D} Scanning")} ${cyan(projectDir)}
 `);
@@ -959,6 +2435,34 @@ try {
   if (impactTarget) {
     impact = (0, impact_1.simulateImpact)(metrics, impactTarget, impactDesc ?? "");
     printImpact(impact);
+  } else if (gitImpact) {
+    console.log(`
+${bold("\u{1F50D} Reading git diff...")}`);
+    const changed = (0, gitdiff_1.getChangedEntities)({
+      projectDir,
+      mode: gitMode,
+      commit: gitCommit,
+      from: gitFrom,
+      to: gitTo
+    });
+    if (changed.length === 0) {
+      console.log(`
+${green("\u2713")} No changed entities found in diff`);
+    } else {
+      console.log(`
+${bold(`Found ${changed.length} changed entity(s):`)}`);
+      for (const entity of changed) {
+        console.log(`   ${dim("\u2192")} ${entity.name}  ${dim(`(${entity.file})`)}`);
+      }
+      console.log(`
+${bold("Running impact simulation...")}`);
+      for (const entity of changed) {
+        console.log(`
+${dim("\u2500".repeat(42))}`);
+        const result = (0, impact_1.simulateImpact)(metrics, entity.name, entity.description);
+        printImpact(result);
+      }
+    }
   }
   (0, output_1.writeOutput)(metrics, parsed, outputPath, impact);
 } catch (err) {