@vohongtho.infotech/code-intel 0.1.4 → 0.1.5

package/dist/index.js

@@ -1,14 +1,17 @@
-import fs8 from 'fs';
+import fs6 from 'fs';
 import path6 from 'path';
-import os2 from 'os';
+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';
-import { Database, Connection } from '@ladybugdb/core';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -86,23 +89,23 @@ function groupFile(name) {
 }
 function loadGroup(name) {
   try {
-    return JSON.parse(fs8.readFileSync(groupFile(name), "utf-8"));
+    return JSON.parse(fs6.readFileSync(groupFile(name), "utf-8"));
   } catch {
     return null;
   }
 }
 function saveGroup(group) {
-  fs8.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs8.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+  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 fs8.readdirSync(GROUPS_DIR)) {
+    for (const file of fs6.readdirSync(GROUPS_DIR)) {
       if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
       try {
         const g = JSON.parse(
-          fs8.readFileSync(path6.join(GROUPS_DIR, file), "utf-8")
+          fs6.readFileSync(path6.join(GROUPS_DIR, file), "utf-8")
         );
         groups.push(g);
       } catch {
@@ -114,16 +117,16 @@ function listGroups() {
 }
 function deleteGroup(name) {
   try {
-    fs8.unlinkSync(groupFile(name));
+    fs6.unlinkSync(groupFile(name));
   } catch {
   }
   try {
-    fs8.unlinkSync(path6.join(GROUPS_DIR, `${name}.sync.json`));
+    fs6.unlinkSync(path6.join(GROUPS_DIR, `${name}.sync.json`));
   } catch {
   }
 }
 function groupExists(name) {
-  return fs8.existsSync(groupFile(name));
+  return fs6.existsSync(groupFile(name));
 }
 function addMember(groupName, member) {
   const group = loadGroup(groupName);
@@ -149,8 +152,8 @@ function removeMember(groupName, groupPath) {
   return group;
 }
 function saveSyncResult(result) {
-  fs8.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs8.writeFileSync(
+  fs6.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs6.writeFileSync(
     path6.join(GROUPS_DIR, `${result.groupName}.sync.json`),
     JSON.stringify(result, null, 2) + "\n"
   );
@@ -158,7 +161,7 @@ function saveSyncResult(result) {
 function loadSyncResult(groupName) {
   try {
     return JSON.parse(
-      fs8.readFileSync(path6.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+      fs6.readFileSync(path6.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
     );
   } catch {
     return null;
@@ -167,7 +170,7 @@ function loadSyncResult(groupName) {
 var GROUPS_DIR;
 var init_group_registry = __esm({
   "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path6.join(os2.homedir(), ".code-intel", "groups");
+    GROUPS_DIR = path6.join(os3.homedir(), ".code-intel", "groups");
   }
 });
 
@@ -1664,25 +1667,25 @@ function validateDAG(phases) {
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const phaseMap = new Map(phases.map((p) => [p.name, p]));
-  function dfs(name, path17) {
+  function dfs(name, path19) {
     if (visiting.has(name)) {
-      const cycleStart = path17.indexOf(name);
-      const cycle = path17.slice(cycleStart).concat(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);
-    path17.push(name);
+    path19.push(name);
     const phase = phaseMap.get(name);
     if (phase) {
       for (const dep of phase.dependencies) {
-        if (dfs(dep, path17)) return true;
+        if (dfs(dep, path19)) return true;
       }
     }
     visiting.delete(name);
     visited.add(name);
-    path17.pop();
+    path19.pop();
     return false;
   }
   for (const phase of phases) {
@@ -1790,11 +1793,18 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".cache",
   "tmp",
   "temp",
-  ".parcel-cache"
+  ".parcel-cache",
+  ".venv",
+  "venv",
+  ".env",
+  "env",
+  "__snapshots__",
+  ".nyc_output",
+  "storybook-static"
 ]);
 function loadIgnorePatterns(workspaceRoot) {
   try {
-    const raw = fs8.readFileSync(path6.join(workspaceRoot, ".codeintelignore"), "utf-8");
+    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();
@@ -1805,6 +1815,8 @@ function loadIgnorePatterns(workspaceRoot) {
     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: [],
@@ -1816,29 +1828,35 @@ var scanPhase = {
     function walk(dir) {
       let entries;
       try {
-        entries = fs8.readdirSync(dir, { withFileTypes: true });
+        entries = fs6.readdirSync(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const entry of entries) {
-        if (entry.name.startsWith(".") && entry.isDirectory()) continue;
-        if (IGNORED_DIRS.has(entry.name) && entry.isDirectory()) continue;
-        if (extraIgnore.has(entry.name) && entry.isDirectory()) continue;
-        const fullPath = path6.join(dir, entry.name);
         if (entry.isDirectory()) {
-          walk(fullPath);
+          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 ext = path6.extname(entry.name);
-          const fullName = entry.name;
-          if (fullName.endsWith(".d.ts") || fullName.endsWith(".js.map") || fullName.endsWith(".d.ts.map")) continue;
-          if (extensions.has(ext)) {
-            filePaths.push(fullPath);
+          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,
@@ -1852,6 +1870,7 @@ var structurePhase = {
   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);
@@ -1868,6 +1887,8 @@ var structurePhase = {
         dirs.add(dir);
         dir = path6.dirname(dir);
       }
+      structDone++;
+      context.onPhaseProgress?.("structure", structDone, context.filePaths.length);
     }
     for (const dir of dirs) {
       context.graph.addNode({
@@ -1884,29 +1905,266 @@ var structurePhase = {
     };
   }
 };
+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;
-    for (const filePath of context.filePaths) {
+    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);
-          console.log(`  [parse] skipped (no parser): ${relativePath2}`);
+          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);
-      let source;
-      try {
-        source = fs8.readFileSync(filePath, "utf-8");
-      } catch {
-        continue;
-      }
       const fileNode = context.graph.getNode(fileNodeId);
       if (fileNode) {
         fileNode.content = source.slice(0, 2e3);
@@ -1921,15 +2179,18 @@ var parsePhase = {
         if (trimmed.startsWith("//") || trimmed.startsWith("#") || trimmed.startsWith("*") || trimmed.startsWith("/*")) continue;
         const extracted = extractSymbol(trimmed, lang);
         if (!extracted) continue;
-        if (seen.has(extracted.name + ":" + extracted.kind)) continue;
-        seen.add(extracted.name + ":" + extracted.kind);
+        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)
         });
@@ -1956,11 +2217,17 @@ var parsePhase = {
       }
       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`
+      message: `Extracted ${symbolCount} symbols from ${filePaths.length} files`
     };
   }
 };
@@ -1984,12 +2251,6 @@ function extractSymbol(line, lang, _lineNum, _filePath) {
     if (constVar && /^[A-Z_]+$/.test(constVar[1])) {
       return { kind: "constant", name: constVar[1], exported: line.includes("export") };
     }
-    const method = line.match(/^(?:(?:public|private|protected|static|async|readonly)\s+)*(\w+)\s*\(/);
-    if (method && !["if", "for", "while", "switch", "catch", "return", "constructor"].includes(method[1])) {
-      if (method[1] === "constructor") {
-        return { kind: "constructor", name: "constructor", exported: false };
-      }
-    }
   }
   if (lang === "python" /* Python */) {
     const func = line.match(/^(?:async\s+)?def\s+(\w+)/);
@@ -2101,16 +2362,73 @@ function extractSymbol(line, lang, _lineNum, _filePath) {
   }
   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;
@@ -2126,7 +2444,18 @@ var resolvePhase = {
     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)) {
+      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) {
@@ -2136,17 +2465,14 @@ var resolvePhase = {
         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);
-      let source;
-      try {
-        source = fs8.readFileSync(filePath, "utf-8");
-      } catch {
-        continue;
-      }
+      const source = fileCache.get(filePath);
+      if (!source) continue;
       const lines = source.split("\n");
       const imports = extractImports(lines, lang === "python");
       const calls = extractCalls(lines);
@@ -2173,11 +2499,13 @@ var resolvePhase = {
               break;
             }
           }
-          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 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;
+              }
             }
           }
         }
@@ -2200,6 +2528,7 @@ var resolvePhase = {
         }
       }
       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;
@@ -2208,7 +2537,7 @@ var resolvePhase = {
           confidence = 0.5;
         }
         if (targetId) {
-          const callerNodeId = findEnclosingFunction(graph, relativePath, call.line);
+          const callerNodeId = funcList ? findEnclosingFunctionFast(funcList, call.line) : null;
           const sourceId = callerNodeId ?? fileNodeId;
           if (sourceId !== targetId) {
             const edgeId = generateEdgeId(sourceId, targetId, "calls");
@@ -2264,6 +2593,8 @@ var resolvePhase = {
           }
         }
       }
+      fileDone++;
+      context.onPhaseProgress?.("resolve", fileDone, filePaths.length);
     }
     return {
       status: "completed",
@@ -2281,18 +2612,13 @@ function extractImports(lines, isPython) {
       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));
+        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
-      });
+      if (defaultMatch && defaultMatch[1] !== "type") names.push(defaultMatch[1]);
+      imports.push({ rawPath: tsImport[1], localNames: names, isDefault: !namedMatch, line: i + 1 });
       continue;
     }
     if (isPython) {
@@ -2316,64 +2642,34 @@ function extractImports(lines, isPython) {
     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
-      });
+      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
-      });
+      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
-      });
+      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
-      });
+      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
-      });
+      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
-      });
+      imports.push({ rawPath: requireMatch[1], localNames: [], isDefault: false, line: i + 1 });
     }
   }
   return imports;
@@ -2394,19 +2690,14 @@ function extractCalls(lines) {
     callRegex.lastIndex = 0;
     while ((match = callRegex.exec(line)) !== null) {
       const name = match[1];
-      if (["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"].includes(name)) continue;
+      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
-      });
+      calls.push({ name: match[2], receiverText: match[1], isNew: false, line: i + 1 });
     }
   }
   return calls;
@@ -2429,19 +2720,23 @@ function extractHeritage(lines) {
   }
   return heritages;
 }
-function findEnclosingFunction(graph, filePath, line) {
+function findEnclosingFunctionFast(funcs, line) {
+  let lo = 0;
+  let hi = funcs.length - 1;
   let best = null;
-  for (const node of graph.allNodes()) {
-    if (node.filePath !== filePath) continue;
-    if (!["function", "method"].includes(node.kind)) continue;
-    if (!node.startLine) continue;
-    if (node.startLine <= line) {
-      if (!best || node.startLine > best.startLine) {
-        best = { id: node.id, startLine: node.startLine };
+  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?.id ?? null;
+  return best;
 }
 
 // src/pipeline/phases/cluster-phase.ts
@@ -2464,7 +2759,11 @@ var clusterPhase = {
       group.push({ id: node.id, name: node.name });
     }
     let clusterCount = 0;
-    for (const [dir, members] of nodesByDir) {
+    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}`;
@@ -2525,27 +2824,30 @@ var flowPhase = {
     const maxDepth = 10;
     const maxBranching = 4;
     let flowCount = 0;
-    for (const ep of entryPoints.slice(0, 20)) {
+    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: path17 } = queue.shift();
-        if (path17.length > maxDepth) continue;
+        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 && path17.length >= 3) {
+        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: path17, entryPoint: ep.name }
+            metadata: { steps: path19, entryPoint: ep.name }
           });
-          for (let i = 0; i < path17.length; i++) {
+          for (let i = 0; i < path19.length; i++) {
             graph.addEdge({
-              id: generateEdgeId(path17[i], flowId, `step_of_${i}`),
-              source: path17[i],
+              id: generateEdgeId(path19[i], flowId, `step_of_${i}`),
+              source: path19[i],
               target: flowId,
               kind: "step_of",
               weight: 1,
@@ -2558,7 +2860,7 @@ var flowPhase = {
         for (const edge of callEdges) {
           if (visited.has(edge.target)) continue;
           visited.add(edge.target);
-          queue.push({ nodeId: edge.target, path: [...path17, edge.target] });
+          queue.push({ nodeId: edge.target, path: [...path19, edge.target] });
         }
       }
     }
@@ -2687,17 +2989,17 @@ function traceFlow(entryId, graph, maxDepth = 10, maxBranching = 4) {
     const queue = [{ nodeId: entryId, path: [entryId] }];
     const visited = /* @__PURE__ */ new Set();
     while (queue.length > 0 && flows.length < maxFlows) {
-      const { nodeId, path: path17 } = queue.shift();
-      if (path17.length > maxDepth) continue;
+      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 && path17.length >= 3) {
-        flows.push({ entryPointId: entryId, steps: [...path17] });
+      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: [...path17, edge.target] });
+        queue.push({ nodeId: edge.target, path: [...path19, edge.target] });
       }
     }
   }
@@ -2858,226 +3160,65 @@ var VectorIndex = class {
 function esc(s) {
   return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
 }
-function createMcpServer(graph, repoName) {
-  const server = new Server(
-    { name: "code-intel", version: "0.1.0" },
-    { capabilities: { tools: {}, resources: {} } }
-  );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-      {
-        name: "repos",
-        description: "List indexed repositories",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "search",
-        description: "Hybrid search across the codebase knowledge graph",
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: { type: "string", description: "Search query" },
-            limit: { type: "number", description: "Max results (default 20)" }
-          },
-          required: ["query"]
-        }
-      },
-      {
-        name: "inspect",
-        description: "360\xB0 view of a symbol: definition, callers, callees, heritage, references",
-        inputSchema: {
-          type: "object",
-          properties: {
-            symbol_name: { type: "string", description: "Symbol name to inspect" }
-          },
-          required: ["symbol_name"]
-        }
-      },
-      {
-        name: "blast_radius",
-        description: "Impact analysis: what depends on / is affected by this symbol",
-        inputSchema: {
-          type: "object",
-          properties: {
-            target: { type: "string", description: "Target symbol name" },
-            direction: { type: "string", enum: ["callers", "callees", "both"], description: "Direction to trace" },
-            max_hops: { type: "number", description: "Max hops (default 5)" }
-          },
-          required: ["target"]
-        }
-      },
-      {
-        name: "routes",
-        description: "List route handler mappings in the codebase",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
-        name: "raw_query",
-        description: "Execute a graph query (simplified Cypher-like)",
-        inputSchema: {
-          type: "object",
-          properties: {
-            cypher: { type: "string", description: "Query string (name='X' or :kind patterns)" }
-          },
-          required: ["cypher"]
-        }
-      }
-    ]
-  }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    const a = args ?? {};
-    switch (name) {
-      case "repos": {
-        return { content: [{ type: "text", text: JSON.stringify([{ name: repoName, nodes: graph.size.nodes, edges: graph.size.edges }], null, 2) }] };
-      }
-      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) }] };
-      }
-      case "inspect": {
-        const symbolName = a.symbol_name;
-        const node = findNodeByName(graph, symbolName);
-        if (!node) return { content: [{ type: "text", text: `Symbol "${symbolName}" not found` }] };
-        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 })),
-              callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({ id: e.target, name: 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)
-          }]
-        };
-      }
-      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 };
-        });
-        return { content: [{ type: "text", text: JSON.stringify({ target: node.name, affectedCount: affected.size, affected: affectedDetails }, null, 2) }] };
-      }
-      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 });
-          }
-        }
-        return { content: [{ type: "text", text: JSON.stringify(routes, null, 2) }] };
-      }
-      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" }] };
-      }
-      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) {
-  const server = createMcpServer(graph, repoName);
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-function findNodeByName(graph, name) {
-  for (const node of graph.allNodes()) {
-    if (node.name === name) return node;
+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 [];
   }
-  return void 0;
 }
-var DbManager = class {
-  db = null;
-  conn = null;
+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() {
-    fs8.mkdirSync(path6.dirname(this.dbPath), { recursive: true });
+    fs6.mkdirSync(path6.dirname(this.dbPath), { recursive: true });
     this.db = new Database(this.dbPath);
     await this.db.init();
     this.conn = new Connection(this.db);
@@ -3168,112 +3309,6 @@ function getCreateEdgeTableDDL() {
   return ddls;
 }
 
-// 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, "");
-}
-var GLOBAL_DIR = path6.join(os2.homedir(), ".code-intel");
-var REPOS_FILE = path6.join(GLOBAL_DIR, "repos.json");
-function loadRegistry() {
-  try {
-    const data = fs8.readFileSync(REPOS_FILE, "utf-8");
-    return JSON.parse(data);
-  } catch {
-    return [];
-  }
-}
-function saveRegistry(entries) {
-  fs8.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs8.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");
-  fs8.mkdirSync(metaDir, { recursive: true });
-  fs8.writeFileSync(path6.join(metaDir, "meta.json"), JSON.stringify(metadata, null, 2));
-}
-function loadMetadata(repoDir) {
-  try {
-    const data = fs8.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/http/app.ts
-init_group_registry();
-
 // src/multi-repo/graph-from-db.ts
 var TABLE_TO_KIND = Object.fromEntries(
   Object.entries(NODE_TABLE_MAP).map(([kind, table]) => [table, kind])
@@ -3463,12 +3498,12 @@ async function syncGroup(group) {
   for (const member of group.members) {
     const regEntry = registry.find((r) => r.name === member.registryName);
     if (!regEntry) {
-      console.warn(`  \u26A0 Registry entry "${member.registryName}" not found \u2014 skipping ${member.groupPath}`);
+      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 (!fs8.existsSync(dbPath)) {
-      console.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
+    if (!fs6.existsSync(dbPath)) {
+      logger_default.warn(`  \u26A0 No index at ${dbPath} \u2014 run \`code-intel analyze ${regEntry.path}\` first`);
       continue;
     }
     const graph = createKnowledgeGraph();
@@ -3479,11 +3514,11 @@ async function syncGroup(group) {
       db.close();
     } catch (err) {
       db.close();
-      console.warn(`  \u26A0 Could not load graph for "${member.registryName}": ${err instanceof Error ? err.message : err}`);
+      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);
-    console.log(`  \u2713 ${member.registryName} (${member.groupPath}): ${contracts.length} contracts`);
+    logger_default.info(`  \u2713 ${member.registryName} (${member.groupPath}): ${contracts.length} contracts`);
     allContracts.push(...contracts);
   }
   const links = matchContracts(allContracts);
@@ -3503,7 +3538,7 @@ async function queryGroup(group, query, limit = 20) {
     const regEntry = registry.find((r) => r.name === member.registryName);
     if (!regEntry) continue;
     const dbPath = path6.join(regEntry.path, ".code-intel", "graph.db");
-    if (!fs8.existsSync(dbPath)) continue;
+    if (!fs6.existsSync(dbPath)) continue;
     const graph = createKnowledgeGraph();
     const db = new DbManager(dbPath);
     try {
@@ -3530,80 +3565,949 @@ async function queryGroup(group, query, limit = 20) {
   const merged = reciprocalRankFusion(...allRankings).slice(0, limit);
   return { perRepo, merged };
 }
-
-// src/http/app.ts
-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) {
-        console.log("  [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}`);
+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)" }
           }
-        });
-        console.log("");
-        await idx.buildIndex(nodes);
-        console.log(`  [vector] Index built: ${nodes.length} embeddings`);
-      } else {
-        console.log("  [vector] Index already exists, skipping rebuild.");
-      }
-      vectorIndex = idx;
-      vectorIndexReady = true;
-      return idx;
-    } catch (err) {
-      console.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) => {
-    res.json([{ name: repoName, nodes: graph.size.nodes, edges: graph.size.edges }]);
-  });
-  app.get("/api/graph/:repo", (_req, res) => {
-    const nodes = [...graph.allNodes()];
-    const edges = [...graph.allEdges()];
-    res.json({ nodes, edges });
-  });
-  app.post("/api/search", (req, res) => {
-    const { query, limit } = req.body;
-    const results = textSearch(graph, 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) {
+        }
+      },
+      // ── 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;
@@ -3633,7 +4537,7 @@ function createApp(graph, repoName, workspaceRoot) {
   app.post("/api/files/read", (req, res) => {
     const { file_path } = req.body;
     try {
-      const content = fs8.readFileSync(file_path, "utf-8");
+      const content = fs6.readFileSync(file_path, "utf-8");
       res.json({ content });
     } catch {
       res.status(404).json({ error: "File not found" });
@@ -3712,55 +4616,57 @@ function createApp(graph, repoName, workspaceRoot) {
       res.status(400).json({ error: "Invalid query" });
     }
   });
-  app.get("/api/nodes/:id", (req, res) => {
+  app.get("/api/nodes/:id", async (req, res) => {
     const nodeId = decodeURIComponent(req.params.id);
-    const node = graph.getNode(nodeId);
+    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 = [...graph.findEdgesTo(nodeId)];
-    const outgoing = [...graph.findEdgesFrom(nodeId)];
+    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: graph.getNode(e.source)?.name,
+        name: g.getNode(e.source)?.name,
         weight: e.weight
       })),
       callees: outgoing.filter((e) => e.kind === "calls").map((e) => ({
         id: e.target,
-        name: graph.getNode(e.target)?.name,
+        name: g.getNode(e.target)?.name,
         weight: e.weight
       })),
       imports: outgoing.filter((e) => e.kind === "imports").map((e) => ({
         id: e.target,
-        name: graph.getNode(e.target)?.name
+        name: g.getNode(e.target)?.name
       })),
       importedBy: incoming.filter((e) => e.kind === "imports").map((e) => ({
         id: e.source,
-        name: graph.getNode(e.source)?.name
+        name: g.getNode(e.source)?.name
       })),
       extends: outgoing.filter((e) => e.kind === "extends").map((e) => ({
         id: e.target,
-        name: graph.getNode(e.target)?.name
+        name: g.getNode(e.target)?.name
       })),
       implementsEdges: outgoing.filter((e) => e.kind === "implements").map((e) => ({
         id: e.target,
-        name: graph.getNode(e.target)?.name
+        name: g.getNode(e.target)?.name
       })),
       members: outgoing.filter((e) => e.kind === "has_member").map((e) => ({
         id: e.target,
-        name: graph.getNode(e.target)?.name,
-        kind: graph.getNode(e.target)?.kind
+        name: g.getNode(e.target)?.name,
+        kind: g.getNode(e.target)?.kind
       })),
-      cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => graph.getNode(e.target)?.name)[0]
+      cluster: incoming.filter((e) => e.kind === "belongs_to").map((e) => g.getNode(e.target)?.name)[0]
     });
   });
-  app.post("/api/blast-radius", (req, res) => {
-    const { target, direction = "both", max_hops = 5 } = req.body;
+  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 graph.allNodes()) {
+    for (const node of g.allNodes()) {
       if (node.name === target || node.id === target) {
         targetNode = node;
         break;
@@ -3777,22 +4683,16 @@ function createApp(graph, repoName, workspaceRoot) {
       const { id, depth } = queue.shift();
       if (visited.has(id) || depth > max_hops) continue;
       visited.add(id);
-      const node = graph.getNode(id);
-      if (node) {
-        affected.set(id, { name: node.name, kind: node.kind, depth });
-      }
+      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 graph.findEdgesTo(id)) {
-          if (edge.kind === "calls" || edge.kind === "imports") {
-            queue.push({ id: edge.source, depth: depth + 1 });
-          }
+        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 graph.findEdgesFrom(id)) {
-          if (edge.kind === "calls" || edge.kind === "imports") {
-            queue.push({ id: edge.target, depth: depth + 1 });
-          }
+        for (const edge of g.findEdgesFrom(id)) {
+          if (edge.kind === "calls" || edge.kind === "imports") queue.push({ id: edge.target, depth: depth + 1 });
         }
       }
     }
@@ -3802,28 +4702,20 @@ function createApp(graph, repoName, workspaceRoot) {
       affected: [...affected.entries()].map(([id, info]) => ({ id, ...info })).filter((a) => a.depth > 0)
     });
   });
-  app.get("/api/flows", (_req, res) => {
+  app.get("/api/flows", async (req, res) => {
+    const g = await getGraphForRepo(req.query.repo);
     const flows = [];
-    for (const node of graph.allNodes()) {
-      if (node.kind === "flow") {
-        flows.push({
-          id: node.id,
-          name: node.name,
-          steps: node.metadata?.steps
-        });
-      }
+    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", (_req, res) => {
+  app.get("/api/clusters", async (req, res) => {
+    const g = await getGraphForRepo(req.query.repo);
     const clusters = [];
-    for (const node of graph.allNodes()) {
+    for (const node of g.allNodes()) {
       if (node.kind === "cluster") {
-        clusters.push({
-          id: node.id,
-          name: node.name,
-          memberCount: node.metadata?.memberCount ?? 0
-        });
+        clusters.push({ id: node.id, name: node.name, memberCount: node.metadata?.memberCount ?? 0 });
       }
     }
     res.json({ clusters });
@@ -3900,7 +4792,7 @@ function createApp(graph, repoName, workspaceRoot) {
       const regEntry = registry.find((r) => r.name === member.registryName);
       if (!regEntry) continue;
       const dbPath = path6.join(regEntry.path, ".code-intel", "graph.db");
-      if (!fs8.existsSync(dbPath)) continue;
+      if (!fs6.existsSync(dbPath)) continue;
       const db = new DbManager(dbPath);
       try {
         await db.init();
@@ -3912,7 +4804,7 @@ function createApp(graph, repoName, workspaceRoot) {
     }
     res.json({ nodes: [...mergedGraph.allNodes()], edges: [...mergedGraph.allEdges()] });
   });
-  if (fs8.existsSync(WEB_DIST)) {
+  if (fs6.existsSync(WEB_DIST)) {
     app.use(express.static(WEB_DIST));
     app.get("/{*path}", (_req, res) => {
       res.sendFile(path6.join(WEB_DIST, "index.html"));
@@ -3923,8 +4815,8 @@ function createApp(graph, repoName, workspaceRoot) {
 function startHttpServer(graph, repoName, port = 4747, workspaceRoot) {
   const app = createApp(graph, repoName, workspaceRoot);
   app.listen(port, () => {
-    console.log(`Code Intelligence server running at http://localhost:${port}`);
-    console.log(`  Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`);
+    logger_default.info(`Code Intelligence server running at http://localhost:${port}`);
+    logger_default.info(`  Graph: ${graph.size.nodes} nodes, ${graph.size.edges} edges`);
   });
 }