@vohongtho.infotech/code-intel 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,18 +1,4833 @@
-export { createKnowledgeGraph } from './graph/index.js';
-export { generateNodeId, generateEdgeId } from './graph/index.js';
-export { initParser, getParser, getLanguage, parseSource, runQuery, AstCache } from './parsing/index.js';
-export { getLanguageModule, getAllLanguageModules } from './languages/index.js';
-export { resolveImports, BindingTracker } from './resolver/index.js';
-export { buildCallEdges, classifyCall } from './call-graph/index.js';
-export { buildHeritageEdges, computeMRO, detectOverrides } from './inheritance/index.js';
-export { runPipeline, validateDAG, topologicalSort } from './pipeline/index.js';
-export { scanPhase, structurePhase, parsePhase, resolvePhase, clusterPhase, flowPhase, } from './pipeline/index.js';
-export { createScope, resolveBinding, addBinding } from './scope-analysis/index.js';
-export { detectCommunities, addClustersToGraph } from './clustering/index.js';
-export { findEntryPoints, traceFlow } from './flow-detection/index.js';
-export { textSearch, reciprocalRankFusion } from './search/index.js';
-export { createMcpServer, startMcpStdio } from './mcp-server/index.js';
-export { createApp, startHttpServer } from './http/index.js';
-export { DbManager, loadGraphToDB, upsertRepo, loadRegistry, removeRepo, saveMetadata, loadMetadata, getDbPath } from './storage/index.js';
-export { listGroups, getGroup, createGroup, deleteGroup, mergeSearchResults } from './multi-repo/index.js';
+import fs6 from 'fs';
+import path6 from 'path';
+import os3 from 'os';
+import { Parser, Language, Query } from 'web-tree-sitter';
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Database, Connection } from '@ladybugdb/core';
+import { execSync } from 'child_process';
+import express from 'express';
+import cors from 'cors';
+import { fileURLToPath } from 'url';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/search/embedder.ts
+var embedder_exports = {};
+__export(embedder_exports, {
+  embedNodes: () => embedNodes
+});
+async function getEmbedder() {
+  if (!pipelineInstance) {
+    const { pipeline } = await import('@huggingface/transformers');
+    pipelineInstance = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+  }
+  return pipelineInstance;
+}
+async function embedNodes(graph, opts = {}) {
+  const { batchSize = 32, onProgress } = opts;
+  const candidates = [];
+  for (const node of graph.allNodes()) {
+    if (["cluster", "directory", "flow"].includes(node.kind)) continue;
+    const text = buildText(node);
+    candidates.push({ id: node.id, name: node.name, kind: node.kind, filePath: node.filePath, text });
+  }
+  const embedder = await getEmbedder();
+  const results = [];
+  for (let i = 0; i < candidates.length; i += batchSize) {
+    const batch = candidates.slice(i, i + batchSize);
+    const texts = batch.map((c) => c.text);
+    for (let j = 0; j < texts.length; j++) {
+      const out = await embedder(texts[j], { pooling: "mean", normalize: true });
+      results.push({ ...batch[j], embedding: Array.from(out.data) });
+    }
+    onProgress?.(Math.min(i + batchSize, candidates.length), candidates.length);
+  }
+  return results;
+}
+function buildText(node) {
+  const parts = [`${node.kind} ${node.name}`];
+  const sig = node.metadata?.signature;
+  if (sig) parts.push(sig);
+  if (node.content) parts.push(node.content.slice(0, 256));
+  parts.push(node.filePath);
+  return parts.join(" ").slice(0, 512);
+}
+var pipelineInstance;
+var init_embedder = __esm({
+  "src/search/embedder.ts"() {
+    pipelineInstance = null;
+  }
+});
+
+// src/multi-repo/group-registry.ts
+var group_registry_exports = {};
+__export(group_registry_exports, {
+  addMember: () => addMember,
+  deleteGroup: () => deleteGroup,
+  groupExists: () => groupExists,
+  listGroups: () => listGroups,
+  loadGroup: () => loadGroup,
+  loadSyncResult: () => loadSyncResult,
+  removeMember: () => removeMember,
+  saveGroup: () => saveGroup,
+  saveSyncResult: () => saveSyncResult
+});
+function groupFile(name) {
+  return path6.join(GROUPS_DIR, `${name}.json`);
+}
+function loadGroup(name) {
+  try {
+    return JSON.parse(fs6.readFileSync(groupFile(name), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveGroup(group) {
+  fs6.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs6.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+}
+function listGroups() {
+  const groups = [];
+  try {
+    for (const file of fs6.readdirSync(GROUPS_DIR)) {
+      if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
+      try {
+        const g = JSON.parse(
+          fs6.readFileSync(path6.join(GROUPS_DIR, file), "utf-8")
+        );
+        groups.push(g);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return groups;
+}
+function deleteGroup(name) {
+  try {
+    fs6.unlinkSync(groupFile(name));
+  } catch {
+  }
+  try {
+    fs6.unlinkSync(path6.join(GROUPS_DIR, `${name}.sync.json`));
+  } catch {
+  }
+}
+function groupExists(name) {
+  return fs6.existsSync(groupFile(name));
+}
+function addMember(groupName, member) {
+  const group = loadGroup(groupName);
+  if (!group) throw new Error(`Group "${groupName}" not found.`);
+  const idx = group.members.findIndex((m) => m.groupPath === member.groupPath);
+  if (idx >= 0) {
+    group.members[idx] = member;
+  } else {
+    group.members.push(member);
+  }
+  saveGroup(group);
+  return group;
+}
+function removeMember(groupName, groupPath) {
+  const group = loadGroup(groupName);
+  if (!group) throw new Error(`Group "${groupName}" not found.`);
+  const before = group.members.length;
+  group.members = group.members.filter((m) => m.groupPath !== groupPath);
+  if (group.members.length === before) {
+    throw new Error(`No member at path "${groupPath}" in group "${groupName}".`);
+  }
+  saveGroup(group);
+  return group;
+}
+function saveSyncResult(result) {
+  fs6.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs6.writeFileSync(
+    path6.join(GROUPS_DIR, `${result.groupName}.sync.json`),
+    JSON.stringify(result, null, 2) + "\n"
+  );
+}
+function loadSyncResult(groupName) {
+  try {
+    return JSON.parse(
+      fs6.readFileSync(path6.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+    );
+  } catch {
+    return null;
+  }
+}
+var GROUPS_DIR;
+var init_group_registry = __esm({
+  "src/multi-repo/group-registry.ts"() {
+    GROUPS_DIR = path6.join(os3.homedir(), ".code-intel", "groups");
+  }
+});
+
+// src/graph/knowledge-graph.ts
+function createKnowledgeGraph() {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const edgesByKind = /* @__PURE__ */ new Map();
+  const edgesFromNode = /* @__PURE__ */ new Map();
+  const edgesToNode = /* @__PURE__ */ new Map();
+  function indexEdge(edge) {
+    let kindSet = edgesByKind.get(edge.kind);
+    if (!kindSet) {
+      kindSet = /* @__PURE__ */ new Set();
+      edgesByKind.set(edge.kind, kindSet);
+    }
+    kindSet.add(edge.id);
+    let fromSet = edgesFromNode.get(edge.source);
+    if (!fromSet) {
+      fromSet = /* @__PURE__ */ new Set();
+      edgesFromNode.set(edge.source, fromSet);
+    }
+    fromSet.add(edge.id);
+    let toSet = edgesToNode.get(edge.target);
+    if (!toSet) {
+      toSet = /* @__PURE__ */ new Set();
+      edgesToNode.set(edge.target, toSet);
+    }
+    toSet.add(edge.id);
+  }
+  function unindexEdge(edge) {
+    edgesByKind.get(edge.kind)?.delete(edge.id);
+    edgesFromNode.get(edge.source)?.delete(edge.id);
+    edgesToNode.get(edge.target)?.delete(edge.id);
+  }
+  return {
+    addNode(node) {
+      nodes.set(node.id, node);
+    },
+    addEdge(edge) {
+      edges.set(edge.id, edge);
+      indexEdge(edge);
+    },
+    getNode(id) {
+      return nodes.get(id);
+    },
+    getEdge(id) {
+      return edges.get(id);
+    },
+    *findEdgesByKind(kind) {
+      const ids = edgesByKind.get(kind);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesFrom(sourceId) {
+      const ids = edgesFromNode.get(sourceId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    *findEdgesTo(targetId) {
+      const ids = edgesToNode.get(targetId);
+      if (!ids) return;
+      for (const id of ids) {
+        const edge = edges.get(id);
+        if (edge) yield edge;
+      }
+    },
+    removeNodeCascade(id) {
+      const fromEdges = edgesFromNode.get(id);
+      if (fromEdges) {
+        for (const edgeId of [...fromEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
+        }
+      }
+      const toEdges = edgesToNode.get(id);
+      if (toEdges) {
+        for (const edgeId of [...toEdges]) {
+          const edge = edges.get(edgeId);
+          if (edge) {
+            unindexEdge(edge);
+            edges.delete(edgeId);
+          }
+        }
+      }
+      edgesFromNode.delete(id);
+      edgesToNode.delete(id);
+      nodes.delete(id);
+    },
+    removeEdge(id) {
+      const edge = edges.get(id);
+      if (edge) {
+        unindexEdge(edge);
+        edges.delete(id);
+      }
+    },
+    *allNodes() {
+      yield* nodes.values();
+    },
+    *allEdges() {
+      yield* edges.values();
+    },
+    get size() {
+      return { nodes: nodes.size, edges: edges.size };
+    },
+    clear() {
+      nodes.clear();
+      edges.clear();
+      edgesByKind.clear();
+      edgesFromNode.clear();
+      edgesToNode.clear();
+    }
+  };
+}
+
+// src/graph/id-generator.ts
+function generateNodeId(kind, filePath, qualifiedName) {
+  return `${kind}:${filePath}:${qualifiedName}`;
+}
+function generateEdgeId(source, target, kind) {
+  return `${kind}:${source}->${target}`;
+}
+var initialized = false;
+var parserCache = /* @__PURE__ */ new Map();
+var languageCache = /* @__PURE__ */ new Map();
+var GRAMMAR_WASM_MAP = {
+  // WASM grammar files to be downloaded/provided per language
+  // For now, the parser manager provides a placeholder
+};
+async function initParser() {
+  if (initialized) return;
+  await Parser.init();
+  initialized = true;
+}
+async function getParser(lang) {
+  await initParser();
+  let parser = parserCache.get(lang);
+  if (parser) return parser;
+  parser = new Parser();
+  parserCache.set(lang, parser);
+  return parser;
+}
+async function getLanguage(lang) {
+  const cached = languageCache.get(lang);
+  if (cached) return cached;
+  const wasmPath = GRAMMAR_WASM_MAP[lang];
+  if (!wasmPath) return null;
+  try {
+    const language = await Language.load(wasmPath);
+    languageCache.set(lang, language);
+    return language;
+  } catch {
+    return null;
+  }
+}
+async function parseSource(lang, source) {
+  const parser = await getParser(lang);
+  const language = await getLanguage(lang);
+  if (!language) return null;
+  parser.setLanguage(language);
+  return parser.parse(source);
+}
+function runQuery(tree, language, querySource) {
+  const query = new Query(language, querySource);
+  const matches = query.matches(tree.rootNode);
+  const captures = [];
+  for (const match of matches) {
+    for (const capture of match.captures) {
+      captures.push({
+        name: capture.name,
+        node: capture.node,
+        text: capture.node.text
+      });
+    }
+  }
+  return captures;
+}
+
+// src/parsing/ast-cache.ts
+var DEFAULT_MAX = 500;
+var AstCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(maxEntries = DEFAULT_MAX) {
+    this.maxEntries = maxEntries;
+  }
+  get(filePath) {
+    const entry = this.cache.get(filePath);
+    if (entry) {
+      entry.accessedAt = Date.now();
+      return entry.tree;
+    }
+    return void 0;
+  }
+  set(filePath, tree) {
+    if (this.cache.size >= this.maxEntries) {
+      this.evictLRU();
+    }
+    this.cache.set(filePath, { tree, accessedAt: Date.now() });
+  }
+  has(filePath) {
+    return this.cache.has(filePath);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  evictLRU() {
+    let oldest = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache) {
+      if (entry.accessedAt < oldestTime) {
+        oldest = key;
+        oldestTime = entry.accessedAt;
+      }
+    }
+    if (oldest) {
+      this.cache.delete(oldest);
+    }
+  }
+};
+
+// src/shared/detection.ts
+var EXTENSION_MAP = {
+  ".ts": "typescript" /* TypeScript */,
+  ".tsx": "typescript" /* TypeScript */,
+  ".mts": "typescript" /* TypeScript */,
+  ".cts": "typescript" /* TypeScript */,
+  ".js": "javascript" /* JavaScript */,
+  ".jsx": "javascript" /* JavaScript */,
+  ".mjs": "javascript" /* JavaScript */,
+  ".cjs": "javascript" /* JavaScript */,
+  ".py": "python" /* Python */,
+  ".pyi": "python" /* Python */,
+  ".java": "java" /* Java */,
+  ".go": "go" /* Go */,
+  ".c": "c" /* C */,
+  ".h": "c" /* C */,
+  ".cpp": "cpp" /* Cpp */,
+  ".cxx": "cpp" /* Cpp */,
+  ".cc": "cpp" /* Cpp */,
+  ".hpp": "cpp" /* Cpp */,
+  ".hxx": "cpp" /* Cpp */,
+  ".cs": "csharp" /* CSharp */,
+  ".rs": "rust" /* Rust */,
+  ".php": "php" /* PHP */,
+  ".kt": "kotlin" /* Kotlin */,
+  ".kts": "kotlin" /* Kotlin */,
+  ".rb": "ruby" /* Ruby */,
+  ".swift": "swift" /* Swift */,
+  ".dart": "dart" /* Dart */
+};
+function detectLanguage(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXTENSION_MAP[ext] ?? null;
+}
+function getSupportedExtensions() {
+  return Object.keys(EXTENSION_MAP);
+}
+
+// src/parsing/queries/typescript.ts
+var typescriptQueries = `
+;; Class declaration
+(class_declaration
+  name: (type_identifier) @def.class.name) @def.class
+
+;; Abstract class
+(abstract_class_declaration
+  name: (type_identifier) @def.class.name) @def.class
+
+;; Interface declaration
+(interface_declaration
+  name: (type_identifier) @def.interface.name) @def.interface
+
+;; Type alias
+(type_alias_declaration
+  name: (type_identifier) @def.type_alias.name) @def.type_alias
+
+;; Enum
+(enum_declaration
+  name: (identifier) @def.enum.name) @def.enum
+
+;; Function declaration
+(function_declaration
+  name: (identifier) @def.func.name) @def.func
+
+;; Arrow function in variable
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @def.func.name
+    value: (arrow_function))) @def.func
+
+;; Const/let/var variable (non-function)
+(lexical_declaration
+  (variable_declarator
+    name: (identifier) @def.var.name
+    value: (_) @def.var.value)) @def.var
+
+;; Method definition
+(method_definition
+  name: (property_identifier) @def.method.name) @def.method
+
+;; Public field definition
+(public_field_definition
+  name: (property_identifier) @def.property.name) @def.property
+
+;; Import statement
+(import_statement
+  source: (string) @imp.source) @imp
+
+;; Import specifier
+(import_specifier
+  name: (identifier) @imp.name)
+
+;; Namespace import
+(namespace_import (identifier) @imp.namespace)
+
+;; Export statement
+(export_statement) @export
+
+;; Call expression \u2014 function call
+(call_expression
+  function: (identifier) @call.name) @call
+
+;; Call expression \u2014 member call
+(call_expression
+  function: (member_expression
+    object: (_) @call.receiver
+    property: (property_identifier) @call.method)) @call.member
+
+;; New expression
+(new_expression
+  constructor: (identifier) @call.constructor) @call.new
+
+;; Class heritage \u2014 extends
+(class_heritage
+  (extends_clause
+    value: (identifier) @inherit.extends))
+
+;; Class heritage \u2014 implements
+(class_heritage
+  (implements_clause
+    (type_reference (type_identifier) @inherit.implements)))
+`;
+function resolveRelative(rawPath, fromFile, workspace) {
+  const fromDir = path6.dirname(fromFile);
+  const cleaned = rawPath.replace(/['"]/g, "");
+  const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"];
+  const resolved = workspace.resolve(fromDir, cleaned);
+  if (resolved) return resolved;
+  for (const ext of extensions) {
+    const r = workspace.resolve(fromDir, cleaned + ext);
+    if (r) return r;
+  }
+  return null;
+}
+var typescriptModule = {
+  lang: "typescript" /* TypeScript */,
+  fileExtensions: [".ts", ".tsx", ".mts", ".cts"],
+  queries: typescriptQueries,
+  importStyle: "explicit",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    if (cleaned.startsWith(".")) {
+      return resolveRelative(rawPath, fromFile, workspace);
+    }
+    return workspace.findByPackage(cleaned);
+  },
+  isExported(node) {
+    const parent = node.parent;
+    if (!parent) return false;
+    return parent.type === "export_statement" || node.type === "export_statement";
+  },
+  extractType(node) {
+    const typeAnnotation = node.childForFieldName("type");
+    return typeAnnotation?.text ?? null;
+  }
+};
+var javascriptModule = {
+  ...typescriptModule,
+  lang: "javascript" /* JavaScript */,
+  fileExtensions: [".js", ".jsx", ".mjs", ".cjs"]
+};
+
+// src/parsing/queries/python.ts
+var pythonQueries = `
+;; Class definition
+(class_definition
+  name: (identifier) @def.class.name) @def.class
+
+;; Function definition
+(function_definition
+  name: (identifier) @def.func.name) @def.func
+
+;; Decorated definition
+(decorated_definition
+  (function_definition
+    name: (identifier) @def.func.name)) @def.func.decorated
+
+;; Import from
+(import_from_statement
+  module_name: (dotted_name) @imp.source) @imp
+
+;; Import
+(import_statement
+  name: (dotted_name) @imp.module) @imp.direct
+
+;; Import alias
+(aliased_import
+  name: (dotted_name) @imp.alias.original
+  alias: (identifier) @imp.alias.name)
+
+;; Call expression
+(call
+  function: (identifier) @call.name) @call
+
+;; Attribute call
+(call
+  function: (attribute
+    object: (_) @call.receiver
+    attribute: (identifier) @call.method)) @call.member
+
+;; Assignment
+(assignment
+  left: (identifier) @def.var.name) @def.var
+
+;; Class base classes
+(class_definition
+  superclasses: (argument_list
+    (identifier) @inherit.extends))
+`;
+var pythonModule = {
+  lang: "python" /* Python */,
+  fileExtensions: [".py", ".pyi"],
+  queries: pythonQueries,
+  importStyle: "namespace",
+  inheritanceStrategy: "c3",
+  resolveImport(rawPath, fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    const parts = cleaned.split(".");
+    const fromDir = path6.dirname(fromFile);
+    const relPath = parts.join("/");
+    for (const suffix of ["/__init__.py", ".py"]) {
+      const r = workspace.resolve(fromDir, relPath + suffix);
+      if (r) return r;
+    }
+    return workspace.findByPackage(cleaned);
+  },
+  isExported(node) {
+    const name = node.childForFieldName("name");
+    if (!name) return true;
+    return !name.text.startsWith("_");
+  },
+  extractType(node) {
+    const returnType = node.childForFieldName("return_type");
+    return returnType?.text ?? null;
+  }
+};
+
+// src/parsing/queries/java.ts
+var javaQueries = `
+;; Class declaration
+(class_declaration
+  name: (identifier) @def.class.name) @def.class
+
+;; Interface declaration
+(interface_declaration
+  name: (identifier) @def.interface.name) @def.interface
+
+;; Enum declaration
+(enum_declaration
+  name: (identifier) @def.enum.name) @def.enum
+
+;; Method declaration
+(method_declaration
+  name: (identifier) @def.method.name) @def.method
+
+;; Constructor declaration
+(constructor_declaration
+  name: (identifier) @def.constructor.name) @def.constructor
+
+;; Field declaration
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @def.property.name)) @def.property
+
+;; Import
+(import_declaration
+  (scoped_identifier) @imp.source) @imp
+
+;; Call
+(method_invocation
+  name: (identifier) @call.name) @call
+
+;; Object creation
+(object_creation_expression
+  type: (type_identifier) @call.constructor) @call.new
+
+;; Extends
+(superclass (type_identifier) @inherit.extends)
+
+;; Implements
+(super_interfaces
+  (type_list (type_identifier) @inherit.implements))
+`;
+
+// src/languages/modules/java.ts
+var javaModule = {
+  lang: "java" /* Java */,
+  fileExtensions: [".java"],
+  queries: javaQueries,
+  importStyle: "explicit",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    const filePath = cleaned.replace(/\./g, "/") + ".java";
+    return workspace.findByPackage(filePath);
+  },
+  isExported(node) {
+    const text = node.text;
+    return text.includes("public");
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/parsing/queries/go.ts
+var goQueries = `
+;; Function declaration
+(function_declaration
+  name: (identifier) @def.func.name) @def.func
+
+;; Method declaration
+(method_declaration
+  name: (field_identifier) @def.method.name) @def.method
+
+;; Type declaration \u2014 struct
+(type_declaration
+  (type_spec
+    name: (type_identifier) @def.struct.name
+    type: (struct_type))) @def.struct
+
+;; Type declaration \u2014 interface
+(type_declaration
+  (type_spec
+    name: (type_identifier) @def.interface.name
+    type: (interface_type))) @def.interface
+
+;; Import spec
+(import_spec
+  path: (interpreted_string_literal) @imp.source) @imp
+
+;; Call expression
+(call_expression
+  function: (identifier) @call.name) @call
+
+;; Selector call
+(call_expression
+  function: (selector_expression
+    operand: (_) @call.receiver
+    field: (field_identifier) @call.method)) @call.member
+
+;; Const declaration
+(const_declaration
+  (const_spec
+    name: (identifier) @def.constant.name)) @def.constant
+
+;; Var declaration
+(var_declaration
+  (var_spec
+    name: (identifier) @def.var.name)) @def.var
+`;
+
+// src/languages/modules/go.ts
+var goModule = {
+  lang: "go" /* Go */,
+  fileExtensions: [".go"],
+  queries: goQueries,
+  importStyle: "wildcard",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    return workspace.findByPackage(cleaned);
+  },
+  isExported(node) {
+    const name = node.childForFieldName("name");
+    if (!name) return false;
+    const first = name.text[0];
+    return first === first.toUpperCase() && first !== first.toLowerCase();
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/parsing/queries/c.ts
+var cQueries = `
+;; Function definition
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @def.func.name)) @def.func
+
+;; Struct specifier
+(struct_specifier
+  name: (type_identifier) @def.struct.name) @def.struct
+
+;; Enum specifier
+(enum_specifier
+  name: (type_identifier) @def.enum.name) @def.enum
+
+;; Typedef
+(type_definition
+  declarator: (type_identifier) @def.type_alias.name) @def.type_alias
+
+;; Include
+(preproc_include
+  path: (_) @imp.source) @imp
+
+;; Call
+(call_expression
+  function: (identifier) @call.name) @call
+
+;; Global variable
+(declaration
+  declarator: (init_declarator
+    declarator: (identifier) @def.var.name)) @def.var
+`;
+var cModule = {
+  lang: "c" /* C */,
+  fileExtensions: [".c", ".h"],
+  queries: cQueries,
+  importStyle: "include",
+  inheritanceStrategy: "none",
+  resolveImport(rawPath, fromFile, workspace) {
+    const cleaned = rawPath.replace(/[<>"']/g, "");
+    const fromDir = path6.dirname(fromFile);
+    return workspace.resolve(fromDir, cleaned);
+  },
+  isExported(_node) {
+    return true;
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/parsing/queries/cpp.ts
+var cppQueries = `
+;; Class specifier
+(class_specifier
+  name: (type_identifier) @def.class.name) @def.class
+
+;; Struct specifier
+(struct_specifier
+  name: (type_identifier) @def.struct.name) @def.struct
+
+;; Function definition
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @def.func.name)) @def.func
+
+;; Namespace definition
+(namespace_definition
+  name: (identifier) @def.namespace.name) @def.namespace
+
+;; Template declaration
+(template_declaration
+  (class_specifier
+    name: (type_identifier) @def.class.name)) @def.class.template
+
+;; Include
+(preproc_include
+  path: (_) @imp.source) @imp
+
+;; Call
+(call_expression
+  function: (identifier) @call.name) @call
+
+;; Member call
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @call.method)) @call.member
+
+;; Base class clause
+(base_class_clause
+  (type_identifier) @inherit.extends)
+
+;; Enum
+(enum_specifier
+  name: (type_identifier) @def.enum.name) @def.enum
+`;
+var cppModule = {
+  lang: "cpp" /* Cpp */,
+  fileExtensions: [".cpp", ".cxx", ".cc", ".hpp", ".hxx"],
+  queries: cppQueries,
+  importStyle: "include",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, fromFile, workspace) {
+    const cleaned = rawPath.replace(/[<>"']/g, "");
+    const fromDir = path6.dirname(fromFile);
+    return workspace.resolve(fromDir, cleaned);
+  },
+  isExported(_node) {
+    return true;
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/parsing/queries/csharp.ts
+var csharpQueries = `
+;; Class declaration
+(class_declaration
+  name: (identifier) @def.class.name) @def.class
+
+;; Interface declaration
+(interface_declaration
+  name: (identifier) @def.interface.name) @def.interface
+
+;; Struct declaration
+(struct_declaration
+  name: (identifier) @def.struct.name) @def.struct
+
+;; Enum declaration
+(enum_declaration
+  name: (identifier) @def.enum.name) @def.enum
+
+;; Method declaration
+(method_declaration
+  name: (identifier) @def.method.name) @def.method
+
+;; Constructor declaration
+(constructor_declaration
+  name: (identifier) @def.constructor.name) @def.constructor
+
+;; Property declaration
+(property_declaration
+  name: (identifier) @def.property.name) @def.property
+
+;; Namespace declaration
+(namespace_declaration
+  name: (_) @def.namespace.name) @def.namespace
+
+;; Using directive
+(using_directive
+  (qualified_name) @imp.source) @imp
+
+;; Invocation
+(invocation_expression
+  function: (identifier) @call.name) @call
+
+;; Member invocation
+(invocation_expression
+  function: (member_access_expression
+    name: (identifier) @call.method)) @call.member
+
+;; Object creation
+(object_creation_expression
+  type: (identifier) @call.constructor) @call.new
+
+;; Base list (extends/implements)
+(base_list
+  (identifier) @inherit.extends)
+`;
+
+// src/languages/modules/csharp.ts
+var csharpModule = {
+  lang: "csharp" /* CSharp */,
+  fileExtensions: [".cs"],
+  queries: csharpQueries,
+  importStyle: "explicit",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    return workspace.findByPackage(cleaned);
+  },
+  isExported(node) {
+    return node.text.includes("public") || node.text.includes("internal");
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/parsing/queries/rust.ts
+var rustQueries = `
+;; Function item
+(function_item
+  name: (identifier) @def.func.name) @def.func
+
+;; Struct item
+(struct_item
+  name: (type_identifier) @def.struct.name) @def.struct
+
+;; Enum item
+(enum_item
+  name: (type_identifier) @def.enum.name) @def.enum
+
+;; Trait item
+(trait_item
+  name: (type_identifier) @def.trait.name) @def.trait
+
+;; Impl item
+(impl_item
+  type: (type_identifier) @def.class.name) @def.impl
+
+;; Type alias
+(type_item
+  name: (type_identifier) @def.type_alias.name) @def.type_alias
+
+;; Use declaration
+(use_declaration
+  argument: (_) @imp.source) @imp
+
+;; Call
+(call_expression
+  function: (identifier) @call.name) @call
+
+;; Method call
+(call_expression
+  function: (field_expression
+    field: (field_identifier) @call.method)) @call.member
+
+;; Const item
+(const_item
+  name: (identifier) @def.constant.name) @def.constant
+
+;; Static item
+(static_item
+  name: (identifier) @def.var.name) @def.var
+`;
+
+// src/languages/modules/rust.ts
+var rustModule = {
+  lang: "rust" /* Rust */,
+  fileExtensions: [".rs"],
+  queries: rustQueries,
+  importStyle: "explicit",
+  inheritanceStrategy: "none",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    const parts = cleaned.split("::");
+    const filePath = parts.join("/") + ".rs";
+    return workspace.findByPackage(filePath);
+  },
+  isExported(node) {
+    return node.text.startsWith("pub ") || node.text.startsWith("pub(");
+  },
+  extractType(node) {
+    const returnType = node.childForFieldName("return_type");
+    return returnType?.text ?? null;
+  }
+};
+
+// src/parsing/queries/php.ts
+var phpQueries = `
+;; Class declaration
+(class_declaration
+  name: (name) @def.class.name) @def.class
+
+;; Interface declaration
+(interface_declaration
+  name: (name) @def.interface.name) @def.interface
+
+;; Trait declaration
+(trait_declaration
+  name: (name) @def.trait.name) @def.trait
+
+;; Function definition
+(function_definition
+  name: (name) @def.func.name) @def.func
+
+;; Method declaration
+(method_declaration
+  name: (name) @def.method.name) @def.method
+
+;; Property declaration
+(property_declaration
+  (property_element
+    (variable_name) @def.property.name)) @def.property
+
+;; Namespace definition
+(namespace_definition
+  name: (namespace_name) @def.namespace.name) @def.namespace
+
+;; Use declaration (import)
+(namespace_use_declaration
+  (namespace_use_clause
+    (qualified_name) @imp.source)) @imp
+
+;; Include/require
+(include_expression
+  (_) @imp.source) @imp.include
+
+;; Function call
+(function_call_expression
+  function: (name) @call.name) @call
+
+;; Method call
+(member_call_expression
+  name: (name) @call.method) @call.member
+
+;; Object creation
+(object_creation_expression
+  (name) @call.constructor) @call.new
+
+;; Class base clause
+(base_clause
+  (name) @inherit.extends)
+
+;; Class interface clause
+(class_interface_clause
+  (name) @inherit.implements)
+`;
+
+// src/languages/modules/php.ts
+var phpModule = {
+  lang: "php" /* PHP */,
+  fileExtensions: [".php"],
+  queries: phpQueries,
+  importStyle: "explicit",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"\\]/g, "/").replace(/^\//, "");
+    return workspace.findByPackage(cleaned + ".php");
+  },
+  isExported(node) {
+    return node.text.includes("public") || !node.text.includes("private");
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/parsing/queries/kotlin.ts
+var kotlinQueries = `
+;; Class declaration
+(class_declaration
+  (type_identifier) @def.class.name) @def.class
+
+;; Object declaration
+(object_declaration
+  (type_identifier) @def.class.name) @def.class.object
+
+;; Interface declaration  
+(class_declaration
+  (type_identifier) @def.interface.name) @def.interface
+
+;; Function declaration
+(function_declaration
+  (simple_identifier) @def.func.name) @def.func
+
+;; Property declaration
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @def.property.name)) @def.property
+
+;; Import
+(import_header
+  (identifier) @imp.source) @imp
+
+;; Call
+(call_expression
+  (simple_identifier) @call.name) @call
+
+;; Navigation call
+(call_expression
+  (navigation_expression
+    (simple_identifier) @call.method)) @call.member
+
+;; Delegation specifier (extends/implements)
+(delegation_specifier
+  (user_type
+    (type_identifier) @inherit.extends))
+`;
+
+// src/languages/modules/kotlin.ts
+var kotlinModule = {
+  lang: "kotlin" /* Kotlin */,
+  fileExtensions: [".kt", ".kts"],
+  queries: kotlinQueries,
+  importStyle: "explicit",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    const filePath = cleaned.replace(/\./g, "/") + ".kt";
+    return workspace.findByPackage(filePath);
+  },
+  isExported(node) {
+    return !node.text.includes("private") && !node.text.includes("internal");
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/parsing/queries/ruby.ts
+var rubyQueries = `
+;; Class
+(class
+  name: (constant) @def.class.name) @def.class
+
+;; Module
+(module
+  name: (constant) @def.module.name) @def.module
+
+;; Method
+(method
+  name: (identifier) @def.method.name) @def.method
+
+;; Singleton method
+(singleton_method
+  name: (identifier) @def.method.name) @def.method.static
+
+;; Assignment
+(assignment
+  left: (identifier) @def.var.name) @def.var
+
+;; Require
+(call
+  method: (identifier) @_method
+  arguments: (argument_list (string) @imp.source)
+  (#match? @_method "^require"))
+
+;; Call
+(call
+  method: (identifier) @call.name) @call
+
+;; Superclass
+(superclass
+  (constant) @inherit.extends)
+`;
+
+// src/languages/modules/ruby.ts
+var rubyModule = {
+  lang: "ruby" /* Ruby */,
+  fileExtensions: [".rb"],
+  queries: rubyQueries,
+  importStyle: "wildcard",
+  inheritanceStrategy: "mixin-aware",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    return workspace.findByPackage(cleaned + ".rb") ?? workspace.findByPackage(cleaned);
+  },
+  isExported(_node) {
+    return true;
+  },
+  extractType(_node) {
+    return null;
+  }
+};
+
+// src/parsing/queries/swift.ts
+var swiftQueries = `
+;; Class declaration
+(class_declaration
+  name: (type_identifier) @def.class.name) @def.class
+
+;; Struct declaration
+(struct_declaration
+  name: (type_identifier) @def.struct.name) @def.struct
+
+;; Protocol declaration
+(protocol_declaration
+  name: (type_identifier) @def.interface.name) @def.interface
+
+;; Enum declaration
+(enum_declaration
+  name: (type_identifier) @def.enum.name) @def.enum
+
+;; Function declaration
+(function_declaration
+  name: (simple_identifier) @def.func.name) @def.func
+
+;; Property declaration
+(property_declaration
+  (pattern
+    (simple_identifier) @def.property.name)) @def.property
+
+;; Import
+(import_declaration
+  (identifier) @imp.source) @imp
+
+;; Call
+(call_expression
+  (simple_identifier) @call.name) @call
+
+;; Inheritance
+(inheritance_specifier
+  (type_identifier) @inherit.extends)
+`;
+
+// src/languages/modules/swift.ts
+var swiftModule = {
+  lang: "swift" /* Swift */,
+  fileExtensions: [".swift"],
+  queries: swiftQueries,
+  importStyle: "wildcard",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, _fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    return workspace.findByPackage(cleaned);
+  },
+  isExported(node) {
+    return !node.text.includes("private") && !node.text.includes("fileprivate");
+  },
+  extractType(node) {
+    const typeAnnotation = node.childForFieldName("type");
+    return typeAnnotation?.text ?? null;
+  }
+};
+var dartModule = {
+  lang: "dart" /* Dart */,
+  fileExtensions: [".dart"],
+  queries: typescriptQueries,
+  // Dart grammar fallback
+  importStyle: "wildcard",
+  inheritanceStrategy: "depth-first",
+  resolveImport(rawPath, fromFile, workspace) {
+    const cleaned = rawPath.replace(/['"]/g, "");
+    if (cleaned.startsWith("package:")) {
+      const pkg = cleaned.replace("package:", "");
+      return workspace.findByPackage(pkg);
+    }
+    const fromDir = path6.dirname(fromFile);
+    return workspace.resolve(fromDir, cleaned);
+  },
+  isExported(node) {
+    const name = node.childForFieldName("name");
+    if (!name) return true;
+    return !name.text.startsWith("_");
+  },
+  extractType(node) {
+    const typeNode = node.childForFieldName("type");
+    return typeNode?.text ?? null;
+  }
+};
+
+// src/languages/registry.ts
+var MODULES = {
+  ["typescript" /* TypeScript */]: typescriptModule,
+  ["javascript" /* JavaScript */]: javascriptModule,
+  ["python" /* Python */]: pythonModule,
+  ["java" /* Java */]: javaModule,
+  ["go" /* Go */]: goModule,
+  ["c" /* C */]: cModule,
+  ["cpp" /* Cpp */]: cppModule,
+  ["csharp" /* CSharp */]: csharpModule,
+  ["rust" /* Rust */]: rustModule,
+  ["php" /* PHP */]: phpModule,
+  ["kotlin" /* Kotlin */]: kotlinModule,
+  ["ruby" /* Ruby */]: rubyModule,
+  ["swift" /* Swift */]: swiftModule,
+  ["dart" /* Dart */]: dartModule
+};
+function getLanguageModule(lang) {
+  return MODULES[lang];
+}
+function getAllLanguageModules() {
+  return Object.values(MODULES);
+}
+
+// src/resolver/binding-tracker.ts
+var BindingTracker = class {
+  bindings = /* @__PURE__ */ new Map();
+  addBinding(filePath, binding) {
+    let fileBindings = this.bindings.get(filePath);
+    if (!fileBindings) {
+      fileBindings = /* @__PURE__ */ new Map();
+      this.bindings.set(filePath, fileBindings);
+    }
+    fileBindings.set(binding.localName, binding);
+  }
+  getBinding(filePath, localName) {
+    return this.bindings.get(filePath)?.get(localName);
+  }
+  getFileBindings(filePath) {
+    const fileBindings = this.bindings.get(filePath);
+    return fileBindings ? [...fileBindings.values()] : [];
+  }
+  clear() {
+    this.bindings.clear();
+  }
+};
+
+// src/resolver/import-resolver.ts
+function resolveImports(filePath, fileNodeId, imports, langModule, workspace) {
+  const bindings = new BindingTracker();
+  const edges = [];
+  const maxReExportHops = 5;
+  for (const imp of imports) {
+    let resolvedPath = langModule.resolveImport(imp.rawPath, filePath, workspace);
+    let hops = 0;
+    const visited = /* @__PURE__ */ new Set();
+    while (resolvedPath && hops < maxReExportHops && !visited.has(resolvedPath)) {
+      visited.add(resolvedPath);
+      hops++;
+      break;
+    }
+    if (!resolvedPath) continue;
+    const targetNodeId = `file:${resolvedPath}:${resolvedPath}`;
+    const edge = {
+      id: generateEdgeId(fileNodeId, targetNodeId, "imports"),
+      source: fileNodeId,
+      target: targetNodeId,
+      kind: "imports",
+      weight: 0.95,
+      label: imp.rawPath
+    };
+    edges.push(edge);
+    for (const localName of imp.localNames) {
+      const binding = {
+        localName,
+        sourcePath: resolvedPath,
+        exportedName: localName,
+        isDefault: imp.isDefault,
+        isNamespace: imp.isNamespace
+      };
+      bindings.addBinding(filePath, binding);
+    }
+  }
+  return { edges, bindings };
+}
+
+// src/call-graph/call-builder.ts
+function buildCallEdges(callSites, graph, bindings) {
+  const edges = [];
+  const symbolIndex = buildSymbolIndex(graph);
+  const tiers = [
+    {
+      name: "same-file",
+      confidence: 0.95,
+      resolve(cs) {
+        const key = `${cs.callerFilePath}:${cs.name}`;
+        return symbolIndex.get(key) ?? null;
+      }
+    },
+    {
+      name: "imported",
+      confidence: 0.9,
+      resolve(cs) {
+        const binding = bindings.getBinding(cs.callerFilePath, cs.name);
+        if (!binding) return null;
+        const key = `${binding.sourcePath}:${binding.exportedName}`;
+        return symbolIndex.get(key) ?? null;
+      }
+    },
+    {
+      name: "global",
+      confidence: 0.5,
+      resolve(cs) {
+        return globalSymbolIndex.get(cs.name) ?? null;
+      }
+    }
+  ];
+  const globalSymbolIndex = /* @__PURE__ */ new Map();
+  for (const node of graph.allNodes()) {
+    if (["function", "method", "class", "constructor"].includes(node.kind)) {
+      if (!globalSymbolIndex.has(node.name)) {
+        globalSymbolIndex.set(node.name, node.id);
+      }
+    }
+  }
+  for (const cs of callSites) {
+    for (const tier of tiers) {
+      const targetId = tier.resolve(cs);
+      if (targetId && targetId !== cs.callerNodeId) {
+        edges.push({
+          id: generateEdgeId(cs.callerNodeId, targetId, "calls"),
+          source: cs.callerNodeId,
+          target: targetId,
+          kind: "calls",
+          weight: tier.confidence,
+          label: cs.name
+        });
+        break;
+      }
+    }
+  }
+  return edges;
+}
+function buildSymbolIndex(graph) {
+  const index = /* @__PURE__ */ new Map();
+  for (const node of graph.allNodes()) {
+    if (["function", "method", "class", "constructor", "variable"].includes(node.kind)) {
+      const key = `${node.filePath}:${node.name}`;
+      index.set(key, node.id);
+    }
+  }
+  return index;
+}
+
+// src/call-graph/call-classifier.ts
+function classifyCall(name, hasReceiver, isNew) {
+  if (isNew) return "constructor";
+  if (hasReceiver) return "member";
+  if (name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase()) {
+    return "constructor";
+  }
+  return "free";
+}
+
+// src/inheritance/heritage-builder.ts
+function buildHeritageEdges(heritages, graph) {
+  const edges = [];
+  const classIndex = /* @__PURE__ */ new Map();
+  for (const node of graph.allNodes()) {
+    if (["class", "interface", "struct", "trait"].includes(node.kind)) {
+      classIndex.set(node.name, node.id);
+    }
+  }
+  for (const h of heritages) {
+    for (const name of h.extendsNames) {
+      const targetId = classIndex.get(name);
+      if (targetId) {
+        edges.push({
+          id: generateEdgeId(h.classNodeId, targetId, "extends"),
+          source: h.classNodeId,
+          target: targetId,
+          kind: "extends",
+          weight: 1,
+          label: `extends ${name}`
+        });
+      }
+    }
+    for (const name of h.implementsNames) {
+      const targetId = classIndex.get(name);
+      if (targetId) {
+        edges.push({
+          id: generateEdgeId(h.classNodeId, targetId, "implements"),
+          source: h.classNodeId,
+          target: targetId,
+          kind: "implements",
+          weight: 1,
+          label: `implements ${name}`
+        });
+      }
+    }
+  }
+  return edges;
+}
+
+// src/inheritance/mro-walker.ts
+function computeMRO(classId, parentMap, strategy) {
+  switch (strategy) {
+    case "depth-first":
+      return depthFirstMRO(classId, parentMap);
+    case "c3":
+      return c3Linearize(classId, parentMap);
+    case "mixin-aware":
+      return mixinAwareMRO(classId, parentMap);
+    case "none":
+      return [classId];
+  }
+}
+function depthFirstMRO(classId, parentMap) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [classId];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current)) continue;
+    visited.add(current);
+    result.push(current);
+    const parents = parentMap.get(current) ?? [];
+    for (let i = parents.length - 1; i >= 0; i--) {
+      stack.push(parents[i]);
+    }
+  }
+  return result;
+}
+function c3Linearize(classId, parentMap) {
+  const cache = /* @__PURE__ */ new Map();
+  const inProgress = /* @__PURE__ */ new Set();
+  function linearize(cls) {
+    if (cache.has(cls)) return cache.get(cls);
+    if (inProgress.has(cls)) return [cls];
+    inProgress.add(cls);
+    const parents = parentMap.get(cls) ?? [];
+    if (parents.length === 0) {
+      const result2 = [cls];
+      cache.set(cls, result2);
+      inProgress.delete(cls);
+      return result2;
+    }
+    const parentLinearizations = parents.map((p) => linearize(p));
+    const sequences = [...parentLinearizations, parents];
+    const result = [cls];
+    while (sequences.some((s) => s.length > 0)) {
+      let found = false;
+      for (const seq of sequences) {
+        if (seq.length === 0) continue;
+        const head = seq[0];
+        const inTail = sequences.some((s) => s.indexOf(head) > 0);
+        if (!inTail) {
+          result.push(head);
+          for (const s of sequences) {
+            const idx = s.indexOf(head);
+            if (idx >= 0) s.splice(idx, 1);
+          }
+          found = true;
+          break;
+        }
+      }
+      if (!found) break;
+    }
+    cache.set(cls, result);
+    inProgress.delete(cls);
+    return result;
+  }
+  return linearize(classId);
+}
+function mixinAwareMRO(classId, parentMap) {
+  return depthFirstMRO(classId, parentMap);
+}
+
+// src/inheritance/override-detector.ts
+function detectOverrides(graph) {
+  const edges = [];
+  const methodsByOwner = /* @__PURE__ */ new Map();
+  for (const edge of graph.findEdgesByKind("has_member")) {
+    const member = graph.getNode(edge.target);
+    if (member && member.kind === "method") {
+      let methods = methodsByOwner.get(edge.source);
+      if (!methods) {
+        methods = /* @__PURE__ */ new Map();
+        methodsByOwner.set(edge.source, methods);
+      }
+      methods.set(member.name, member.id);
+    }
+  }
+  for (const extendsEdge of graph.findEdgesByKind("extends")) {
+    const childMethods = methodsByOwner.get(extendsEdge.source);
+    const parentMethods = methodsByOwner.get(extendsEdge.target);
+    if (!childMethods || !parentMethods) continue;
+    for (const [methodName, childMethodId] of childMethods) {
+      const parentMethodId = parentMethods.get(methodName);
+      if (parentMethodId) {
+        edges.push({
+          id: generateEdgeId(childMethodId, parentMethodId, "overrides"),
+          source: childMethodId,
+          target: parentMethodId,
+          kind: "overrides",
+          weight: 1,
+          label: `overrides ${methodName}`
+        });
+      }
+    }
+  }
+  return edges;
+}
+
+// src/pipeline/dag-validator.ts
+function validateDAG(phases) {
+  const errors = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const phase of phases) {
+    if (names.has(phase.name)) {
+      errors.push({ type: "duplicate", message: `Duplicate phase name: ${phase.name}` });
+    }
+    names.add(phase.name);
+  }
+  for (const phase of phases) {
+    for (const dep of phase.dependencies) {
+      if (!names.has(dep)) {
+        errors.push({
+          type: "missing-dep",
+          message: `Phase "${phase.name}" depends on missing phase "${dep}"`
+        });
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const phaseMap = new Map(phases.map((p) => [p.name, p]));
+  function dfs(name, path19) {
+    if (visiting.has(name)) {
+      const cycleStart = path19.indexOf(name);
+      const cycle = path19.slice(cycleStart).concat(name);
+      errors.push({ type: "cycle", message: `Cycle detected: ${cycle.join(" \u2192 ")}` });
+      return true;
+    }
+    if (visited.has(name)) return false;
+    visiting.add(name);
+    path19.push(name);
+    const phase = phaseMap.get(name);
+    if (phase) {
+      for (const dep of phase.dependencies) {
+        if (dfs(dep, path19)) return true;
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    path19.pop();
+    return false;
+  }
+  for (const phase of phases) {
+    if (!visited.has(phase.name)) {
+      dfs(phase.name, []);
+    }
+  }
+  return errors;
+}
+function topologicalSort(phases) {
+  const phaseMap = new Map(phases.map((p) => [p.name, p]));
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjList = /* @__PURE__ */ new Map();
+  for (const phase of phases) {
+    inDegree.set(phase.name, 0);
+    adjList.set(phase.name, []);
+  }
+  for (const phase of phases) {
+    for (const dep of phase.dependencies) {
+      adjList.get(dep)?.push(phase.name);
+      inDegree.set(phase.name, (inDegree.get(phase.name) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) queue.push(name);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(phaseMap.get(current));
+    for (const neighbor of adjList.get(current) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  return sorted;
+}
+
+// src/pipeline/orchestrator.ts
+async function runPipeline(phases, context) {
+  const errors = validateDAG(phases);
+  if (errors.length > 0) {
+    throw new Error(`Pipeline validation failed:
+${errors.map((e) => e.message).join("\n")}`);
+  }
+  const sorted = topologicalSort(phases);
+  const results = /* @__PURE__ */ new Map();
+  const startTime = Date.now();
+  let success = true;
+  for (const phase of sorted) {
+    context.onProgress?.(phase.name, "running");
+    const phaseStart = Date.now();
+    try {
+      const depResults = /* @__PURE__ */ new Map();
+      for (const dep of phase.dependencies) {
+        const depResult = results.get(dep);
+        if (depResult) depResults.set(dep, depResult);
+      }
+      const result = await phase.execute(context, depResults);
+      results.set(phase.name, result);
+      context.onProgress?.(phase.name, result.status);
+      if (result.status === "failed") {
+        success = false;
+        break;
+      }
+    } catch (err) {
+      const result = {
+        status: "failed",
+        duration: Date.now() - phaseStart,
+        message: err instanceof Error ? err.message : String(err)
+      };
+      results.set(phase.name, result);
+      context.onProgress?.(phase.name, "failed");
+      success = false;
+      break;
+    }
+  }
+  return {
+    success,
+    results,
+    totalDuration: Date.now() - startTime
+  };
+}
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "dist-tests",
+  "build",
+  "out",
+  "__pycache__",
+  ".tox",
+  ".pytest_cache",
+  ".mypy_cache",
+  "vendor",
+  "target",
+  ".code-intel",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  "tmp",
+  "temp",
+  ".parcel-cache",
+  ".venv",
+  "venv",
+  ".env",
+  "env",
+  "__snapshots__",
+  ".nyc_output",
+  "storybook-static"
+]);
+function loadIgnorePatterns(workspaceRoot) {
+  try {
+    const raw = fs6.readFileSync(path6.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    const extras = /* @__PURE__ */ new Set();
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) extras.add(trimmed);
+    }
+    return extras;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+var IGNORED_FILE_SUFFIXES = [".d.ts", ".js.map", ".d.ts.map", ".min.js", ".min.css"];
+var MAX_FILE_SIZE_BYTES = 512 * 1024;
+var scanPhase = {
+  name: "scan",
+  dependencies: [],
+  async execute(context) {
+    const start = Date.now();
+    const extensions = new Set(getSupportedExtensions());
+    const filePaths = [];
+    const extraIgnore = loadIgnorePatterns(context.workspaceRoot);
+    function walk(dir) {
+      let entries;
+      try {
+        entries = fs6.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (entry.name.startsWith(".")) continue;
+          if (IGNORED_DIRS.has(entry.name)) continue;
+          if (extraIgnore.has(entry.name)) continue;
+          walk(path6.join(dir, entry.name));
+        } else if (entry.isFile()) {
+          const name = entry.name;
+          if (IGNORED_FILE_SUFFIXES.some((s) => name.endsWith(s))) continue;
+          const ext = path6.extname(name);
+          if (!extensions.has(ext)) continue;
+          const fullPath = path6.join(dir, name);
+          try {
+            const stat = fs6.statSync(fullPath);
+            if (stat.size > MAX_FILE_SIZE_BYTES) continue;
+          } catch {
+            continue;
+          }
+          filePaths.push(fullPath);
+        }
+      }
+    }
+    walk(context.workspaceRoot);
+    context.filePaths.push(...filePaths);
+    context.onPhaseProgress?.("scan", filePaths.length, filePaths.length);
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Found ${filePaths.length} source files`
+    };
+  }
+};
+var structurePhase = {
+  name: "structure",
+  dependencies: ["scan"],
+  async execute(context) {
+    const start = Date.now();
+    const dirs = /* @__PURE__ */ new Set();
+    let structDone = 0;
+    for (const filePath of context.filePaths) {
+      const relativePath = path6.relative(context.workspaceRoot, filePath);
+      const lang = detectLanguage(filePath);
+      context.graph.addNode({
+        id: generateNodeId("file", relativePath, relativePath),
+        kind: "file",
+        name: path6.basename(filePath),
+        filePath: relativePath,
+        metadata: lang ? { language: lang } : void 0
+      });
+      let dir = path6.dirname(relativePath);
+      while (dir && dir !== "." && dir !== "") {
+        if (dirs.has(dir)) break;
+        dirs.add(dir);
+        dir = path6.dirname(dir);
+      }
+      structDone++;
+      context.onPhaseProgress?.("structure", structDone, context.filePaths.length);
+    }
+    for (const dir of dirs) {
+      context.graph.addNode({
+        id: generateNodeId("directory", dir, dir),
+        kind: "directory",
+        name: path6.basename(dir),
+        filePath: dir
+      });
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Created ${context.filePaths.length} file nodes, ${dirs.size} directory nodes`
+    };
+  }
+};
+var SENSITIVE_KEYS = [
+  "password",
+  "passwd",
+  "pass",
+  "pwd",
+  "secret",
+  "secretkey",
+  "secret_key",
+  "secretaccesskey",
+  "accesskeyid",
+  "credentials",
+  "auth",
+  "authentication",
+  "login",
+  "api_key",
+  "apikey",
+  "api",
+  "access_key",
+  "access_token",
+  "accesskey",
+  "auth_key",
+  "auth_token",
+  "authkey",
+  "token",
+  "jwt",
+  "bearer_token",
+  "refresh_token",
+  "session_token",
+  "session_key",
+  "oauth_token",
+  "connection_string",
+  "conn_string",
+  "db_uri",
+  "db_url",
+  "database_url",
+  "mongodb_uri",
+  "mysql_uri",
+  "postgres_uri",
+  "sql_uri",
+  "db_username",
+  "db_password",
+  "db_host",
+  "db_port",
+  "db_name",
+  "encryption_key",
+  "crypto_key",
+  "private_key",
+  "public_key",
+  "ssl_key",
+  "ssh_key",
+  "pgp_key",
+  "rsa_key",
+  "aes_key",
+  "email",
+  "phone",
+  "telephone",
+  "mobile",
+  "ssn",
+  "social_security",
+  "credit_card",
+  "cc_number",
+  "card_number",
+  "cvv",
+  "expiry_date",
+  "birth_date",
+  "dob",
+  "address",
+  "zip_code",
+  "postal_code",
+  "bank_account",
+  "iban",
+  "swift_code",
+  "routing_number",
+  "tax_id",
+  "vat_number",
+  "financial_id",
+  "certificate",
+  "client_cert",
+  "server_cert",
+  "ca_cert",
+  "aws_key",
+  "aws_secret",
+  "azure_key",
+  "gcp_key",
+  "s3_key",
+  "cloudinary_key",
+  "stripe_key",
+  "paypal_key",
+  "twilio_key",
+  "app_secret",
+  "client_secret",
+  "consumer_secret",
+  "encryption_secret",
+  "master_key",
+  "root_password",
+  "admin_password",
+  "config_secret",
+  "env_secret",
+  "deploy_key",
+  "ci_key",
+  "session_id",
+  "cookie_secret",
+  "csrf_token",
+  "xsrf_token",
+  "license_key",
+  "product_key",
+  "serial_number",
+  "activation_code"
+];
+var SENSITIVE_PATTERNS = [
+  /(?:password|passwd|secret|api_key|access_token|auth_token|token)\s*[:=]\s*([^\s,]+)/gi,
+  /\b\d{16}\b/gi,
+  /\b\d{3}-\d{2}-\d{4}\b/gi,
+  /\b[A-Za-z0-9]{32}\b/gi,
+  /\b[A-Za-z0-9_-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}\b/gi,
+  /\b\d{10}\b/gi,
+  /\b[A-Za-z0-9]{64}\b/gi,
+  /(?:connection_string|db_uri|db_url|mongodb_uri)\s*[:=]\s*([^\s,]+)/gi,
+  /(?:apikey|api_key|auth_key)\s*[:=]\s*([^\s,]+)/gi,
+  /(?:bearer\s+)[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+/gi
+];
+var SENSITIVE_KEYS_REGEX = new RegExp(`^(${SENSITIVE_KEYS.join("|")})$`, "i");
+var Logger = class _Logger {
+  static instance = null;
+  static maskSensitiveData(value) {
+    if (typeof value === "string" && value.length > 5) {
+      const firstChar = value.at(0);
+      const lastChar = value.at(-1);
+      return firstChar + "*".repeat(value.length - 2) + lastChar;
+    }
+    return value;
+  }
+  static maskSensitive(message, args = []) {
+    const maskString = (input) => {
+      if (typeof input !== "string") return input;
+      return SENSITIVE_PATTERNS.reduce((str, pattern) => {
+        return str.replace(
+          pattern,
+          (match, value) => value ? match.replace(value, _Logger.maskSensitiveData(value)) : match
+        );
+      }, input);
+    };
+    const deepMask = (obj) => {
+      if (typeof obj === "string") return maskString(obj);
+      if (Array.isArray(obj)) return obj.map((item) => deepMask(item));
+      if (typeof obj === "object" && obj !== null) {
+        return Object.entries(obj).reduce(
+          (acc, [key, value]) => {
+            if (value === void 0) return acc;
+            const isSensitiveKey = SENSITIVE_KEYS_REGEX.test(key);
+            acc[key] = isSensitiveKey && typeof value === "string" ? _Logger.maskSensitiveData(value) : deepMask(value);
+            return acc;
+          },
+          {}
+        );
+      }
+      return obj;
+    };
+    return {
+      maskedMessage: maskString(message),
+      maskedArgs: args.map((arg) => deepMask(arg))
+    };
+  }
+  /** Global log directory: ~/.code-intel/logs */
+  static LOG_DIR = path6.join(os3.homedir(), ".code-intel", "logs");
+  static getLogger() {
+    if (!_Logger.instance) {
+      const isProduction = process.env.NODE_ENV === "production";
+      const logLevel = process.env.LOG_LEVEL ?? "info";
+      const transports = [];
+      transports.push(new winston.transports.Console());
+      if (!isProduction) {
+        try {
+          if (!fs6.existsSync(_Logger.LOG_DIR)) {
+            fs6.mkdirSync(_Logger.LOG_DIR, { recursive: true });
+          }
+          transports.push(
+            new DailyRotateFile({
+              filename: path6.join(_Logger.LOG_DIR, "%DATE%-code-intel.log"),
+              datePattern: "YYYY-MM-DD",
+              maxSize: "20m",
+              maxFiles: "14d"
+            })
+          );
+        } catch {
+        }
+      }
+      _Logger.instance = winston.createLogger({
+        level: logLevel,
+        format: winston.format.combine(
+          winston.format.timestamp(),
+          winston.format.printf(({ timestamp, level, message, ...meta }) => {
+            const args = meta[/* @__PURE__ */ Symbol.for("splat")] || [];
+            const { maskedMessage, maskedArgs } = _Logger.maskSensitive(message, args);
+            const formattedArgs = maskedArgs.map(
+              (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+            );
+            const suffix = formattedArgs.length ? " " + formattedArgs.join(" ") : "";
+            return `${timestamp} [${level.toUpperCase()}]: ${maskedMessage}${suffix}`;
+          })
+        ),
+        transports
+      });
+    }
+    return _Logger.instance;
+  }
+  static info(message, ...args) {
+    _Logger.getLogger().info(message, ...args);
+  }
+  static warn(message, ...args) {
+    _Logger.getLogger().warn(message, ...args);
+  }
+  static error(message, ...args) {
+    _Logger.getLogger().error(message, ...args);
+  }
+  static debug(message, ...args) {
+    _Logger.getLogger().debug(message, ...args);
+  }
+};
+var logger_default = Logger;
+Logger.getLogger();
+
+// src/pipeline/phases/parse-phase.ts
+var parsePhase = {
+  name: "parse",
+  dependencies: ["structure"],
+  async execute(context) {
+    const start = Date.now();
+    let symbolCount = 0;
+    if (!context.fileCache) context.fileCache = /* @__PURE__ */ new Map();
+    if (!context.fileFunctionIndex) context.fileFunctionIndex = /* @__PURE__ */ new Map();
+    const CONCURRENCY = 64;
+    const filePaths = context.filePaths;
+    let readDone = 0;
+    for (let i = 0; i < filePaths.length; i += CONCURRENCY) {
+      const batch = filePaths.slice(i, i + CONCURRENCY);
+      await Promise.all(batch.map(async (filePath) => {
+        try {
+          const source = await fs6.promises.readFile(filePath, "utf-8");
+          context.fileCache.set(filePath, source);
+        } catch {
+        }
+      }));
+      readDone += batch.length;
+      context.onPhaseProgress?.("parse:read", readDone, filePaths.length);
+    }
+    let parseDone = 0;
+    for (const filePath of filePaths) {
+      const lang = detectLanguage(filePath);
+      if (!lang) {
+        if (context.verbose) {
+          const relativePath2 = path6.relative(context.workspaceRoot, filePath);
+          logger_default.info(`  [parse] skipped (no parser): ${relativePath2}`);
+        }
+        continue;
+      }
+      const source = context.fileCache.get(filePath);
+      if (!source) continue;
+      const relativePath = path6.relative(context.workspaceRoot, filePath);
+      const fileNodeId = generateNodeId("file", relativePath, relativePath);
+      const fileNode = context.graph.getNode(fileNodeId);
+      if (fileNode) {
+        fileNode.content = source.slice(0, 2e3);
+      }
+      const nodes = [];
+      const edges = [];
+      const seen = /* @__PURE__ */ new Set();
+      const lines = source.split("\n");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
+        const extracted = extractSymbol(trimmed, lang);
+        if (!extracted) continue;
+        const dedupeKey = extracted.name + ":" + extracted.kind;
+        if (seen.has(dedupeKey)) continue;
+        seen.add(dedupeKey);
+        const nodeId = generateNodeId(extracted.kind, relativePath, extracted.name);
+        const endLine = estimateEndLine(lines, i, lang);
+        nodes.push({
+          id: nodeId,
+          kind: extracted.kind,
+          name: extracted.name,
+          filePath: relativePath,
+          startLine: i + 1,
+          endLine,
+          exported: extracted.exported,
+          content: extractBlock(lines, i, 20)
+        });
+        edges.push({
+          id: generateEdgeId(fileNodeId, nodeId, "contains"),
+          source: fileNodeId,
+          target: nodeId,
+          kind: "contains",
+          weight: 1
+        });
+        if (extracted.ownerName) {
+          const ownerId = generateNodeId("class", relativePath, extracted.ownerName);
+          if (context.graph.getNode(ownerId) || nodes.some((n) => n.id === ownerId)) {
+            edges.push({
+              id: generateEdgeId(ownerId, nodeId, "has_member"),
+              source: ownerId,
+              target: nodeId,
+              kind: "has_member",
+              weight: 1
+            });
+          }
+        }
+        symbolCount++;
+      }
+      for (const n of nodes) context.graph.addNode(n);
+      for (const e of edges) context.graph.addEdge(e);
+      const funcs = nodes.filter((n) => n.kind === "function" || n.kind === "method").map((n) => ({ id: n.id, startLine: n.startLine ?? 0, endLine: n.endLine })).sort((a, b) => a.startLine - b.startLine);
+      if (funcs.length > 0) {
+        context.fileFunctionIndex.set(relativePath, funcs);
+      }
+      parseDone++;
+      context.onPhaseProgress?.("parse", parseDone, filePaths.length);
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Extracted ${symbolCount} symbols from ${filePaths.length} files`
+    };
+  }
+};
+function extractSymbol(line, lang, _lineNum, _filePath) {
+  if (lang === "typescript" /* TypeScript */ || lang === "javascript" /* JavaScript */) {
+    const func = line.match(/^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: line.includes("export") };
+    const arrowFunc = line.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/);
+    if (arrowFunc) return { kind: "function", name: arrowFunc[1], exported: line.includes("export") };
+    const arrowFunc2 = line.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/);
+    if (arrowFunc2) return { kind: "function", name: arrowFunc2[1], exported: line.includes("export") };
+    const cls = line.match(/^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: line.includes("export") };
+    const iface = line.match(/^(?:export\s+)?interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: line.includes("export") };
+    const enumM = line.match(/^(?:export\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: line.includes("export") };
+    const typeAlias = line.match(/^(?:export\s+)?type\s+(\w+)\s*[=<]/);
+    if (typeAlias) return { kind: "type_alias", name: typeAlias[1], exported: line.includes("export") };
+    const constVar = line.match(/^(?:export\s+)?const\s+(\w+)\s*(?::\s*\w[^=]*)?\s*=/);
+    if (constVar && /^[A-Z_]+$/.test(constVar[1])) {
+      return { kind: "constant", name: constVar[1], exported: line.includes("export") };
+    }
+  }
+  if (lang === "python" /* Python */) {
+    const func = line.match(/^(?:async\s+)?def\s+(\w+)/);
+    if (func) return { kind: func[1].startsWith("__") ? "method" : "function", name: func[1], exported: !func[1].startsWith("_") };
+    const cls = line.match(/^class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !cls[1].startsWith("_") };
+  }
+  if (lang === "java" /* Java */) {
+    const cls = line.match(/(?:public|private|protected)?\s*(?:static\s+)?(?:abstract\s+)?(?:final\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: line.includes("public") };
+    const iface = line.match(/(?:public\s+)?interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: line.includes("public") };
+    const enumM = line.match(/(?:public\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: line.includes("public") };
+    const method = line.match(/(?:public|private|protected)\s+(?:static\s+)?(?:[\w<>\[\]]+)\s+(\w+)\s*\(/);
+    if (method) return { kind: "method", name: method[1], exported: line.includes("public") };
+  }
+  if (lang === "go" /* Go */) {
+    const func = line.match(/^func\s+(\w+)\s*\(/);
+    if (func) return { kind: "function", name: func[1], exported: func[1][0] === func[1][0].toUpperCase() };
+    const method = line.match(/^func\s+\([^)]+\)\s+(\w+)\s*\(/);
+    if (method) return { kind: "method", name: method[1], exported: method[1][0] === method[1][0].toUpperCase() };
+    const structM = line.match(/^type\s+(\w+)\s+struct\b/);
+    if (structM) return { kind: "struct", name: structM[1], exported: structM[1][0] === structM[1][0].toUpperCase() };
+    const ifaceM = line.match(/^type\s+(\w+)\s+interface\b/);
+    if (ifaceM) return { kind: "interface", name: ifaceM[1], exported: ifaceM[1][0] === ifaceM[1][0].toUpperCase() };
+  }
+  if (lang === "rust" /* Rust */) {
+    const func = line.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: line.startsWith("pub") };
+    const structM = line.match(/^(?:pub\s+)?struct\s+(\w+)/);
+    if (structM) return { kind: "struct", name: structM[1], exported: line.startsWith("pub") };
+    const enumM = line.match(/^(?:pub\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: line.startsWith("pub") };
+    const traitM = line.match(/^(?:pub\s+)?trait\s+(\w+)/);
+    if (traitM) return { kind: "trait", name: traitM[1], exported: line.startsWith("pub") };
+    const implM = line.match(/^impl(?:<[^>]*>)?\s+(\w+)/);
+    if (implM) return { kind: "class", name: implM[1], exported: false };
+  }
+  if (lang === "c" /* C */ || lang === "cpp" /* Cpp */) {
+    const cls = line.match(/^(?:class|struct)\s+(\w+)/);
+    if (cls) return { kind: lang === "cpp" /* Cpp */ ? "class" : "struct", name: cls[1], exported: true };
+    const nsM = line.match(/^namespace\s+(\w+)/);
+    if (nsM) return { kind: "namespace", name: nsM[1], exported: true };
+    const func = line.match(/^(?:[\w:*&<>\[\]]+\s+)+(\w+)\s*\([^;]*$/);
+    if (func && !["if", "for", "while", "switch", "return"].includes(func[1])) {
+      return { kind: "function", name: func[1], exported: true };
+    }
+  }
+  if (lang === "csharp" /* CSharp */) {
+    const cls = line.match(/(?:public|internal|private)?\s*(?:static\s+)?(?:abstract\s+)?(?:partial\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: line.includes("public") };
+    const iface = line.match(/(?:public\s+)?interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: line.includes("public") };
+    const structM = line.match(/(?:public\s+)?struct\s+(\w+)/);
+    if (structM) return { kind: "struct", name: structM[1], exported: line.includes("public") };
+    const method = line.match(/(?:public|private|protected|internal)\s+(?:static\s+)?(?:async\s+)?(?:[\w<>\[\]?]+)\s+(\w+)\s*\(/);
+    if (method) return { kind: "method", name: method[1], exported: line.includes("public") };
+    const nsM = line.match(/namespace\s+([\w.]+)/);
+    if (nsM) return { kind: "namespace", name: nsM[1], exported: true };
+  }
+  if (lang === "php" /* PHP */) {
+    const cls = line.match(/(?:abstract\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: true };
+    const func = line.match(/(?:public|private|protected|static\s+)*function\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: line.includes("public") || !line.includes("private") };
+    const iface = line.match(/interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: true };
+    const traitM = line.match(/trait\s+(\w+)/);
+    if (traitM) return { kind: "trait", name: traitM[1], exported: true };
+  }
+  if (lang === "kotlin" /* Kotlin */) {
+    const cls = line.match(/(?:data\s+|sealed\s+|abstract\s+|open\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !line.includes("private") };
+    const iface = line.match(/interface\s+(\w+)/);
+    if (iface) return { kind: "interface", name: iface[1], exported: !line.includes("private") };
+    const func = line.match(/(?:suspend\s+)?fun\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: !line.includes("private") };
+    const obj = line.match(/object\s+(\w+)/);
+    if (obj) return { kind: "class", name: obj[1], exported: !line.includes("private") };
+  }
+  if (lang === "ruby" /* Ruby */) {
+    const cls = line.match(/^class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: true };
+    const modM = line.match(/^module\s+(\w+)/);
+    if (modM) return { kind: "module", name: modM[1], exported: true };
+    const method = line.match(/^(?:def\s+(?:self\.)?(\w+))/);
+    if (method) return { kind: "method", name: method[1], exported: true };
+  }
+  if (lang === "swift" /* Swift */) {
+    const cls = line.match(/(?:public\s+|open\s+)?(?:final\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !line.includes("private") };
+    const structM = line.match(/(?:public\s+)?struct\s+(\w+)/);
+    if (structM) return { kind: "struct", name: structM[1], exported: !line.includes("private") };
+    const proto = line.match(/(?:public\s+)?protocol\s+(\w+)/);
+    if (proto) return { kind: "interface", name: proto[1], exported: !line.includes("private") };
+    const enumM = line.match(/(?:public\s+)?enum\s+(\w+)/);
+    if (enumM) return { kind: "enum", name: enumM[1], exported: !line.includes("private") };
+    const func = line.match(/(?:public\s+|private\s+|internal\s+)?(?:static\s+)?func\s+(\w+)/);
+    if (func) return { kind: "function", name: func[1], exported: !line.includes("private") };
+  }
+  if (lang === "dart" /* Dart */) {
+    const cls = line.match(/(?:abstract\s+)?class\s+(\w+)/);
+    if (cls) return { kind: "class", name: cls[1], exported: !cls[1].startsWith("_") };
+    const func = line.match(/^(?:\w+\s+)?(\w+)\s*\(/);
+    if (func && !["if", "for", "while", "switch", "catch", "return"].includes(func[1])) {
+      return { kind: "function", name: func[1], exported: !func[1].startsWith("_") };
+    }
+  }
+  return null;
+}
+function estimateEndLine(lines, startIdx, lang) {
+  const MAX_SCAN = 200;
+  const end = Math.min(startIdx + MAX_SCAN, lines.length);
+  if (lang !== "python" /* Python */ && lang !== "ruby" /* Ruby */) {
+    let depth = 0;
+    let foundOpen = false;
+    for (let i = startIdx; i < end; i++) {
+      for (const ch of lines[i]) {
+        if (ch === "{") {
+          depth++;
+          foundOpen = true;
+        } else if (ch === "}") {
+          depth--;
+          if (foundOpen && depth === 0) return i + 1;
+        }
+      }
+    }
+    return void 0;
+  }
+  const startIndent = (lines[startIdx].match(/^(\s*)/) ?? ["", ""])[1].length;
+  for (let i = startIdx + 1; i < end; i++) {
+    const l = lines[i];
+    if (l.trim() === "") continue;
+    const indent = (l.match(/^(\s*)/) ?? ["", ""])[1].length;
+    if (indent <= startIndent && l.trim() !== "") return i;
+  }
+  return void 0;
+}
+function extractBlock(lines, startIdx, maxLines) {
+  const end = Math.min(startIdx + maxLines, lines.length);
+  return lines.slice(startIdx, end).join("\n");
+}
+var CALL_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "catch",
+  "return",
+  "throw",
+  "typeof",
+  "instanceof",
+  "delete",
+  "void",
+  "new",
+  "import",
+  "export",
+  "from",
+  "const",
+  "let",
+  "var",
+  "function",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "extends",
+  "implements"
+]);
+var resolvePhase = {
+  name: "resolve",
+  dependencies: ["parse"],
+  async execute(context) {
+    const start = Date.now();
+    const { graph, workspaceRoot, filePaths } = context;
+    const fileCache = context.fileCache ?? /* @__PURE__ */ new Map();
+    const fileFunctionIndex = context.fileFunctionIndex ?? /* @__PURE__ */ new Map();
+    let importEdges = 0;
+    let callEdges = 0;
+    let heritageEdges = 0;
+    const fileIndex = /* @__PURE__ */ new Map();
+    for (const fp of filePaths) {
+      const rel = path6.relative(workspaceRoot, fp);
+      fileIndex.set(rel, fp);
+      const noExt = rel.replace(/\.\w+$/, "");
+      if (!fileIndex.has(noExt)) fileIndex.set(noExt, fp);
+      const base = path6.basename(rel, path6.extname(rel));
+      if (!fileIndex.has(base)) fileIndex.set(base, fp);
+    }
+    const symbolIndex = /* @__PURE__ */ new Map();
+    const fileSymbolIndex = /* @__PURE__ */ new Map();
+    for (const node of graph.allNodes()) {
+      if ([
+        "function",
+        "class",
+        "interface",
+        "method",
+        "enum",
+        "type_alias",
+        "variable",
+        "constant",
+        "struct",
+        "trait"
+      ].includes(node.kind)) {
+        symbolIndex.set(node.name, node.id);
+        let fileMap = fileSymbolIndex.get(node.filePath);
+        if (!fileMap) {
+          fileMap = /* @__PURE__ */ new Map();
+          fileSymbolIndex.set(node.filePath, fileMap);
+        }
+        fileMap.set(node.name, node.id);
+      }
+    }
+    let fileDone = 0;
+    for (const filePath of filePaths) {
+      const lang = detectLanguage(filePath);
+      if (!lang) continue;
+      const relativePath = path6.relative(workspaceRoot, filePath);
+      const fileNodeId = generateNodeId("file", relativePath, relativePath);
+      const source = fileCache.get(filePath);
+      if (!source) continue;
+      const lines = source.split("\n");
+      const imports = extractImports(lines, lang === "python");
+      const calls = extractCalls(lines);
+      const heritages = extractHeritage(lines);
+      for (const imp of imports) {
+        const cleaned = imp.rawPath.replace(/['"]/g, "");
+        let resolvedRelPath = null;
+        if (cleaned.startsWith(".")) {
+          const cleanedNoJs = cleaned.replace(/\.(js|jsx)$/, "");
+          const fromDir = path6.dirname(relativePath);
+          for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".go", "/index.ts", "/index.js"]) {
+            const candidate = path6.join(fromDir, cleanedNoJs + ext);
+            const normalized = path6.normalize(candidate);
+            if (fileIndex.has(normalized)) {
+              const absPath = fileIndex.get(normalized);
+              resolvedRelPath = path6.relative(workspaceRoot, absPath);
+              break;
+            }
+          }
+        } else {
+          for (const ext of ["", ".ts", ".js", ".py", ".java", ".go"]) {
+            if (fileIndex.has(cleaned + ext)) {
+              resolvedRelPath = cleaned + ext;
+              break;
+            }
+          }
+          if (!resolvedRelPath) {
+            const asPath = cleaned.replace(/\./g, "/");
+            for (const ext of ["", ".ts", ".js", ".py", ".java", ".go", "/index.ts", "/__init__.py"]) {
+              if (fileIndex.has(asPath + ext)) {
+                resolvedRelPath = asPath + ext;
+                break;
+              }
+            }
+          }
+        }
+        if (resolvedRelPath) {
+          const targetFileId = generateNodeId("file", resolvedRelPath, resolvedRelPath);
+          if (graph.getNode(targetFileId)) {
+            const edgeId = generateEdgeId(fileNodeId, targetFileId, "imports");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: fileNodeId,
+                target: targetFileId,
+                kind: "imports",
+                weight: 0.95,
+                label: cleaned
+              });
+              importEdges++;
+            }
+          }
+        }
+      }
+      const localSymbols = fileSymbolIndex.get(relativePath);
+      const funcList = fileFunctionIndex.get(relativePath);
+      for (const call of calls) {
+        let targetId = localSymbols?.get(call.name);
+        let confidence = 0.95;
+        if (!targetId) {
+          targetId = symbolIndex.get(call.name);
+          confidence = 0.5;
+        }
+        if (targetId) {
+          const callerNodeId = funcList ? findEnclosingFunctionFast(funcList, call.line) : null;
+          const sourceId = callerNodeId ?? fileNodeId;
+          if (sourceId !== targetId) {
+            const edgeId = generateEdgeId(sourceId, targetId, "calls");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: sourceId,
+                target: targetId,
+                kind: "calls",
+                weight: confidence,
+                label: call.name
+              });
+              callEdges++;
+            }
+          }
+        }
+      }
+      for (const h of heritages) {
+        const classNodeId = localSymbols?.get(h.className) ?? symbolIndex.get(h.className);
+        if (!classNodeId) continue;
+        for (const ext of h.extendsNames) {
+          const targetId = symbolIndex.get(ext);
+          if (targetId) {
+            const edgeId = generateEdgeId(classNodeId, targetId, "extends");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: classNodeId,
+                target: targetId,
+                kind: "extends",
+                weight: 1,
+                label: `extends ${ext}`
+              });
+              heritageEdges++;
+            }
+          }
+        }
+        for (const impl of h.implementsNames) {
+          const targetId = symbolIndex.get(impl);
+          if (targetId) {
+            const edgeId = generateEdgeId(classNodeId, targetId, "implements");
+            if (!graph.getEdge(edgeId)) {
+              graph.addEdge({
+                id: edgeId,
+                source: classNodeId,
+                target: targetId,
+                kind: "implements",
+                weight: 1,
+                label: `implements ${impl}`
+              });
+              heritageEdges++;
+            }
+          }
+        }
+      }
+      fileDone++;
+      context.onPhaseProgress?.("resolve", fileDone, filePaths.length);
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Resolved ${importEdges} imports, ${callEdges} calls, ${heritageEdges} heritage edges. Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`
+    };
+  }
+};
+function extractImports(lines, isPython) {
+  const imports = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const tsImport = line.match(/import\s+.*?from\s+['"]([^'"]+)['"]/);
+    if (tsImport) {
+      const names = [];
+      const namedMatch = line.match(/\{([^}]+)\}/);
+      if (namedMatch) {
+        names.push(
+          ...namedMatch[1].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim()).filter(Boolean)
+        );
+      }
+      const defaultMatch = line.match(/import\s+(\w+)/);
+      if (defaultMatch && defaultMatch[1] !== "type") names.push(defaultMatch[1]);
+      imports.push({ rawPath: tsImport[1], localNames: names, isDefault: !namedMatch, line: i + 1 });
+      continue;
+    }
+    if (isPython) {
+      const fromImport = line.match(/from\s+([\w.]+)\s+import\s+(.+)/);
+      if (fromImport) {
+        const names = fromImport[2].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim()).filter(Boolean);
+        imports.push({ rawPath: fromImport[1], localNames: names, isDefault: false, line: i + 1 });
+        continue;
+      }
+      const directImport = line.match(/^import\s+([\w.]+)(?:\s+as\s+(\w+))?/);
+      if (directImport) {
+        imports.push({
+          rawPath: directImport[1],
+          localNames: [directImport[2] ?? directImport[1].split(".").pop()],
+          isDefault: false,
+          line: i + 1
+        });
+        continue;
+      }
+    }
+    const javaImport = line.match(/^import\s+(?:static\s+)?([\w.]+)/);
+    if (javaImport && !line.includes("from")) {
+      const parts = javaImport[1].split(".");
+      imports.push({ rawPath: javaImport[1], localNames: [parts[parts.length - 1]], isDefault: false, line: i + 1 });
+      continue;
+    }
+    const goImport = line.match(/^\s*"([^"]+)"/);
+    if (goImport && (i > 0 && lines[i - 1]?.includes("import") || line.match(/^import\s+"/))) {
+      const parts = goImport[1].split("/");
+      imports.push({ rawPath: goImport[1], localNames: [parts[parts.length - 1]], isDefault: false, line: i + 1 });
+      continue;
+    }
+    const includeMatch = line.match(/#include\s+[<"]([^>"]+)[>"]/);
+    if (includeMatch) {
+      imports.push({ rawPath: includeMatch[1], localNames: [], isDefault: false, line: i + 1 });
+      continue;
+    }
+    const rustUse = line.match(/^use\s+([\w:]+)/);
+    if (rustUse) {
+      const parts = rustUse[1].split("::");
+      imports.push({ rawPath: rustUse[1], localNames: [parts[parts.length - 1]], isDefault: false, line: i + 1 });
+      continue;
+    }
+    const usingMatch = line.match(/^using\s+([\w.]+)/);
+    if (usingMatch) {
+      const parts = usingMatch[1].split(".");
+      imports.push({ rawPath: usingMatch[1], localNames: [parts[parts.length - 1]], isDefault: false, line: i + 1 });
+    }
+    const requireMatch = line.match(/require\s+['"]([^'"]+)['"]/);
+    if (requireMatch) {
+      imports.push({ rawPath: requireMatch[1], localNames: [], isDefault: false, line: i + 1 });
+    }
+  }
+  return imports;
+}
+function extractCalls(lines) {
+  const calls = [];
+  const callRegex = /(?:new\s+)?(\w+)\s*\(/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*(export\s+)?(async\s+)?function\s/.test(line)) continue;
+    if (/^\s*(export\s+)?(abstract\s+)?class\s/.test(line)) continue;
+    if (/^\s*(export\s+)?interface\s/.test(line)) continue;
+    if (/^\s*(export\s+)?enum\s/.test(line)) continue;
+    if (/^\s*(export\s+)?type\s+\w+\s*=/.test(line)) continue;
+    if (/^\s*import\s/.test(line)) continue;
+    if (/^\s*\/\//.test(line)) continue;
+    let match;
+    callRegex.lastIndex = 0;
+    while ((match = callRegex.exec(line)) !== null) {
+      const name = match[1];
+      if (CALL_KEYWORDS.has(name)) continue;
+      const isNew = line.substring(Math.max(0, match.index - 4), match.index).includes("new");
+      calls.push({ name, isNew, line: i + 1 });
+    }
+    const memberCallRegex = /(\w+)\.(\w+)\s*\(/g;
+    memberCallRegex.lastIndex = 0;
+    while ((match = memberCallRegex.exec(line)) !== null) {
+      calls.push({ name: match[2], receiverText: match[1], isNew: false, line: i + 1 });
+    }
+  }
+  return calls;
+}
+function extractHeritage(lines) {
+  const heritages = [];
+  for (const line of lines) {
+    const classMatch = line.match(/class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?/);
+    if (classMatch) {
+      const extendsNames = classMatch[2] ? [classMatch[2]] : [];
+      const implementsNames = classMatch[3] ? classMatch[3].split(",").map((n) => n.trim()).filter(Boolean) : [];
+      heritages.push({ className: classMatch[1], extendsNames, implementsNames });
+      continue;
+    }
+    const pyClassMatch = line.match(/class\s+(\w+)\(([^)]+)\)/);
+    if (pyClassMatch) {
+      const bases = pyClassMatch[2].split(",").map((n) => n.trim()).filter(Boolean);
+      heritages.push({ className: pyClassMatch[1], extendsNames: bases, implementsNames: [] });
+    }
+  }
+  return heritages;
+}
+function findEnclosingFunctionFast(funcs, line) {
+  let lo = 0;
+  let hi = funcs.length - 1;
+  let best = null;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const fn = funcs[mid];
+    if (fn.startLine <= line) {
+      if (fn.endLine === void 0 || line <= fn.endLine) {
+        best = fn.id;
+      }
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return best;
+}
+
+// src/pipeline/phases/cluster-phase.ts
+var clusterPhase = {
+  name: "cluster",
+  dependencies: ["resolve"],
+  async execute(context) {
+    const start = Date.now();
+    const { graph } = context;
+    const relevantKinds = /* @__PURE__ */ new Set(["function", "class", "method", "interface", "struct", "trait", "enum"]);
+    const nodesByDir = /* @__PURE__ */ new Map();
+    for (const node of graph.allNodes()) {
+      if (!relevantKinds.has(node.kind)) continue;
+      const dir = node.filePath.split("/").slice(0, -1).join("/") || ".";
+      let group = nodesByDir.get(dir);
+      if (!group) {
+        group = [];
+        nodesByDir.set(dir, group);
+      }
+      group.push({ id: node.id, name: node.name });
+    }
+    let clusterCount = 0;
+    const dirEntries = [...nodesByDir.entries()];
+    let clusterDone = 0;
+    for (const [dir, members] of dirEntries) {
+      clusterDone++;
+      context.onPhaseProgress?.("cluster", clusterDone, dirEntries.length);
+      if (members.length < 2) continue;
+      const clusterId = generateNodeId("cluster", dir, `cluster-${clusterCount}`);
+      const label = dir.split("/").filter(Boolean).pop() ?? `cluster-${clusterCount}`;
+      graph.addNode({
+        id: clusterId,
+        kind: "cluster",
+        name: label,
+        filePath: dir,
+        metadata: { memberCount: members.length }
+      });
+      for (const member of members) {
+        graph.addEdge({
+          id: generateEdgeId(member.id, clusterId, "belongs_to"),
+          source: member.id,
+          target: clusterId,
+          kind: "belongs_to",
+          weight: 1
+        });
+      }
+      clusterCount++;
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Created ${clusterCount} clusters`
+    };
+  }
+};
+
+// src/pipeline/phases/flow-phase.ts
+var flowPhase = {
+  name: "flow",
+  dependencies: ["resolve"],
+  async execute(context) {
+    const start = Date.now();
+    const { graph } = context;
+    const calledNodes = /* @__PURE__ */ new Set();
+    for (const edge of graph.findEdgesByKind("calls")) {
+      calledNodes.add(edge.target);
+    }
+    const entryPoints = [];
+    for (const node of graph.allNodes()) {
+      if (!["function", "method"].includes(node.kind)) continue;
+      let score = 0;
+      const hasCallers = calledNodes.has(node.id);
+      const outCalls = [...graph.findEdgesFrom(node.id)].filter((e) => e.kind === "calls");
+      if (!hasCallers && outCalls.length > 0) score += 10;
+      if (node.exported) score += 5;
+      if (/^(main|handle|init|start|run|execute|process|serve|listen|bootstrap)/.test(node.name)) score += 3;
+      if (node.filePath.includes("test") || node.filePath.includes("spec") || node.filePath.includes("__test")) score -= 20;
+      if (node.filePath.includes("route") || node.filePath.includes("controller") || node.filePath.includes("handler")) score += 8;
+      if (score >= 5) {
+        entryPoints.push({ id: node.id, name: node.name, score, filePath: node.filePath });
+      }
+    }
+    entryPoints.sort((a, b) => b.score - a.score);
+    const maxFlows = 75;
+    const maxDepth = 10;
+    const maxBranching = 4;
+    let flowCount = 0;
+    const epSlice = entryPoints.slice(0, 20);
+    for (let epIdx = 0; epIdx < epSlice.length; epIdx++) {
+      const ep = epSlice[epIdx];
+      context.onPhaseProgress?.("flow", epIdx + 1, epSlice.length);
+      if (flowCount >= maxFlows) break;
+      const queue = [{ nodeId: ep.id, path: [ep.id] }];
+      const visited = /* @__PURE__ */ new Set();
+      while (queue.length > 0 && flowCount < maxFlows) {
+        const { nodeId, path: path19 } = queue.shift();
+        if (path19.length > maxDepth) continue;
+        const callEdges = [...graph.findEdgesFrom(nodeId)].filter((e) => e.kind === "calls").slice(0, maxBranching);
+        if (callEdges.length === 0 && path19.length >= 3) {
+          const flowId = generateNodeId("flow", ep.filePath, `flow-${flowCount}`);
+          graph.addNode({
+            id: flowId,
+            kind: "flow",
+            name: `${ep.name} flow ${flowCount}`,
+            filePath: ep.filePath,
+            metadata: { steps: path19, entryPoint: ep.name }
+          });
+          for (let i = 0; i < path19.length; i++) {
+            graph.addEdge({
+              id: generateEdgeId(path19[i], flowId, `step_of_${i}`),
+              source: path19[i],
+              target: flowId,
+              kind: "step_of",
+              weight: 1,
+              label: `step ${i + 1}`
+            });
+          }
+          flowCount++;
+          continue;
+        }
+        for (const edge of callEdges) {
+          if (visited.has(edge.target)) continue;
+          visited.add(edge.target);
+          queue.push({ nodeId: edge.target, path: [...path19, edge.target] });
+        }
+      }
+    }
+    return {
+      status: "completed",
+      duration: Date.now() - start,
+      message: `Found ${entryPoints.length} entry points, traced ${flowCount} flows`
+    };
+  }
+};
+
+// src/scope-analysis/scope-builder.ts
+function createScope(name, kind, parent = null) {
+  const scope = { name, kind, parent, bindings: /* @__PURE__ */ new Map(), children: [] };
+  parent?.children.push(scope);
+  return scope;
+}
+function resolveBinding(name, scope) {
+  let current = scope;
+  while (current !== null) {
+    const binding = current.bindings.get(name);
+    if (binding) return binding;
+    current = current.parent;
+  }
+  return null;
+}
+function addBinding(scope, binding) {
+  scope.bindings.set(binding.name, binding);
+}
+
+// src/clustering/community-detector.ts
+function detectCommunities(graph) {
+  const relevantKinds = /* @__PURE__ */ new Set(["function", "class", "method", "interface", "struct"]);
+  const nodes = [];
+  for (const node of graph.allNodes()) {
+    if (relevantKinds.has(node.kind)) {
+      nodes.push(node);
+    }
+  }
+  if (nodes.length < 10) return [];
+  const dirGroups = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const dir = node.filePath.split("/").slice(0, -1).join("/") || ".";
+    let group = dirGroups.get(dir);
+    if (!group) {
+      group = [];
+      dirGroups.set(dir, group);
+    }
+    group.push(node);
+  }
+  const clusters = [];
+  let idx = 0;
+  for (const [dir, members] of dirGroups) {
+    if (members.length < 2) continue;
+    const clusterId = generateNodeId("cluster", dir, `cluster-${idx}`);
+    const label = generateLabel(dir, members);
+    clusters.push({
+      clusterId,
+      label,
+      memberIds: members.map((m) => m.id)
+    });
+    idx++;
+  }
+  return clusters;
+}
+function generateLabel(dir, members) {
+  const parts = dir.split("/").filter(Boolean);
+  if (parts.length > 0) {
+    return parts[parts.length - 1];
+  }
+  return `cluster-${members[0]?.name ?? "unknown"}`;
+}
+function addClustersToGraph(graph, clusters) {
+  for (const cluster of clusters) {
+    graph.addNode({
+      id: cluster.clusterId,
+      kind: "cluster",
+      name: cluster.label,
+      filePath: "",
+      metadata: { memberCount: cluster.memberIds.length }
+    });
+    for (const memberId of cluster.memberIds) {
+      graph.addEdge({
+        id: generateEdgeId(memberId, cluster.clusterId, "belongs_to"),
+        source: memberId,
+        target: cluster.clusterId,
+        kind: "belongs_to",
+        weight: 1
+      });
+    }
+  }
+}
+
+// src/flow-detection/entry-point-finder.ts
+function findEntryPoints(graph) {
+  const calledNodes = /* @__PURE__ */ new Set();
+  for (const edge of graph.findEdgesByKind("calls")) {
+    calledNodes.add(edge.target);
+  }
+  const entryPoints = [];
+  for (const node of graph.allNodes()) {
+    if (!["function", "method"].includes(node.kind)) continue;
+    const outEdges = [...graph.findEdgesFrom(node.id)].filter((e) => e.kind === "calls");
+    const inDegree = calledNodes.has(node.id) ? 1 : 0;
+    let score = 0;
+    if (outEdges.length > 0 && inDegree === 0) score += 10;
+    if (node.exported) score += 5;
+    if (/^(main|handle|init|start|run|execute|process|serve|listen)/.test(node.name)) score += 3;
+    if (node.filePath.includes("test") || node.filePath.includes("spec")) score -= 20;
+    if (node.filePath.includes("route") || node.filePath.includes("controller")) score += 8;
+    if (score >= 5) {
+      entryPoints.push({
+        nodeId: node.id,
+        name: node.name,
+        score,
+        filePath: node.filePath
+      });
+    }
+  }
+  return entryPoints.sort((a, b) => b.score - a.score);
+}
+function traceFlow(entryId, graph, maxDepth = 10, maxBranching = 4) {
+  const flows = [];
+  const maxFlows = 75;
+  function bfs() {
+    const queue = [{ nodeId: entryId, path: [entryId] }];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0 && flows.length < maxFlows) {
+      const { nodeId, path: path19 } = queue.shift();
+      if (path19.length > maxDepth) continue;
+      const callEdges = [...graph.findEdgesFrom(nodeId)].filter((e) => e.kind === "calls").slice(0, maxBranching);
+      if (callEdges.length === 0 && path19.length >= 3) {
+        flows.push({ entryPointId: entryId, steps: [...path19] });
+        continue;
+      }
+      for (const edge of callEdges) {
+        if (visited.has(edge.target)) continue;
+        visited.add(edge.target);
+        queue.push({ nodeId: edge.target, path: [...path19, edge.target] });
+      }
+    }
+  }
+  bfs();
+  return deduplicateFlows(flows);
+}
+function deduplicateFlows(flows) {
+  const result = [];
+  for (const flow of flows) {
+    const edges = /* @__PURE__ */ new Set();
+    for (let i = 0; i < flow.steps.length - 1; i++) {
+      edges.add(`${flow.steps[i]}->${flow.steps[i + 1]}`);
+    }
+    const isDuplicate = result.some((existing) => {
+      const existingEdges = /* @__PURE__ */ new Set();
+      for (let i = 0; i < existing.steps.length - 1; i++) {
+        existingEdges.add(`${existing.steps[i]}->${existing.steps[i + 1]}`);
+      }
+      let overlap = 0;
+      for (const e of edges) {
+        if (existingEdges.has(e)) overlap++;
+      }
+      return overlap / Math.max(edges.size, 1) > 0.7;
+    });
+    if (!isDuplicate) result.push(flow);
+  }
+  return result;
+}
+
+// src/search/text-search.ts
+function textSearch(graph, query, limit = 20) {
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const results = [];
+  const isTestPath = (fp) => fp.includes("test") || fp.includes("spec") || fp.includes("__test");
+  const isDistPath = (fp) => fp.includes("/dist") || fp.includes("\\dist") || fp.includes(".d.ts");
+  for (const node of graph.allNodes()) {
+    if (["directory", "cluster", "flow"].includes(node.kind)) continue;
+    let score = 0;
+    const nameLC = node.name.toLowerCase();
+    const pathLC = node.filePath.toLowerCase();
+    for (const term of terms) {
+      if (nameLC === term) score += 10;
+      else if (nameLC.startsWith(term)) score += 7;
+      else if (nameLC.includes(term)) score += 5;
+      if (pathLC.includes(term)) score += 2;
+      if (node.content?.toLowerCase().includes(term)) score += 3;
+    }
+    if (score > 0) {
+      if (isDistPath(node.filePath)) score -= 8;
+      if (isTestPath(node.filePath)) score -= 4;
+      if (["function", "class", "interface", "method"].includes(node.kind)) score += 1;
+    }
+    if (score > 0) {
+      results.push({
+        nodeId: node.id,
+        name: node.name,
+        kind: node.kind,
+        filePath: node.filePath,
+        score,
+        snippet: node.content?.slice(0, 200)
+      });
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
+}
+function reciprocalRankFusion(...rankings) {
+  const K = 60;
+  const scoreMap = /* @__PURE__ */ new Map();
+  for (const ranking of rankings) {
+    for (let rank = 0; rank < ranking.length; rank++) {
+      const result = ranking[rank];
+      const existing = scoreMap.get(result.nodeId);
+      const rrfContribution = 1 / (K + rank + 1);
+      if (existing) {
+        existing.rrfScore += rrfContribution;
+      } else {
+        scoreMap.set(result.nodeId, {
+          result,
+          rrfScore: rrfContribution
+        });
+      }
+    }
+  }
+  return [...scoreMap.values()].sort((a, b) => b.rrfScore - a.rrfScore).map((entry) => ({ ...entry.result, score: entry.rrfScore }));
+}
+
+// src/search/index.ts
+init_embedder();
+
+// src/search/vector-index.ts
+var EMBED_TABLE = "embed_nodes";
+var EMBED_DIM = 384;
+var INDEX_NAME = "embed_vec_idx";
+var VectorIndex = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  async init() {
+    await this.db.execute("INSTALL VECTOR");
+    await this.db.execute("LOAD EXTENSION VECTOR");
+    await this.db.execute(`
+      CREATE NODE TABLE IF NOT EXISTS ${EMBED_TABLE} (
+        id STRING,
+        name STRING,
+        kind STRING,
+        file_path STRING,
+        text STRING,
+        embedding FLOAT[${EMBED_DIM}],
+        PRIMARY KEY (id)
+      )
+    `);
+  }
+  async buildIndex(nodes) {
+    await this.db.execute(`MATCH (n:${EMBED_TABLE}) DETACH DELETE n`).catch(() => {
+    });
+    for (const node of nodes) {
+      const vecLiteral = `[${node.embedding.join(",")}]`;
+      await this.db.execute(
+        `CREATE (:${EMBED_TABLE} {
+          id: '${esc(node.id)}',
+          name: '${esc(node.name)}',
+          kind: '${esc(node.kind)}',
+          file_path: '${esc(node.filePath)}',
+          text: '${esc(node.text)}',
+          embedding: ${vecLiteral}
+        })`
+      );
+    }
+    await this.db.execute(`CALL DROP_VECTOR_INDEX('${EMBED_TABLE}', '${INDEX_NAME}')`).catch(() => {
+    });
+    await this.db.execute(`CALL CREATE_VECTOR_INDEX('${EMBED_TABLE}', '${INDEX_NAME}', 'embedding')`);
+  }
+  async search(queryEmbedding, topK = 10) {
+    const vecLiteral = `[${queryEmbedding.join(",")}]`;
+    const rows = await this.db.query(
+      `CALL QUERY_VECTOR_INDEX('${EMBED_TABLE}', '${INDEX_NAME}', ${vecLiteral}, ${topK}) RETURN node.id, node.name, node.kind, node.file_path, distance`
+    );
+    return rows.map((r) => ({
+      nodeId: String(r["node.id"]),
+      name: String(r["node.name"]),
+      kind: String(r["node.kind"]),
+      filePath: String(r["node.file_path"]),
+      score: 1 - Number(r["distance"])
+      // cosine distance → similarity
+    }));
+  }
+  async isBuilt() {
+    try {
+      const rows = await this.db.query(`MATCH (n:${EMBED_TABLE}) RETURN count(n) AS cnt`);
+      return Number(rows[0]?.cnt ?? 0) > 0;
+    } catch {
+      return false;
+    }
+  }
+};
+function esc(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
+}
+var GLOBAL_DIR = path6.join(os3.homedir(), ".code-intel");
+var REPOS_FILE = path6.join(GLOBAL_DIR, "repos.json");
+function loadRegistry() {
+  try {
+    const data = fs6.readFileSync(REPOS_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return [];
+  }
+}
+function saveRegistry(entries) {
+  fs6.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs6.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+}
+function upsertRepo(entry) {
+  const entries = loadRegistry();
+  const idx = entries.findIndex((e) => e.path === entry.path);
+  if (idx >= 0) {
+    entries[idx] = entry;
+  } else {
+    entries.push(entry);
+  }
+  saveRegistry(entries);
+}
+function removeRepo(repoPath) {
+  const entries = loadRegistry().filter((e) => e.path !== repoPath);
+  saveRegistry(entries);
+}
+function saveMetadata(repoDir, metadata) {
+  const metaDir = path6.join(repoDir, ".code-intel");
+  fs6.mkdirSync(metaDir, { recursive: true });
+  fs6.writeFileSync(path6.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
+}
+function loadMetadata(repoDir) {
+  try {
+    const data = fs6.readFileSync(path6.join(repoDir, ".code-intel", "meta.json"), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function getDbPath(repoDir) {
+  return path6.join(repoDir, ".code-intel", "graph.db");
+}
+function getVectorDbPath(repoDir) {
+  return path6.join(repoDir, ".code-intel", "vector.db");
+}
+
+// src/mcp-server/server.ts
+init_group_registry();
+var DbManager = class {
+  db = null;
+  conn = null;
+  dbPath;
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  async init() {
+    fs6.mkdirSync(path6.dirname(this.dbPath), { recursive: true });
+    this.db = new Database(this.dbPath);
+    await this.db.init();
+    this.conn = new Connection(this.db);
+    await this.conn.init();
+  }
+  async query(cypher) {
+    if (!this.conn) throw new Error("Database not initialized");
+    const result = await this.conn.query(cypher);
+    const qr = Array.isArray(result) ? result[0] : result;
+    const rows = await qr.getAll();
+    qr.close();
+    return rows;
+  }
+  async execute(cypher) {
+    if (!this.conn) throw new Error("Database not initialized");
+    const result = await this.conn.query(cypher);
+    const qr = Array.isArray(result) ? result[0] : result;
+    qr.close();
+  }
+  close() {
+    try {
+      this.conn?.close();
+    } catch {
+    }
+    try {
+      this.db?.close();
+    } catch {
+    }
+    this.conn = null;
+    this.db = null;
+  }
+  get isOpen() {
+    return this.conn !== null;
+  }
+};
+
+// src/storage/schema.ts
+var NODE_TABLE_MAP = {
+  file: "file_nodes",
+  directory: "dir_nodes",
+  function: "func_nodes",
+  class: "class_nodes",
+  interface: "iface_nodes",
+  method: "method_nodes",
+  constructor: "ctor_nodes",
+  variable: "var_nodes",
+  property: "prop_nodes",
+  struct: "struct_nodes",
+  enum: "enum_nodes",
+  trait: "trait_nodes",
+  namespace: "ns_nodes",
+  module: "mod_nodes",
+  type_alias: "type_nodes",
+  constant: "const_nodes",
+  route: "route_nodes",
+  cluster: "cluster_nodes",
+  flow: "flow_nodes"
+};
+var ALL_NODE_TABLES = [...new Set(Object.values(NODE_TABLE_MAP))];
+function getCreateNodeTableDDL(tableName) {
+  return `CREATE NODE TABLE IF NOT EXISTS ${tableName} (
+  id STRING,
+  name STRING,
+  file_path STRING,
+  start_line INT64,
+  end_line INT64,
+  exported BOOLEAN,
+  content STRING,
+  metadata STRING,
+  PRIMARY KEY (id)
+)`;
+}
+function getCreateEdgeTableDDL() {
+  const ddls = [];
+  const uniqueTables = ALL_NODE_TABLES;
+  const fromToPairs = [];
+  for (const from of uniqueTables) {
+    for (const to of uniqueTables) {
+      fromToPairs.push(`FROM ${from} TO ${to}`);
+    }
+  }
+  ddls.push(`CREATE REL TABLE IF NOT EXISTS code_edges (
+  ${fromToPairs.join(",\n  ")},
+  kind STRING,
+  weight DOUBLE,
+  label STRING
+)`);
+  return ddls;
+}
+
+// src/multi-repo/graph-from-db.ts
+var TABLE_TO_KIND = Object.fromEntries(
+  Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
+);
+function parseRow(row, kind) {
+  return {
+    id: String(row["id"] ?? ""),
+    kind,
+    name: String(row["name"] ?? ""),
+    filePath: String(row["file_path"] ?? ""),
+    startLine: row["start_line"] != null ? Number(row["start_line"]) : void 0,
+    endLine: row["end_line"] != null ? Number(row["end_line"]) : void 0,
+    exported: row["exported"] != null ? Boolean(row["exported"]) : void 0,
+    content: row["content"] ? String(row["content"]) : void 0,
+    metadata: row["metadata"] ? (() => {
+      try {
+        return JSON.parse(String(row["metadata"]));
+      } catch {
+        return void 0;
+      }
+    })() : void 0
+  };
+}
+async function loadGraphFromDB(graph, db) {
+  for (const table of ALL_NODE_TABLES) {
+    const kind = TABLE_TO_KIND[table];
+    if (!kind) continue;
+    let rows = [];
+    try {
+      rows = await db.query(`MATCH (n:${table}) RETURN n.id, n.name, n.file_path, n.start_line, n.end_line, n.exported, n.content, n.metadata`);
+    } catch {
+      continue;
+    }
+    for (const row of rows) {
+      const node = parseRow({
+        id: row["n.id"],
+        name: row["n.name"],
+        file_path: row["n.file_path"],
+        start_line: row["n.start_line"],
+        end_line: row["n.end_line"],
+        exported: row["n.exported"],
+        content: row["n.content"],
+        metadata: row["n.metadata"]
+      }, kind);
+      if (node.id && node.name) graph.addNode(node);
+    }
+  }
+  try {
+    const edgeRows = await db.query(
+      `MATCH (a)-[e:code_edges]->(b) RETURN a.id, b.id, e.kind, e.weight, e.label`
+    );
+    for (const row of edgeRows) {
+      const sourceId = String(row["a.id"] ?? "");
+      const targetId = String(row["b.id"] ?? "");
+      const kind = String(row["e.kind"] ?? "");
+      if (!sourceId || !targetId || !kind) continue;
+      const edge = {
+        id: `${sourceId}::${kind}::${targetId}`,
+        source: sourceId,
+        target: targetId,
+        kind,
+        weight: row["e.weight"] != null ? Number(row["e.weight"]) : void 0,
+        label: row["e.label"] ? String(row["e.label"]) : void 0
+      };
+      graph.addEdge(edge);
+    }
+  } catch {
+  }
+}
+
+// src/multi-repo/group-sync.ts
+function extractContracts(graph, repoName, repoPath) {
+  const contracts = [];
+  for (const node of graph.allNodes()) {
+    if (node.exported === true && ["function", "class", "interface", "method", "type_alias", "constant", "enum", "struct", "trait"].includes(node.kind)) {
+      contracts.push({
+        repoName,
+        repoPath,
+        kind: "export",
+        name: node.name,
+        nodeId: node.id,
+        nodeKind: node.kind,
+        filePath: node.filePath,
+        signature: node.content?.split("\n")[0]?.trim()
+      });
+    }
+    if (node.kind === "route") {
+      contracts.push({
+        repoName,
+        repoPath,
+        kind: "route",
+        name: node.name,
+        nodeId: node.id,
+        nodeKind: node.kind,
+        filePath: node.filePath,
+        signature: node.content?.split("\n")[0]?.trim()
+      });
+    }
+    if (["interface", "type_alias"].includes(node.kind)) {
+      const nameLower = node.name.toLowerCase();
+      if (nameLower.includes("event") || nameLower.includes("message")) {
+        contracts.push({
+          repoName,
+          repoPath,
+          kind: "event",
+          name: node.name,
+          nodeId: node.id,
+          nodeKind: node.kind,
+          filePath: node.filePath
+        });
+      } else if (nameLower.includes("schema") || nameLower.includes("dto") || nameLower.includes("request") || nameLower.includes("response")) {
+        contracts.push({
+          repoName,
+          repoPath,
+          kind: "schema",
+          name: node.name,
+          nodeId: node.id,
+          nodeKind: node.kind,
+          filePath: node.filePath
+        });
+      }
+    }
+  }
+  return contracts;
+}
+function matchContracts(allContracts) {
+  const links = [];
+  const byRepo = /* @__PURE__ */ new Map();
+  for (const c of allContracts) {
+    const arr = byRepo.get(c.repoName) ?? [];
+    arr.push(c);
+    byRepo.set(c.repoName, arr);
+  }
+  const repoNames = [...byRepo.keys()];
+  for (let i = 0; i < repoNames.length; i++) {
+    for (let j = 0; j < repoNames.length; j++) {
+      if (i === j) continue;
+      const providerContracts = byRepo.get(repoNames[i]);
+      const consumerContracts = byRepo.get(repoNames[j]);
+      const consumerByName = /* @__PURE__ */ new Map();
+      for (const c of consumerContracts) consumerByName.set(c.name, c);
+      for (const provider of providerContracts) {
+        const consumer = consumerByName.get(provider.name);
+        if (consumer) {
+          const sameKind = provider.kind === consumer.kind;
+          links.push({
+            providerRepo: provider.repoName,
+            providerContract: provider.name,
+            consumerRepo: consumer.repoName,
+            consumerContract: consumer.name,
+            matchKind: provider.kind === "route" ? "route-match" : "name-match",
+            confidence: sameKind ? 0.9 : 0.6
+          });
+        } else {
+          const providerLC = provider.name.toLowerCase();
+          for (const c of consumerContracts) {
+            if (c.name.toLowerCase().includes(providerLC) || providerLC.includes(c.name.toLowerCase())) {
+              if (c.name.length >= 4 && provider.name.length >= 4) {
+                links.push({
+                  providerRepo: provider.repoName,
+                  providerContract: provider.name,
+                  consumerRepo: c.repoName,
+                  consumerContract: c.name,
+                  matchKind: "name-match",
+                  confidence: 0.4
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const key = `${link.providerRepo}:${link.providerContract}:${link.consumerRepo}:${link.consumerContract}`;
+    const existing = seen.get(key);
+    if (!existing || link.confidence > existing.confidence) {
+      seen.set(key, link);
+    }
+  }
+  return [...seen.values()].sort((a, b) => b.confidence - a.confidence);
+}
+async function syncGroup(group) {
+  const registry = loadRegistry();
+  const allContracts = [];
+  for (const member of group.members) {
+    const regEntry = registry.find((r) => r.name === member.registryName);
+    if (!regEntry) {
+      logger_default.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
+      continue;
+    }
+    const dbPath = path6.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs6.existsSync(dbPath)) {
+      logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
+      continue;
+    }
+    const graph = createKnowledgeGraph();
+    const db = new DbManager(dbPath);
+    try {
+      await db.init();
+      await loadGraphFromDB(graph, db);
+      db.close();
+    } catch (err) {
+      db.close();
+      logger_default.warn(`  \u26A0 Could not load graph for "${member.registryName}": ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const contracts = extractContracts(graph, member.registryName, regEntry.path);
+    logger_default.info(`  \u2713 ${member.registryName} (${member.groupPath}): ${contracts.length} contracts`);
+    allContracts.push(...contracts);
+  }
+  const links = matchContracts(allContracts);
+  return {
+    groupName: group.name,
+    syncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    memberCount: group.members.length,
+    contracts: allContracts,
+    links
+  };
+}
+async function queryGroup(group, query, limit = 20) {
+  const registry = loadRegistry();
+  const perRepo = [];
+  const allRankings = [];
+  for (const member of group.members) {
+    const regEntry = registry.find((r) => r.name === member.registryName);
+    if (!regEntry) continue;
+    const dbPath = path6.join(regEntry.path, ".code-intel", "graph.db");
+    if (!fs6.existsSync(dbPath)) continue;
+    const graph = createKnowledgeGraph();
+    const db = new DbManager(dbPath);
+    try {
+      await db.init();
+      await loadGraphFromDB(graph, db);
+      db.close();
+    } catch {
+      db.close();
+      continue;
+    }
+    const results = textSearch(graph, query, limit);
+    const taggedResults = results.map((r) => ({
+      ...r,
+      snippet: `[${member.registryName}] ${r.snippet ?? ""}`.trim()
+    }));
+    perRepo.push({
+      repoName: member.registryName,
+      repoPath: regEntry.path,
+      groupPath: member.groupPath,
+      results: taggedResults
+    });
+    allRankings.push(taggedResults);
+  }
+  const merged = reciprocalRankFusion(...allRankings).slice(0, limit);
+  return { perRepo, merged };
+}
+function createMcpServer(graph, repoName, workspaceRoot) {
+  const server = new Server(
+    { name: "code-intel", version: "0.1.0" },
+    { capabilities: { tools: {}, resources: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      // ── Core repo tools ──────────────────────────────────────────────────
+      {
+        name: "repos",
+        description: "List all indexed repositories with node and edge counts",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "overview",
+        description: "Repository summary: total nodes/edges and a full breakdown of node and edge counts by kind. Use this first to understand the shape of the codebase.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      // ── Search & inspect ─────────────────────────────────────────────────
+      {
+        name: "search",
+        description: "BM25 keyword search across all indexed symbols \u2014 functions, classes, files, routes, etc.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query (symbol name, keyword, or partial match)" },
+            limit: { type: "number", description: "Max results to return (default: 20)" }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "inspect",
+        description: "360\xB0 view of a symbol: definition location, callers, callees, heritage (extends/implements), members, cluster, and source preview (first 500 chars)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            symbol_name: { type: "string", description: "Exact symbol name to inspect" }
+          },
+          required: ["symbol_name"]
+        }
+      },
+      {
+        name: "blast_radius",
+        description: "Impact analysis: traverse the call/import graph to find all symbols that depend on or are affected by a given symbol. Returns risk level (LOW / MEDIUM / HIGH).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: { type: "string", description: "Target symbol name" },
+            direction: {
+              type: "string",
+              enum: ["callers", "callees", "both"],
+              description: "Which direction to trace \u2014 callers (who depends on it), callees (what it depends on), or both (default: both)"
+            },
+            max_hops: { type: "number", description: "Maximum traversal depth (default: 5)" }
+          },
+          required: ["target"]
+        }
+      },
+      {
+        name: "file_symbols",
+        description: "List all symbols defined in a specific file \u2014 useful to understand what a file exports or contains without reading raw source.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: { type: "string", description: 'File path (partial match is supported, e.g. "auth/login.ts")' }
+          },
+          required: ["file_path"]
+        }
+      },
+      {
+        name: "find_path",
+        description: "Find the shortest call/import path between two symbols. Useful for tracing how one module reaches another.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            from: { type: "string", description: "Source symbol name" },
+            to: { type: "string", description: "Target symbol name" },
+            max_hops: { type: "number", description: "Maximum path length to search (default: 8)" }
+          },
+          required: ["from", "to"]
+        }
+      },
+      {
+        name: "list_exports",
+        description: "List all exported symbols in the repository. Helps AI understand the public API surface of the codebase.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            kind: {
+              type: "string",
+              description: "Filter by node kind: function | class | interface | method | type_alias | constant | enum (optional)"
+            },
+            limit: { type: "number", description: "Max results (default: 100)" }
+          }
+        }
+      },
+      // ── Routes, clusters, flows ──────────────────────────────────────────
+      {
+        name: "routes",
+        description: "List all HTTP route handler mappings detected in the codebase (kind=route or route/handler/controller files)",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "clusters",
+        description: "List detected code clusters (directory-based communities) with member counts and top 10 symbols each. Useful for understanding code organisation.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "number", description: "Max clusters to return (default: 50)" }
+          }
+        }
+      },
+      {
+        name: "flows",
+        description: "List all detected execution flows \u2014 entry points traced through the call graph. Each flow has a name, entry point, and ordered steps.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "number", description: "Max flows to return (default: 50)" }
+          }
+        }
+      },
+      // ── Git change impact ─────────────────────────────────────────────────
+      {
+        name: "detect_changes",
+        description: "Git-diff impact analysis: detects which source files and line ranges changed (HEAD vs working tree or a custom diff), maps them to graph symbols, and computes the combined blast radius. Ideal for PR review or pre-commit analysis.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            base_ref: {
+              type: "string",
+              description: 'Git ref to diff against (default: HEAD). Examples: "HEAD~1", "main", a commit SHA.'
+            },
+            diff_text: {
+              type: "string",
+              description: "Raw unified diff text. If provided, base_ref is ignored and this diff is parsed directly."
+            }
+          }
+        }
+      },
+      // ── Raw query ─────────────────────────────────────────────────────────
+      {
+        name: "raw_query",
+        description: "Execute a simplified Cypher-like graph query. Supports: name='X' (exact name match) or :kind (list nodes of a kind, max 50)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            cypher: { type: "string", description: "Query string \u2014 e.g. name='runPipeline' or :function" }
+          },
+          required: ["cypher"]
+        }
+      },
+      // ── Group / multi-repo tools ──────────────────────────────────────────
+      {
+        name: "group_list",
+        description: "List all configured repository groups, or show the full membership of one group. Repository groups track multiple repos as a logical system.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Group name to inspect (optional \u2014 omit to list all groups)" }
+          }
+        }
+      },
+      {
+        name: "group_sync",
+        description: "Extract cross-repo contracts (exports, routes, schemas, events) from every member repo in a group and detect provider\u2192consumer links via name matching and RRF scoring.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Group name to sync" }
+          },
+          required: ["name"]
+        }
+      },
+      {
+        name: "group_contracts",
+        description: "Inspect extracted contracts and confidence-ranked cross-repo links from the last group sync. Supports filtering by kind, repo, and minimum confidence.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Group name" },
+            kind: {
+              type: "string",
+              enum: ["export", "route", "schema", "event"],
+              description: "Filter by contract kind (optional)"
+            },
+            repo: { type: "string", description: "Filter by registry name (optional)" },
+            min_confidence: { type: "number", description: "Minimum link confidence 0\u20131 (default: 0)" }
+          },
+          required: ["name"]
+        }
+      },
+      {
+        name: "group_query",
+        description: "BM25 search across all repos in a group, merged via Reciprocal Rank Fusion (RRF). Returns a unified ranked list plus per-repo breakdown.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Group name" },
+            query: { type: "string", description: "Search query" },
+            limit: { type: "number", description: "Max results per repo (default: 10)" }
+          },
+          required: ["name", "query"]
+        }
+      },
+      {
+        name: "group_status",
+        description: "Check index freshness and sync staleness for all repos in a group. Flags repos that have not been indexed or are stale (>24h).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Group name" }
+          },
+          required: ["name"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const a = args ?? {};
+    switch (name) {
+      // ── repos ──────────────────────────────────────────────────────────────
+      case "repos": {
+        const registry = loadRegistry();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(
+              registry.map((r) => ({ name: r.name, path: r.path, indexedAt: r.indexedAt, stats: r.stats })),
+              null,
+              2
+            )
+          }]
+        };
+      }
+      // ── overview ───────────────────────────────────────────────────────────
+      case "overview": {
+        const kindCounts = {};
+        for (const node of graph.allNodes()) {
+          kindCounts[node.kind] = (kindCounts[node.kind] ?? 0) + 1;
+        }
+        const edgeCounts = {};
+        for (const edge of graph.allEdges()) {
+          edgeCounts[edge.kind] = (edgeCounts[edge.kind] ?? 0) + 1;
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              repo: repoName,
+              stats: graph.size,
+              nodeCounts: kindCounts,
+              edgeCounts
+            }, null, 2)
+          }]
+        };
+      }
+      // ── search ─────────────────────────────────────────────────────────────
+      case "search": {
+        const query = a.query;
+        const limit = a.limit ?? 20;
+        const results = textSearch(graph, query, limit);
+        return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+      }
+      // ── inspect ────────────────────────────────────────────────────────────
+      case "inspect": {
+        const symbolName = a.symbol_name;
+        const node = findNodeByName(graph, symbolName);
+        if (!node) return { content: [{ type: "text", text: `Symbol "${symbolName}" not found. Try search first.` }] };
+        const incoming = [...graph.findEdgesTo(node.id)];
+        const outgoing = [...graph.findEdgesFrom(node.id)];
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              node: {
+                id: node.id,
+                kind: node.kind,
+                name: node.name,
+                filePath: node.filePath,
+                startLine: node.startLine,
+                endLine: node.endLine,
+                exported: node.exported
+              },
+              callers: incoming.filter((e) => e.kind === "calls").map((e) => ({
+                id: e.source,
+                name: graph.getNode(e.source)?.name,
+                file: graph.getNode(e.source)?.filePath
+              })),
+              callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({
+                id: e.target,
+                name: graph.getNode(e.target)?.name,
+                file: graph.getNode(e.target)?.filePath
+              })),
+              imports: incoming.filter((e) => e.kind === "imports").map((e) => graph.getNode(e.source)?.name),
+              importedBy: outgoing.filter((e) => e.kind === "imports").map((e) => graph.getNode(e.target)?.name),
+              extends: outgoing.filter((e) => e.kind === "extends").map((e) => graph.getNode(e.target)?.name),
+              implements: outgoing.filter((e) => e.kind === "implements").map((e) => graph.getNode(e.target)?.name),
+              members: outgoing.filter((e) => e.kind === "has_member").map((e) => ({
+                name: graph.getNode(e.target)?.name,
+                kind: graph.getNode(e.target)?.kind
+              })),
+              cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0],
+              content: node.content?.slice(0, 500)
+            }, null, 2)
+          }]
+        };
+      }
+      // ── blast_radius ───────────────────────────────────────────────────────
+      case "blast_radius": {
+        const target = a.target;
+        const direction = a.direction ?? "both";
+        const maxHops = a.max_hops ?? 5;
+        const node = findNodeByName(graph, target);
+        if (!node) return { content: [{ type: "text", text: `Symbol "${target}" not found.` }] };
+        const affected = /* @__PURE__ */ new Set();
+        const queue = [{ id: node.id, depth: 0 }];
+        const visited = /* @__PURE__ */ new Set();
+        while (queue.length > 0) {
+          const { id, depth } = queue.shift();
+          if (visited.has(id) || depth > maxHops) continue;
+          visited.add(id);
+          affected.add(id);
+          if (direction === "callers" || direction === "both") {
+            for (const edge of graph.findEdgesTo(id)) {
+              if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.source, depth: depth + 1 });
+            }
+          }
+          if (direction === "callees" || direction === "both") {
+            for (const edge of graph.findEdgesFrom(id)) {
+              if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.target, depth: depth + 1 });
+            }
+          }
+        }
+        const affectedDetails = [...affected].map((id) => {
+          const n = graph.getNode(id);
+          return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
+        });
+        const risk = affected.size > 10 ? "HIGH" : affected.size > 5 ? "MEDIUM" : "LOW";
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              target: node.name,
+              affectedCount: affected.size,
+              riskLevel: risk,
+              affected: affectedDetails
+            }, null, 2)
+          }]
+        };
+      }
+      // ── file_symbols ───────────────────────────────────────────────────────
+      case "file_symbols": {
+        const filePath = a.file_path;
+        const matches = [];
+        for (const node of graph.allNodes()) {
+          if (node.filePath && node.filePath.includes(filePath)) {
+            matches.push({ kind: node.kind, name: node.name, startLine: node.startLine, exported: node.exported });
+          }
+        }
+        if (matches.length === 0) {
+          return { content: [{ type: "text", text: `No symbols found for file path matching "${filePath}".` }] };
+        }
+        matches.sort((a2, b) => (a2.startLine ?? 0) - (b.startLine ?? 0));
+        return { content: [{ type: "text", text: JSON.stringify(matches, null, 2) }] };
+      }
+      // ── find_path ──────────────────────────────────────────────────────────
+      case "find_path": {
+        const fromName = a.from;
+        const toName = a.to;
+        const maxHops = a.max_hops ?? 8;
+        const fromNode = findNodeByName(graph, fromName);
+        const toNode = findNodeByName(graph, toName);
+        if (!fromNode) return { content: [{ type: "text", text: `Source symbol "${fromName}" not found.` }] };
+        if (!toNode) return { content: [{ type: "text", text: `Target symbol "${toName}" not found.` }] };
+        const queue = [{ id: fromNode.id, path: [fromNode.id] }];
+        const visited = /* @__PURE__ */ new Set();
+        let foundPath = null;
+        while (queue.length > 0) {
+          const { id, path: currentPath } = queue.shift();
+          if (visited.has(id)) continue;
+          visited.add(id);
+          if (id === toNode.id) {
+            foundPath = currentPath;
+            break;
+          }
+          if (currentPath.length > maxHops) continue;
+          for (const edge of graph.findEdgesFrom(id)) {
+            if ((edge.kind === "calls" || edge.kind === "imports") && !visited.has(edge.target)) {
+              queue.push({ id: edge.target, path: [...currentPath, edge.target] });
+            }
+          }
+        }
+        if (!foundPath) {
+          return { content: [{ type: "text", text: `No path found from "${fromName}" to "${toName}" within ${maxHops} hops.` }] };
+        }
+        const pathDetails = foundPath.map((id) => {
+          const n = graph.getNode(id);
+          return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ from: fromName, to: toName, hops: foundPath.length - 1, path: pathDetails }, null, 2)
+          }]
+        };
+      }
+      // ── list_exports ───────────────────────────────────────────────────────
+      case "list_exports": {
+        const kindFilter = a.kind;
+        const limit = a.limit ?? 100;
+        const exports$1 = [];
+        for (const node of graph.allNodes()) {
+          if (!node.exported) continue;
+          if (kindFilter && node.kind !== kindFilter) continue;
+          exports$1.push({ kind: node.kind, name: node.name, filePath: node.filePath, startLine: node.startLine });
+          if (exports$1.length >= limit) break;
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ total: exports$1.length, exports: exports$1 }, null, 2) }] };
+      }
+      // ── routes ─────────────────────────────────────────────────────────────
+      case "routes": {
+        const routes = [];
+        for (const node of graph.allNodes()) {
+          if (node.kind === "route" || node.kind === "function" && /route|handler|controller/i.test(node.filePath)) {
+            routes.push({ name: node.name, filePath: node.filePath, startLine: node.startLine });
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(routes, null, 2) }] };
+      }
+      // ── clusters ───────────────────────────────────────────────────────────
+      case "clusters": {
+        const limit = a.limit ?? 50;
+        const clusters = [];
+        for (const node of graph.allNodes()) {
+          if (node.kind === "cluster") {
+            const members = [];
+            for (const edge of graph.findEdgesTo(node.id)) {
+              if (edge.kind === "belongs_to") {
+                const member = graph.getNode(edge.source);
+                if (member && member.kind !== "cluster") {
+                  members.push({ name: member.name, kind: member.kind });
+                }
+              }
+            }
+            clusters.push({
+              id: node.id,
+              name: node.name,
+              memberCount: node.metadata?.memberCount ?? members.length,
+              topSymbols: members.slice(0, 10)
+            });
+            if (clusters.length >= limit) break;
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(clusters, null, 2) }] };
+      }
+      // ── flows ──────────────────────────────────────────────────────────────
+      case "flows": {
+        const limit = a.limit ?? 50;
+        const flows = [];
+        for (const node of graph.allNodes()) {
+          if (node.kind === "flow") {
+            const steps = node.metadata?.steps;
+            flows.push({
+              id: node.id,
+              name: node.name,
+              entryPoint: node.metadata?.entryPoint,
+              steps: steps ?? [],
+              stepCount: Array.isArray(steps) ? steps.length : 0
+            });
+            if (flows.length >= limit) break;
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(flows, null, 2) }] };
+      }
+      // ── detect_changes ─────────────────────────────────────────────────────
+      case "detect_changes": {
+        const baseRef = a.base_ref ?? "HEAD";
+        const diffTextInput = a.diff_text;
+        let diffText;
+        const repoRoot = workspaceRoot ?? process.cwd();
+        if (diffTextInput) {
+          diffText = diffTextInput;
+        } else {
+          try {
+            diffText = execSync(`git diff ${baseRef}`, { cwd: repoRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+            if (!diffText.trim()) {
+              diffText = execSync(`git diff HEAD`, { cwd: repoRoot, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+            }
+          } catch {
+            return { content: [{ type: "text", text: `Could not run git diff in ${repoRoot}. Ensure the path is a Git repository.` }] };
+          }
+        }
+        if (!diffText.trim()) {
+          return { content: [{ type: "text", text: "No changes detected in git diff." }] };
+        }
+        const changedFiles = parseDiff(diffText);
+        const hitNodes = /* @__PURE__ */ new Set();
+        for (const { filePath: changedFile, changedLines } of changedFiles) {
+          for (const node of graph.allNodes()) {
+            if (!node.filePath) continue;
+            const normNode = node.filePath.replace(repoRoot + "/", "").replace(repoRoot + path6.sep, "");
+            const normChanged = changedFile.replace(/^a\/|^b\//, "");
+            if (!normNode.endsWith(normChanged) && !normChanged.endsWith(normNode)) continue;
+            if (node.startLine !== void 0 && node.endLine !== void 0) {
+              const overlaps = changedLines.some((l) => l >= node.startLine && l <= node.endLine);
+              if (overlaps) hitNodes.add(node.id);
+            } else if (node.startLine !== void 0) {
+              const overlaps = changedLines.some((l) => Math.abs(l - node.startLine) <= 3);
+              if (overlaps) hitNodes.add(node.id);
+            }
+          }
+        }
+        const allAffected = /* @__PURE__ */ new Set();
+        for (const startId of hitNodes) {
+          const queue = [{ id: startId, depth: 0 }];
+          const visited = /* @__PURE__ */ new Set();
+          while (queue.length > 0) {
+            const { id, depth } = queue.shift();
+            if (visited.has(id) || depth > 5) continue;
+            visited.add(id);
+            allAffected.add(id);
+            for (const edge of graph.findEdgesTo(id)) {
+              if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.source, depth: depth + 1 });
+            }
+          }
+        }
+        const changedSymbols = [...hitNodes].map((id) => {
+          const n = graph.getNode(id);
+          return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
+        });
+        const affectedSymbols = [...allAffected].filter((id) => !hitNodes.has(id)).map((id) => {
+          const n = graph.getNode(id);
+          return n ? { id, name: n.name, kind: n.kind, filePath: n.filePath } : { id };
+        });
+        const risk = allAffected.size > 10 ? "HIGH" : allAffected.size > 4 ? "MEDIUM" : "LOW";
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              baseRef,
+              changedFiles: changedFiles.map((f) => f.filePath),
+              directlyChangedSymbols: changedSymbols,
+              transitivelyAffectedSymbols: affectedSymbols,
+              totalAffected: allAffected.size,
+              riskLevel: risk
+            }, null, 2)
+          }]
+        };
+      }
+      // ── raw_query ──────────────────────────────────────────────────────────
+      case "raw_query": {
+        const q = a.cypher;
+        const nameMatch = q?.match(/name\s*=\s*['"]([^'"]+)['"]/i);
+        if (nameMatch) {
+          const results = [];
+          for (const node of graph.allNodes()) {
+            if (node.name === nameMatch[1]) results.push(node);
+          }
+          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        const kindMatch = q?.match(/:\s*(\w+)/);
+        if (kindMatch) {
+          const results = [];
+          for (const node of graph.allNodes()) {
+            if (node.kind === kindMatch[1]) results.push(node);
+            if (results.length >= 50) break;
+          }
+          return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        return { content: [{ type: "text", text: "Query not recognized. Use name='X' or :kind syntax." }] };
+      }
+      // ── group_list ─────────────────────────────────────────────────────────
+      case "group_list": {
+        const groupName = a.name;
+        if (groupName) {
+          const group = loadGroup(groupName);
+          if (!group) return { content: [{ type: "text", text: `Group "${groupName}" not found.` }] };
+          return { content: [{ type: "text", text: JSON.stringify(group, null, 2) }] };
+        }
+        const groups = listGroups();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(
+              groups.map((g) => ({ name: g.name, createdAt: g.createdAt, lastSync: g.lastSync, memberCount: g.members.length, members: g.members })),
+              null,
+              2
+            )
+          }]
+        };
+      }
+      // ── group_sync ─────────────────────────────────────────────────────────
+      case "group_sync": {
+        const groupName = a.name;
+        const group = loadGroup(groupName);
+        if (!group) return { content: [{ type: "text", text: `Group "${groupName}" not found.` }] };
+        if (group.members.length === 0) return { content: [{ type: "text", text: `Group "${groupName}" has no members.` }] };
+        const result = await syncGroup(group);
+        saveSyncResult(result);
+        group.lastSync = result.syncedAt;
+        saveGroup(group);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              groupName: result.groupName,
+              syncedAt: result.syncedAt,
+              memberCount: result.memberCount,
+              contractCount: result.contracts.length,
+              linkCount: result.links.length,
+              topLinks: result.links.slice(0, 20)
+            }, null, 2)
+          }]
+        };
+      }
+      // ── group_contracts ────────────────────────────────────────────────────
+      case "group_contracts": {
+        const groupName = a.name;
+        const kindFilter = a.kind;
+        const repoFilter = a.repo;
+        const minConf = a.min_confidence ?? 0;
+        const result = loadSyncResult(groupName);
+        if (!result) return { content: [{ type: "text", text: `No sync data for group "${groupName}". Run group_sync first.` }] };
+        let contracts = result.contracts;
+        if (kindFilter) contracts = contracts.filter((c) => c.kind === kindFilter);
+        if (repoFilter) contracts = contracts.filter((c) => c.repoName === repoFilter);
+        let links = result.links.filter((l) => l.confidence >= minConf);
+        if (repoFilter) links = links.filter((l) => l.providerRepo === repoFilter || l.consumerRepo === repoFilter);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ syncedAt: result.syncedAt, contracts, links }, null, 2)
+          }]
+        };
+      }
+      // ── group_query ────────────────────────────────────────────────────────
+      case "group_query": {
+        const groupName = a.name;
+        const query = a.query;
+        const limit = a.limit ?? 10;
+        const group = loadGroup(groupName);
+        if (!group) return { content: [{ type: "text", text: `Group "${groupName}" not found.` }] };
+        const { perRepo, merged } = await queryGroup(group, query, limit);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ query, merged, perRepo }, null, 2)
+          }]
+        };
+      }
+      // ── group_status ───────────────────────────────────────────────────────
+      case "group_status": {
+        const groupName = a.name;
+        const group = loadGroup(groupName);
+        if (!group) return { content: [{ type: "text", text: `Group "${groupName}" not found.` }] };
+        const registry = loadRegistry();
+        const now = Date.now();
+        const memberStatus = group.members.map((m) => {
+          const regEntry = registry.find((r) => r.name === m.registryName);
+          if (!regEntry) return { groupPath: m.groupPath, registryName: m.registryName, status: "NOT_IN_REGISTRY" };
+          const meta = loadMetadata(regEntry.path);
+          if (!meta) return { groupPath: m.groupPath, registryName: m.registryName, repoPath: regEntry.path, status: "NOT_INDEXED" };
+          const ageMin = Math.round((now - new Date(meta.indexedAt).getTime()) / 6e4);
+          const stale = ageMin > 1440;
+          return {
+            groupPath: m.groupPath,
+            registryName: m.registryName,
+            repoPath: regEntry.path,
+            indexedAt: meta.indexedAt,
+            ageMinutes: ageMin,
+            status: stale ? "STALE" : "OK",
+            stats: meta.stats
+          };
+        });
+        const syncAge = group.lastSync ? Math.round((now - new Date(group.lastSync).getTime()) / 6e4) : null;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              group: groupName,
+              lastSync: group.lastSync ?? null,
+              syncAgeMinutes: syncAge,
+              members: memberStatus
+            }, null, 2)
+          }]
+        };
+      }
+      default:
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: [
+      { uri: `codeintel://repo/${repoName}/overview`, name: `${repoName} Overview`, mimeType: "application/json" },
+      { uri: `codeintel://repo/${repoName}/clusters`, name: `${repoName} Clusters`, mimeType: "application/json" },
+      { uri: `codeintel://repo/${repoName}/flows`, name: `${repoName} Flows`, mimeType: "application/json" }
+    ]
+  }));
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri.endsWith("/overview")) {
+      const kindCounts = {};
+      for (const node of graph.allNodes()) {
+        kindCounts[node.kind] = (kindCounts[node.kind] ?? 0) + 1;
+      }
+      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify({ repo: repoName, stats: graph.size, nodeCounts: kindCounts }) }] };
+    }
+    if (uri.endsWith("/clusters")) {
+      const clusters = [];
+      for (const node of graph.allNodes()) {
+        if (node.kind === "cluster") clusters.push({ id: node.id, name: node.name, memberCount: node.metadata?.memberCount });
+      }
+      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(clusters) }] };
+    }
+    if (uri.endsWith("/flows")) {
+      const flows = [];
+      for (const node of graph.allNodes()) {
+        if (node.kind === "flow") flows.push({ id: node.id, name: node.name, steps: node.metadata?.steps, entryPoint: node.metadata?.entryPoint });
+      }
+      return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(flows) }] };
+    }
+    throw new Error(`Unknown resource: ${uri}`);
+  });
+  return server;
+}
+async function startMcpStdio(graph, repoName, workspaceRoot) {
+  const server = createMcpServer(graph, repoName, workspaceRoot);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+function findNodeByName(graph, name) {
+  for (const node of graph.allNodes()) {
+    if (node.name === name) return node;
+  }
+  return void 0;
+}
+function parseDiff(diffText) {
+  const result = [];
+  let currentFile = null;
+  let currentNewLine = 0;
+  const changedLinesMap = /* @__PURE__ */ new Map();
+  for (const raw of diffText.split("\n")) {
+    const fileMatch = raw.match(/^\+\+\+ b\/(.+)/);
+    if (fileMatch) {
+      currentFile = fileMatch[1];
+      if (!changedLinesMap.has(currentFile)) changedLinesMap.set(currentFile, []);
+      continue;
+    }
+    const hunkMatch = raw.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunkMatch) {
+      currentNewLine = parseInt(hunkMatch[1], 10);
+      continue;
+    }
+    if (!currentFile) continue;
+    if (raw.startsWith("+") && !raw.startsWith("+++")) {
+      changedLinesMap.get(currentFile).push(currentNewLine);
+      currentNewLine++;
+    } else if (raw.startsWith("-") && !raw.startsWith("---")) ; else if (!raw.startsWith("\\")) {
+      currentNewLine++;
+    }
+  }
+  for (const [filePath, changedLines] of changedLinesMap) {
+    result.push({ filePath, changedLines });
+  }
+  return result;
+}
+
+// src/storage/graph-loader.ts
+async function loadGraphToDB(graph, dbManager) {
+  for (const table of ALL_NODE_TABLES) {
+    await dbManager.execute(getCreateNodeTableDDL(table));
+  }
+  const edgeDDLs = getCreateEdgeTableDDL();
+  for (const ddl of edgeDDLs) {
+    try {
+      await dbManager.execute(ddl);
+    } catch {
+    }
+  }
+  let nodeCount = 0;
+  for (const node of graph.allNodes()) {
+    const table = NODE_TABLE_MAP[node.kind];
+    const props = buildNodeProps(node);
+    try {
+      await dbManager.execute(`CREATE (:${table} ${props})`);
+      nodeCount++;
+    } catch {
+    }
+  }
+  let edgeCount = 0;
+  for (const edge of graph.allEdges()) {
+    const sourceNode = graph.getNode(edge.source);
+    const targetNode = graph.getNode(edge.target);
+    if (!sourceNode || !targetNode) continue;
+    const fromTable = NODE_TABLE_MAP[sourceNode.kind];
+    const toTable = NODE_TABLE_MAP[targetNode.kind];
+    try {
+      await dbManager.execute(
+        `MATCH (a:${fromTable} {id: '${escCypher(edge.source)}'}), (b:${toTable} {id: '${escCypher(edge.target)}'}) CREATE (a)-[:code_edges {kind: '${edge.kind}', weight: ${edge.weight ?? 1}, label: '${escCypher(edge.label ?? "")}'}]->(b)`
+      );
+      edgeCount++;
+    } catch {
+    }
+  }
+  return { nodeCount, edgeCount };
+}
+function buildNodeProps(node) {
+  const parts = [
+    `id: '${escCypher(node.id)}'`,
+    `name: '${escCypher(node.name)}'`,
+    `file_path: '${escCypher(node.filePath)}'`
+  ];
+  if (node.startLine !== void 0) parts.push(`start_line: ${node.startLine}`);
+  if (node.endLine !== void 0) parts.push(`end_line: ${node.endLine}`);
+  if (node.exported !== void 0) parts.push(`exported: ${node.exported}`);
+  if (node.content) parts.push(`content: '${escCypher(node.content.slice(0, 500))}'`);
+  if (node.metadata) parts.push(`metadata: '${escCypher(JSON.stringify(node.metadata))}'`);
+  return `{${parts.join(", ")}}`;
+}
+function escCypher(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
+}
+
+// src/http/app.ts
+init_group_registry();
+var __dirname$1 = path6.dirname(fileURLToPath(import.meta.url));
+var WEB_DIST = path6.resolve(__dirname$1, "..", "..", "..", "web", "dist");
+function createApp(graph, repoName, workspaceRoot) {
+  const app = express();
+  app.use(cors({ origin: true }));
+  app.use(express.json({ limit: "10mb" }));
+  let vectorIndex = null;
+  let vectorIndexBuilding = false;
+  let vectorIndexReady = false;
+  async function ensureVectorIndex() {
+    if (vectorIndexReady && vectorIndex) return vectorIndex;
+    if (!workspaceRoot || vectorIndexBuilding) return null;
+    vectorIndexBuilding = true;
+    try {
+      const { embedNodes: embedNodes2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+      const dbPath = getVectorDbPath(workspaceRoot);
+      const db = new DbManager(dbPath);
+      await db.init();
+      const idx = new VectorIndex(db);
+      await idx.init();
+      const alreadyBuilt = await idx.isBuilt();
+      if (!alreadyBuilt) {
+        logger_default.info("  [vector] Building embeddings\u2026");
+        const nodes = await embedNodes2(graph, {
+          onProgress: (done, total) => {
+            if (done % 50 === 0 || done === total) process.stdout.write(`\r  [vector] ${done}/${total}`);
+          }
+        });
+        logger_default.info("");
+        await idx.buildIndex(nodes);
+        logger_default.info(`  [vector] Index built: ${nodes.length} embeddings`);
+      } else {
+        logger_default.info("  [vector] Index already exists, skipping rebuild.");
+      }
+      vectorIndex = idx;
+      vectorIndexReady = true;
+      return idx;
+    } catch (err) {
+      logger_default.warn("  [vector] Index build failed:", err instanceof Error ? err.message : err);
+      return null;
+    } finally {
+      vectorIndexBuilding = false;
+    }
+  }
+  if (workspaceRoot) {
+    setImmediate(() => ensureVectorIndex().catch(() => {
+    }));
+  }
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok", nodes: graph.size.nodes, edges: graph.size.edges });
+  });
+  app.get("/api/repos", (_req, res) => {
+    const registry = loadRegistry();
+    if (registry.length === 0) {
+      res.json([{ name: repoName, path: workspaceRoot ?? "", nodes: graph.size.nodes, edges: graph.size.edges, indexedAt: null }]);
+      return;
+    }
+    res.json(registry.map((r) => ({
+      name: r.name,
+      path: r.path,
+      nodes: r.stats.nodes,
+      edges: r.stats.edges,
+      indexedAt: r.indexedAt,
+      active: r.path === workspaceRoot
+    })));
+  });
+  async function loadRepoGraph(requestedRepo) {
+    if (requestedRepo === repoName) return graph;
+    const registry = loadRegistry();
+    const entry = registry.find((r) => r.name === requestedRepo || r.path === requestedRepo);
+    if (!entry) return null;
+    const dbPath = path6.join(entry.path, ".code-intel", "graph.db");
+    if (!fs6.existsSync(dbPath)) return null;
+    const repoGraph = createKnowledgeGraph();
+    const db = new DbManager(dbPath);
+    try {
+      await db.init();
+      await loadGraphFromDB(repoGraph, db);
+      db.close();
+      return repoGraph;
+    } catch {
+      db.close();
+      return null;
+    }
+  }
+  app.get("/api/graph/:repo", async (req, res) => {
+    const requestedRepo = decodeURIComponent(req.params.repo);
+    const g = await loadRepoGraph(requestedRepo);
+    if (!g) {
+      res.status(404).json({ error: `Repo "${requestedRepo}" not found or not indexed. Run: code-intel analyze <path>` });
+      return;
+    }
+    const nodes = [...g.allNodes()];
+    const edges = [...g.allEdges()];
+    res.json({ nodes, edges });
+  });
+  async function getGraphForRepo(requestedRepo) {
+    if (!requestedRepo || requestedRepo === repoName) return graph;
+    const g = await loadRepoGraph(requestedRepo);
+    return g ?? graph;
+  }
+  app.post("/api/search", async (req, res) => {
+    const { query, limit, repo } = req.body;
+    const g = await getGraphForRepo(repo);
+    const results = textSearch(g, query, limit ?? 20);
+    res.json({ results });
+  });
+  app.post("/api/vector-search", async (req, res) => {
+    const { query, limit = 10 } = req.body;
+    if (!query) {
+      res.status(400).json({ error: "Missing query" });
+      return;
+    }
+    const idx = await ensureVectorIndex();
+    if (!idx) {
+      const results = textSearch(graph, query, limit);
+      res.json({ results, source: "text-fallback", vectorReady: false });
+      return;
+    }
+    try {
+      const { pipeline } = await import('@huggingface/transformers');
+      const embedder = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+      const out = await embedder(query, { pooling: "mean", normalize: true });
+      const queryEmbedding = Array.from(out.data);
+      const hits = await idx.search(queryEmbedding, limit);
+      const results = hits.map((h) => ({
+        nodeId: h.nodeId,
+        name: h.name,
+        kind: h.kind,
+        filePath: h.filePath,
+        score: h.score
+      }));
+      res.json({ results, source: "vector", vectorReady: true });
+    } catch (err) {
+      const results = textSearch(graph, query, limit);
+      res.json({ results, source: "text-fallback", vectorReady: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.get("/api/vector-status", (_req, res) => {
+    res.json({ ready: vectorIndexReady, building: vectorIndexBuilding });
+  });
+  app.post("/api/files/read", (req, res) => {
+    const { file_path } = req.body;
+    try {
+      const content = fs6.readFileSync(file_path, "utf-8");
+      res.json({ content });
+    } catch {
+      res.status(404).json({ error: "File not found" });
+    }
+  });
+  app.post("/api/grep", (req, res) => {
+    const { pattern, file_paths } = req.body;
+    const results = [];
+    try {
+      const regex = new RegExp(pattern, "gi");
+      const paths = file_paths ?? [];
+      if (paths.length === 0) {
+        for (const node of graph.allNodes()) {
+          if (node.kind === "file" && node.content) {
+            const lines = node.content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+              if (regex.test(lines[i])) {
+                results.push({ file: node.filePath, line: i + 1, text: lines[i].trim() });
+              }
+              regex.lastIndex = 0;
+            }
+          }
+        }
+      }
+      res.json({ results: results.slice(0, 100) });
+    } catch {
+      res.status(400).json({ error: "Invalid regex pattern" });
+    }
+  });
+  app.post("/api/cypher", async (req, res) => {
+    const { query: q } = req.body;
+    if (!q) {
+      res.status(400).json({ error: "Missing query" });
+      return;
+    }
+    if (workspaceRoot) {
+      try {
+        const dbPath = getDbPath(workspaceRoot);
+        const dbm = new DbManager(dbPath);
+        await dbm.init();
+        const rows = await dbm.query(q);
+        dbm.close();
+        res.json({ results: rows });
+        return;
+      } catch (err) {
+      }
+    }
+    try {
+      const nameMatch = q?.match(/name\s*=\s*['"]([^'"]+)['"]/i);
+      if (nameMatch) {
+        const name = nameMatch[1];
+        const results = [];
+        for (const node of graph.allNodes()) {
+          if (node.name === name) {
+            const incoming = [...graph.findEdgesTo(node.id)];
+            const outgoing = [...graph.findEdgesFrom(node.id)];
+            results.push({ node, incoming: incoming.length, outgoing: outgoing.length });
+          }
+        }
+        res.json({ results });
+        return;
+      }
+      const kindMatch = q?.match(/:\s*(\w+)/);
+      if (kindMatch) {
+        const kind = kindMatch[1];
+        const results = [];
+        for (const node of graph.allNodes()) {
+          if (node.kind === kind) results.push(node);
+          if (results.length >= 50) break;
+        }
+        res.json({ results });
+        return;
+      }
+      res.json({ results: [], message: "Query not recognized." });
+    } catch {
+      res.status(400).json({ error: "Invalid query" });
+    }
+  });
+  app.get("/api/nodes/:id", async (req, res) => {
+    const nodeId = decodeURIComponent(req.params.id);
+    const g = await getGraphForRepo(req.query.repo);
+    const node = g.getNode(nodeId);
+    if (!node) {
+      res.status(404).json({ error: "Node not found" });
+      return;
+    }
+    const incoming = [...g.findEdgesTo(nodeId)];
+    const outgoing = [...g.findEdgesFrom(nodeId)];
+    res.json({
+      node,
+      callers: incoming.filter((e) => e.kind === "calls").map((e) => ({
+        id: e.source,
+        name: g.getNode(e.source)?.name,
+        weight: e.weight
+      })),
+      callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({
+        id: e.target,
+        name: g.getNode(e.target)?.name,
+        weight: e.weight
+      })),
+      imports: outgoing.filter((e) => e.kind === "imports").map((e) => ({
+        id: e.target,
+        name: g.getNode(e.target)?.name
+      })),
+      importedBy: incoming.filter((e) => e.kind === "imports").map((e) => ({
+        id: e.source,
+        name: g.getNode(e.source)?.name
+      })),
+      extends: outgoing.filter((e) => e.kind === "extends").map((e) => ({
+        id: e.target,
+        name: g.getNode(e.target)?.name
+      })),
+      implementsEdges: outgoing.filter((e) => e.kind === "implements").map((e) => ({
+        id: e.target,
+        name: g.getNode(e.target)?.name
+      })),
+      members: outgoing.filter((e) => e.kind === "has_member").map((e) => ({
+        id: e.target,
+        name: g.getNode(e.target)?.name,
+        kind: g.getNode(e.target)?.kind
+      })),
+      cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => g.getNode(e.target)?.name)[0]
+    });
+  });
+  app.post("/api/blast-radius", async (req, res) => {
+    const { target, direction = "both", max_hops = 5, repo } = req.body;
+    const g = await getGraphForRepo(repo);
+    let targetNode = null;
+    for (const node of g.allNodes()) {
+      if (node.name === target || node.id === target) {
+        targetNode = node;
+        break;
+      }
+    }
+    if (!targetNode) {
+      res.status(404).json({ error: `Symbol "${target}" not found` });
+      return;
+    }
+    const affected = /* @__PURE__ */ new Map();
+    const queue = [{ id: targetNode.id, depth: 0 }];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const { id, depth } = queue.shift();
+      if (visited.has(id) || depth > max_hops) continue;
+      visited.add(id);
+      const node = g.getNode(id);
+      if (node) affected.set(id, { name: node.name, kind: node.kind, depth });
+      if (direction === "callers" || direction === "both") {
+        for (const edge of g.findEdgesTo(id)) {
+          if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.source, depth: depth + 1 });
+        }
+      }
+      if (direction === "callees" || direction === "both") {
+        for (const edge of g.findEdgesFrom(id)) {
+          if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.target, depth: depth + 1 });
+        }
+      }
+    }
+    res.json({
+      target: targetNode.name,
+      affectedCount: [...affected.values()].filter((a) => a.depth > 0).length,
+      affected: [...affected.entries()].map(([id, info]) => ({ id, ...info })).filter((a) => a.depth > 0)
+    });
+  });
+  app.get("/api/flows", async (req, res) => {
+    const g = await getGraphForRepo(req.query.repo);
+    const flows = [];
+    for (const node of g.allNodes()) {
+      if (node.kind === "flow") flows.push({ id: node.id, name: node.name, steps: node.metadata?.steps });
+    }
+    res.json({ flows });
+  });
+  app.get("/api/clusters", async (req, res) => {
+    const g = await getGraphForRepo(req.query.repo);
+    const clusters = [];
+    for (const node of g.allNodes()) {
+      if (node.kind === "cluster") {
+        clusters.push({ id: node.id, name: node.name, memberCount: node.metadata?.memberCount ?? 0 });
+      }
+    }
+    res.json({ clusters });
+  });
+  app.get("/api/groups", (_req, res) => {
+    const groups = listGroups();
+    res.json(groups.map((g) => ({
+      name: g.name,
+      memberCount: g.members.length,
+      lastSync: g.lastSync ?? null,
+      createdAt: g.createdAt
+    })));
+  });
+  app.get("/api/groups/:name", (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    res.json(group);
+  });
+  app.get("/api/groups/:name/contracts", (req, res) => {
+    const result = loadSyncResult(req.params.name);
+    if (!result) {
+      res.status(404).json({ error: "No sync result. Run sync first." });
+      return;
+    }
+    res.json(result);
+  });
+  app.post("/api/groups/:name/sync", async (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    try {
+      const result = await syncGroup(group);
+      saveSyncResult(result);
+      group.lastSync = result.syncedAt;
+      const { saveGroup: saveGroup2 } = await Promise.resolve().then(() => (init_group_registry(), group_registry_exports));
+      saveGroup2(group);
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.post("/api/groups/:name/search", async (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    const { q, limit = 20 } = req.body;
+    if (!q) {
+      res.status(400).json({ error: "Missing query q" });
+      return;
+    }
+    try {
+      const { perRepo, merged } = await queryGroup(group, q, limit);
+      res.json({ perRepo, merged });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  app.get("/api/groups/:name/graph", async (req, res) => {
+    const group = loadGroup(req.params.name);
+    if (!group) {
+      res.status(404).json({ error: "Group not found" });
+      return;
+    }
+    const registry = loadRegistry();
+    const mergedGraph = createKnowledgeGraph();
+    for (const member of group.members) {
+      const regEntry = registry.find((r) => r.name === member.registryName);
+      if (!regEntry) continue;
+      const dbPath = path6.join(regEntry.path, ".code-intel", "graph.db");
+      if (!fs6.existsSync(dbPath)) continue;
+      const db = new DbManager(dbPath);
+      try {
+        await db.init();
+        await loadGraphFromDB(mergedGraph, db);
+        db.close();
+      } catch {
+        db.close();
+      }
+    }
+    res.json({ nodes: [...mergedGraph.allNodes()], edges: [...mergedGraph.allEdges()] });
+  });
+  if (fs6.existsSync(WEB_DIST)) {
+    app.use(express.static(WEB_DIST));
+    app.get("/{*path}", (_req, res) => {
+      res.sendFile(path6.join(WEB_DIST, "index.html"));
+    });
+  }
+  return app;
+}
+function startHttpServer(graph, repoName, port = 4747, workspaceRoot) {
+  const app = createApp(graph, repoName, workspaceRoot);
+  app.listen(port, () => {
+    logger_default.info(`Code Intelligence server running at http://localhost:${port}`);
+    logger_default.info(`  Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`);
+  });
+}
+
+// src/multi-repo/index.ts
+init_group_registry();
+
+// src/multi-repo/cross-repo-search.ts
+function mergeSearchResults(...perRepoResults) {
+  return reciprocalRankFusion(...perRepoResults);
+}
+
+export { AstCache, BindingTracker, DbManager, addBinding, addClustersToGraph, addMember, buildCallEdges, buildHeritageEdges, classifyCall, clusterPhase, computeMRO, createApp, createKnowledgeGraph, createMcpServer, createScope, deleteGroup, detectCommunities, detectOverrides, findEntryPoints, flowPhase, generateEdgeId, generateNodeId, getAllLanguageModules, getDbPath, getLanguage, getLanguageModule, getParser, groupExists, initParser, listGroups, loadGraphToDB, loadGroup, loadMetadata, loadRegistry, loadSyncResult, mergeSearchResults, parsePhase, parseSource, queryGroup, reciprocalRankFusion, removeMember, removeRepo, resolveBinding, resolveImports, resolvePhase, runPipeline, runQuery, saveGroup, saveMetadata, saveSyncResult, scanPhase, startHttpServer, startMcpStdio, structurePhase, syncGroup, textSearch, topologicalSort, traceFlow, upsertRepo, validateDAG };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map