@vohongtho.infotech/code-intel 1.0.1 → 1.0.3

package/dist/index.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from 'url';
 import { Parser, Language, Query } from 'web-tree-sitter';
 import { Database, Connection } from '@ladybugdb/core';
 import { execSync } from 'child_process';
-import Database2 from 'better-sqlite3';
+import Database3 from 'better-sqlite3';
 import bcrypt from 'bcrypt';
 import crypto5 from 'crypto';
 import { v4 } from 'uuid';
@@ -198,6 +198,13 @@ var init_id_generator = __esm({
 });
 
 // src/storage/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  ALL_NODE_TABLES: () => ALL_NODE_TABLES,
+  NODE_TABLE_MAP: () => NODE_TABLE_MAP,
+  getCreateEdgeTableDDL: () => getCreateEdgeTableDDL,
+  getCreateNodeTableDDL: () => getCreateNodeTableDDL
+});
 function getCreateNodeTableDDL(tableName) {
   return `CREATE NODE TABLE IF NOT EXISTS ${tableName} (
   id STRING,
@@ -528,7 +535,7 @@ var init_logger = __esm({
           const isProduction = process.env.NODE_ENV === "production";
           const logLevel = process.env.LOG_LEVEL ?? "info";
           const transports = [];
-          transports.push(new winston.transports.Console());
+          transports.push(new winston.transports.Console({ stderrLevels: ["error", "warn", "info", "http", "verbose", "debug", "silly"] }));
           if (!isProduction) {
             try {
               if (!fs26.existsSync(_Logger.LOG_DIR)) {
@@ -2580,6 +2587,65 @@ var init_resolve_phase = __esm({
   }
 });
 
+// src/storage/db-manager.ts
+var db_manager_exports = {};
+__export(db_manager_exports, {
+  DbManager: () => DbManager
+});
+var DbManager;
+var init_db_manager = __esm({
+  "src/storage/db-manager.ts"() {
+    DbManager = class {
+      db = null;
+      conn = null;
+      dbPath;
+      readOnly;
+      constructor(dbPath, readOnly = false) {
+        this.dbPath = dbPath;
+        this.readOnly = readOnly;
+      }
+      async init() {
+        if (!this.readOnly) {
+          fs26.mkdirSync(path32.dirname(this.dbPath), { recursive: true });
+        }
+        this.db = new Database(this.dbPath, 0, true, this.readOnly);
+        await this.db.init();
+        this.conn = new Connection(this.db);
+        await this.conn.init();
+      }
+      async query(cypher) {
+        if (!this.conn) throw new Error("Database not initialized");
+        const result = await this.conn.query(cypher);
+        const qr = Array.isArray(result) ? result[0] : result;
+        const rows = await qr.getAll();
+        qr.close();
+        return rows;
+      }
+      async execute(cypher) {
+        if (!this.conn) throw new Error("Database not initialized");
+        const result = await this.conn.query(cypher);
+        const qr = Array.isArray(result) ? result[0] : result;
+        qr.close();
+      }
+      close() {
+        try {
+          this.conn?.closeSync();
+        } catch {
+        }
+        try {
+          this.db?.closeSync();
+        } catch {
+        }
+        this.conn = null;
+        this.db = null;
+      }
+      get isOpen() {
+        return this.conn !== null;
+      }
+    };
+  }
+});
+
 // src/llm/providers/openai.ts
 var openai_exports = {};
 __export(openai_exports, {
@@ -2590,18 +2656,42 @@ var init_openai = __esm({
   "src/llm/providers/openai.ts"() {
     OpenAIProvider = class {
       modelName;
-      constructor(model) {
+      endpoint;
+      apiKey;
+      constructor(model, baseUrl, apiKey) {
         this.modelName = model ?? "gpt-4o-mini";
+        this.endpoint = (baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "");
+        this.apiKey = apiKey ?? "";
+      }
+      resolvedKey() {
+        return this.apiKey || process.env["OPENAI_API_KEY"] || "";
+      }
+      async getContextWindow() {
+        try {
+          const res = await fetch(`${this.endpoint}/models/${encodeURIComponent(this.modelName)}`, {
+            headers: { "Authorization": `Bearer ${this.resolvedKey()}` },
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return void 0;
+          const json = await res.json();
+          return json.context_window;
+        } catch {
+          return void 0;
+        }
       }
       async summarize(prompt) {
         const { default: OpenAI } = await import('openai');
-        const client = new OpenAI({ apiKey: process.env["OPENAI_API_KEY"] });
+        const client = new OpenAI({ apiKey: this.resolvedKey(), baseURL: this.endpoint });
         const res = await client.chat.completions.create({
           model: this.modelName,
           messages: [{ role: "user", content: prompt }],
-          max_tokens: 200
+          max_tokens: 500
         });
-        return res.choices?.[0]?.message?.content?.trim() ?? "";
+        return {
+          text: res.choices?.[0]?.message?.content?.trim() ?? "",
+          promptTokens: res.usage?.prompt_tokens ?? 0,
+          completionTokens: res.usage?.completion_tokens ?? 0
+        };
       }
     };
   }
@@ -2612,24 +2702,138 @@ var anthropic_exports = {};
 __export(anthropic_exports, {
   AnthropicProvider: () => AnthropicProvider
 });
-var AnthropicProvider;
+var ANTHROPIC_CONTEXT, AnthropicProvider;
 var init_anthropic = __esm({
   "src/llm/providers/anthropic.ts"() {
+    ANTHROPIC_CONTEXT = {
+      "claude-3-5-sonnet-20241022": 2e5,
+      "claude-3-5-haiku-20241022": 2e5,
+      "claude-3-opus-20240229": 2e5,
+      "claude-3-sonnet-20240229": 2e5,
+      "claude-3-haiku-20240307": 2e5,
+      "claude-haiku-4-5": 2e5,
+      "claude-sonnet-4-5": 2e5,
+      "claude-opus-4-5": 2e5
+    };
     AnthropicProvider = class {
       modelName;
-      constructor(model) {
+      endpoint;
+      apiKey;
+      constructor(model, baseUrl, apiKey) {
         this.modelName = model ?? "claude-haiku-4-5";
+        this.endpoint = (baseUrl ?? "https://api.anthropic.com/v1").replace(/\/$/, "");
+        this.apiKey = apiKey ?? "";
+      }
+      resolvedKey() {
+        return this.apiKey || process.env["ANTHROPIC_API_KEY"] || "";
+      }
+      async getContextWindow() {
+        return ANTHROPIC_CONTEXT[this.modelName] ?? 2e5;
       }
       async summarize(prompt) {
         const Anthropic = (await import('@anthropic-ai/sdk')).default;
-        const client = new Anthropic({ apiKey: process.env["ANTHROPIC_API_KEY"] });
+        const client = new Anthropic({
+          apiKey: this.resolvedKey(),
+          baseURL: this.endpoint
+        });
         const res = await client.messages.create({
           model: this.modelName,
-          max_tokens: 200,
+          max_tokens: 500,
           messages: [{ role: "user", content: prompt }]
         });
         const block = res.content?.[0];
-        return block && block.type === "text" ? block.text.trim() : "";
+        return {
+          text: block && block.type === "text" ? block.text.trim() : "",
+          promptTokens: res.usage?.input_tokens ?? 0,
+          completionTokens: res.usage?.output_tokens ?? 0
+        };
+      }
+    };
+  }
+});
+
+// src/llm/providers/custom.ts
+var custom_exports = {};
+__export(custom_exports, {
+  CustomProvider: () => CustomProvider
+});
+var KNOWN_CONTEXT_WINDOWS, CustomProvider;
+var init_custom = __esm({
+  "src/llm/providers/custom.ts"() {
+    KNOWN_CONTEXT_WINDOWS = {
+      // DeepSeek
+      "deepseek-v4-flash": 64e3,
+      "deepseek-v4-pro": 64e3,
+      "deepseek-chat": 64e3,
+      "deepseek-coder": 16384,
+      "deepseek-v2": 128e3,
+      "deepseek-v3": 64e3,
+      // Groq
+      "llama3-8b-8192": 8192,
+      "llama3-70b-8192": 8192,
+      "mixtral-8x7b-32768": 32768,
+      "gemma-7b-it": 8192,
+      // Together AI
+      "mistralai/Mistral-7B-v0.1": 8192,
+      "meta-llama/Llama-3-8b-chat": 8192,
+      // LM Studio / vLLM defaults
+      "default": 4096
+    };
+    CustomProvider = class {
+      modelName;
+      endpoint;
+      baseUrl;
+      apiKey;
+      constructor(baseUrl, model, apiKey = "") {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.modelName = model;
+        this.apiKey = apiKey;
+        this.endpoint = this.baseUrl;
+      }
+      async getContextWindow() {
+        const modelsUrl = this.baseUrl.endsWith("/v1") ? `${this.baseUrl}/models` : `${this.baseUrl}/v1/models`;
+        try {
+          const res = await fetch(modelsUrl, {
+            headers: this.apiKey ? { "Authorization": `Bearer ${this.apiKey}` } : {},
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (res.ok) {
+            const json = await res.json();
+            const model = json.data?.find((m) => m.id === this.modelName);
+            if (model?.context_window) return model.context_window;
+          }
+        } catch {
+        }
+        return KNOWN_CONTEXT_WINDOWS[this.modelName];
+      }
+      async summarize(prompt) {
+        const base = this.baseUrl.endsWith("/v1") ? this.baseUrl : `${this.baseUrl}/v1`;
+        const url = `${base}/chat/completions`;
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (this.apiKey) {
+          headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const body = JSON.stringify({
+          model: this.modelName,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: 500,
+          temperature: 0.3
+        });
+        const res = await fetch(url, { method: "POST", headers, body });
+        if (!res.ok) {
+          const text2 = await res.text().catch(() => res.statusText);
+          throw new Error(`Custom LLM API error ${res.status}: ${text2}`);
+        }
+        const data = await res.json();
+        const msg = data.choices?.[0]?.message;
+        const text = (msg?.content?.trim() || msg?.reasoning_content?.trim()) ?? "";
+        return {
+          text,
+          promptTokens: data.usage?.prompt_tokens ?? 0,
+          completionTokens: data.usage?.completion_tokens ?? 0
+        };
       }
     };
   }
@@ -2645,10 +2849,31 @@ var init_ollama = __esm({
   "src/llm/providers/ollama.ts"() {
     OllamaProvider = class {
       modelName;
+      endpoint;
       baseUrl;
       constructor(model, baseUrl) {
         this.modelName = model ?? "llama3";
         this.baseUrl = baseUrl ?? "http://localhost:11434";
+        this.endpoint = this.baseUrl;
+      }
+      async getContextWindow() {
+        try {
+          const res = await fetch(`${this.baseUrl}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ model: this.modelName }),
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (!res.ok) return void 0;
+          const json = await res.json();
+          const info = json.model_info ?? {};
+          for (const [k, v] of Object.entries(info)) {
+            if (k.endsWith(".context_length") && typeof v === "number") return v;
+          }
+          return void 0;
+        } catch {
+          return void 0;
+        }
       }
       async summarize(prompt) {
         const url = `${this.baseUrl}/api/generate`;
@@ -2666,7 +2891,11 @@ var init_ollama = __esm({
           throw new Error(`Ollama request failed: ${res.status} ${res.statusText}`);
         }
         const json = await res.json();
-        return (json.response ?? "").trim();
+        return {
+          text: (json.response ?? "").trim(),
+          promptTokens: json.prompt_eval_count ?? 0,
+          completionTokens: json.eval_count ?? 0
+        };
       }
     };
   }
@@ -2678,20 +2907,27 @@ __export(factory_exports, {
   createLLMProvider: () => createLLMProvider
 });
 async function createLLMProvider(config = {}) {
-  const { provider = "ollama", model } = config;
+  const { provider = "ollama", model, baseUrl, apiKey } = config;
   switch (provider) {
     case "openai": {
       const { OpenAIProvider: OpenAIProvider2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
-      return new OpenAIProvider2(model);
+      return new OpenAIProvider2(model, baseUrl, apiKey);
     }
     case "anthropic": {
       const { AnthropicProvider: AnthropicProvider2 } = await Promise.resolve().then(() => (init_anthropic(), anthropic_exports));
-      return new AnthropicProvider2(model);
+      return new AnthropicProvider2(model, baseUrl, apiKey);
+    }
+    case "custom": {
+      const { CustomProvider: CustomProvider2 } = await Promise.resolve().then(() => (init_custom(), custom_exports));
+      const url = baseUrl ?? "http://localhost:1234/v1";
+      const mdl = model ?? "default";
+      const key = apiKey ?? "";
+      return new CustomProvider2(url, mdl, key);
     }
     case "ollama":
     default: {
       const { OllamaProvider: OllamaProvider2 } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
-      return new OllamaProvider2(model);
+      return new OllamaProvider2(model, baseUrl);
     }
   }
 }
@@ -2762,168 +2998,6 @@ var init_embedder = __esm({
   }
 });
 
-// src/storage/db-manager.ts
-var db_manager_exports = {};
-__export(db_manager_exports, {
-  DbManager: () => DbManager
-});
-var DbManager;
-var init_db_manager = __esm({
-  "src/storage/db-manager.ts"() {
-    DbManager = class {
-      db = null;
-      conn = null;
-      dbPath;
-      readOnly;
-      constructor(dbPath, readOnly = false) {
-        this.dbPath = dbPath;
-        this.readOnly = readOnly;
-      }
-      async init() {
-        if (!this.readOnly) {
-          fs26.mkdirSync(path32.dirname(this.dbPath), { recursive: true });
-        }
-        this.db = new Database(this.dbPath, 0, true, this.readOnly);
-        await this.db.init();
-        this.conn = new Connection(this.db);
-        await this.conn.init();
-      }
-      async query(cypher) {
-        if (!this.conn) throw new Error("Database not initialized");
-        const result = await this.conn.query(cypher);
-        const qr = Array.isArray(result) ? result[0] : result;
-        const rows = await qr.getAll();
-        qr.close();
-        return rows;
-      }
-      async execute(cypher) {
-        if (!this.conn) throw new Error("Database not initialized");
-        const result = await this.conn.query(cypher);
-        const qr = Array.isArray(result) ? result[0] : result;
-        qr.close();
-      }
-      close() {
-        try {
-          this.conn?.closeSync();
-        } catch {
-        }
-        try {
-          this.db?.closeSync();
-        } catch {
-        }
-        this.conn = null;
-        this.db = null;
-      }
-      get isOpen() {
-        return this.conn !== null;
-      }
-    };
-  }
-});
-
-// src/multi-repo/group-registry.ts
-var group_registry_exports = {};
-__export(group_registry_exports, {
-  addMember: () => addMember,
-  deleteGroup: () => deleteGroup,
-  groupExists: () => groupExists,
-  listGroups: () => listGroups,
-  loadGroup: () => loadGroup,
-  loadSyncResult: () => loadSyncResult,
-  removeMember: () => removeMember,
-  saveGroup: () => saveGroup,
-  saveSyncResult: () => saveSyncResult
-});
-function groupFile(name) {
-  return path32.join(GROUPS_DIR, `${name}.json`);
-}
-function loadGroup(name) {
-  try {
-    return JSON.parse(fs26.readFileSync(groupFile(name), "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function saveGroup(group) {
-  fs26.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs26.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
-}
-function listGroups() {
-  const groups = [];
-  try {
-    for (const file of fs26.readdirSync(GROUPS_DIR)) {
-      if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
-      try {
-        const g = JSON.parse(
-          fs26.readFileSync(path32.join(GROUPS_DIR, file), "utf-8")
-        );
-        groups.push(g);
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return groups;
-}
-function deleteGroup(name) {
-  try {
-    fs26.unlinkSync(groupFile(name));
-  } catch {
-  }
-  try {
-    fs26.unlinkSync(path32.join(GROUPS_DIR, `${name}.sync.json`));
-  } catch {
-  }
-}
-function groupExists(name) {
-  return fs26.existsSync(groupFile(name));
-}
-function addMember(groupName, member) {
-  const group = loadGroup(groupName);
-  if (!group) throw new Error(`Group "${groupName}" not found.`);
-  const idx = group.members.findIndex((m) => m.groupPath === member.groupPath);
-  if (idx >= 0) {
-    group.members[idx] = member;
-  } else {
-    group.members.push(member);
-  }
-  saveGroup(group);
-  return group;
-}
-function removeMember(groupName, groupPath) {
-  const group = loadGroup(groupName);
-  if (!group) throw new Error(`Group "${groupName}" not found.`);
-  const before = group.members.length;
-  group.members = group.members.filter((m) => m.groupPath !== groupPath);
-  if (group.members.length === before) {
-    throw new Error(`No member at path "${groupPath}" in group "${groupName}".`);
-  }
-  saveGroup(group);
-  return group;
-}
-function saveSyncResult(result) {
-  fs26.mkdirSync(GROUPS_DIR, { recursive: true });
-  fs26.writeFileSync(
-    path32.join(GROUPS_DIR, `${result.groupName}.sync.json`),
-    JSON.stringify(result, null, 2) + "\n"
-  );
-}
-function loadSyncResult(groupName) {
-  try {
-    return JSON.parse(
-      fs26.readFileSync(path32.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
-    );
-  } catch {
-    return null;
-  }
-}
-var GROUPS_DIR;
-var init_group_registry = __esm({
-  "src/multi-repo/group-registry.ts"() {
-    GROUPS_DIR = path32.join(os13.homedir(), ".code-intel", "groups");
-  }
-});
-
 // src/multi-repo/graph-from-db.ts
 var graph_from_db_exports = {};
 __export(graph_from_db_exports, {
@@ -3813,19 +3887,26 @@ function executeFIND(stmt, graph) {
     totalCount
   };
 }
+function findBestNode(graph, name) {
+  const matches = [];
+  for (const node of graph.allNodes()) {
+    if (node.name === name) matches.push(node);
+  }
+  if (matches.length === 0) return void 0;
+  if (matches.length === 1) return matches[0];
+  return matches.sort((a, b) => {
+    const aEdges = [...graph.findEdgesFrom(a.id)].length + [...graph.findEdgesTo(a.id)].length;
+    const bEdges = [...graph.findEdgesFrom(b.id)].length + [...graph.findEdgesTo(b.id)].length;
+    return bEdges - aEdges;
+  })[0];
+}
 function executeTRAVERSE(stmt, graph) {
   const start = Date.now();
   const maxDepth = stmt.depth ?? 5;
   const edgeKind = stmt.edgeKind;
   const direction = stmt.direction ?? "OUTGOING";
   const deadline = start + EXECUTION_TIMEOUT_MS;
-  let startNode;
-  for (const node of graph.allNodes()) {
-    if (node.name === stmt.from) {
-      startNode = node;
-      break;
-    }
-  }
+  const startNode = findBestNode(graph, stmt.from);
   if (!startNode) {
     return {
       nodes: [],
@@ -3889,13 +3970,8 @@ function executeTRAVERSE(stmt, graph) {
 function executePATH(stmt, graph) {
   const start = Date.now();
   const deadline = start + EXECUTION_TIMEOUT_MS;
-  let startNode;
-  let endNode;
-  for (const node of graph.allNodes()) {
-    if (node.name === stmt.from) startNode = node;
-    if (node.name === stmt.to) endNode = node;
-    if (startNode && endNode) break;
-  }
+  const startNode = findBestNode(graph, stmt.from);
+  const endNode = findBestNode(graph, stmt.to);
   if (!startNode || !endNode) {
     return {
       path: null,
@@ -4585,6 +4661,7 @@ var init_codes = __esm({
       RATE_LIMIT_EXCEEDED: "CI-1100",
       PAYLOAD_TOO_LARGE: "CI-1101",
       INVALID_REQUEST: "CI-1200",
+      CONFLICT: "CI-1409",
       // Config (CI-2xxx)
       CONFIG_INVALID: "CI-2000",
       CONFIG_NOT_FOUND: "CI-2001",
@@ -4667,7 +4744,7 @@ var init_users_db = __esm({
       constructor(dbPath) {
         const dir = path32.dirname(dbPath);
         secureMkdir(dir);
-        this.db = new Database2(dbPath);
+        this.db = new Database3(dbPath);
         this.db.pragma("journal_mode = WAL");
         this.db.pragma("foreign_keys = ON");
         this.createTables();
@@ -6822,12 +6899,16 @@ function textSearch(graph, query, limit = 20) {
     let score = 0;
     const nameLC = node.name.toLowerCase();
     const pathLC = node.filePath.toLowerCase();
+    const fileBaseName = (node.filePath.split(/[/\\]/).pop()?.replace(/\.[^.]+$/, "") ?? "").toLowerCase();
+    const contentLC = node.content?.toLowerCase() ?? "";
     for (const term of terms) {
       if (nameLC === term) score += 10;
       else if (nameLC.startsWith(term)) score += 7;
       else if (nameLC.includes(term)) score += 5;
-      if (pathLC.includes(term)) score += 2;
-      if (node.content?.toLowerCase().includes(term)) score += 3;
+      if (fileBaseName === term) score += 8;
+      else if (fileBaseName.startsWith(term)) score += 5;
+      else if (pathLC.includes(term)) score += 2;
+      if (contentLC.includes(term)) score += 3;
     }
     if (score > 0) {
       if (isDistPath(node.filePath)) score -= 8;
@@ -6882,7 +6963,7 @@ var VectorIndex = class {
     this.sqlitePath = sqlitePath;
   }
   async init() {
-    this.db = new Database2(this.sqlitePath);
+    this.db = new Database3(this.sqlitePath);
     this.db.pragma("journal_mode = WAL");
     this.db.exec(`
       CREATE TABLE IF NOT EXISTS ${EMBED_TABLE} (
@@ -7012,24 +7093,92 @@ function siftDown(arr, i, score) {
   }
 }
 init_embedder();
+
+// src/search/reranker.ts
+function tokenizeForRerank(text) {
+  return text.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s\-_./:(){}[\]<>,"'`~!@#$%^&*+=|;?\\]+/).filter((t) => t.length >= 2);
+}
+var DEFAULT_KIND_WEIGHTS = {
+  class: 1.2,
+  interface: 1.15,
+  function: 1.1,
+  method: 1.08,
+  type_alias: 1.03,
+  enum: 1.02,
+  constant: 0.98,
+  variable: 0.9,
+  file: 0.85
+};
+var PATH_MULTIPLIER_TEST = 0.4;
+var PATH_MULTIPLIER_DIST = 0.25;
+function rerank(query, results, options = {}) {
+  if (results.length === 0) return results;
+  const {
+    nameWeight = 0.4,
+    snippetWeight = 0.25,
+    kindWeights = {}
+  } = options;
+  const effectiveKindWeights = {
+    ...DEFAULT_KIND_WEIGHTS,
+    ...kindWeights
+  };
+  const queryTerms = [...new Set(tokenizeForRerank(query))];
+  if (queryTerms.length === 0) return results.slice();
+  const queryLower = query.toLowerCase();
+  const scored = results.map((r) => {
+    let bonus = 0;
+    const nameLower = r.name.toLowerCase();
+    const nameTerms = tokenizeForRerank(r.name);
+    if (nameLower === queryLower) {
+      bonus += nameWeight;
+    } else if (nameLower.startsWith(queryLower)) {
+      bonus += nameWeight * 0.75;
+    } else if (queryLower.includes(nameLower) && nameLower.length >= 3) {
+      bonus += nameWeight * 0.45;
+    } else {
+      const matchCount = queryTerms.filter((t) => nameTerms.includes(t)).length;
+      if (matchCount > 0) {
+        const overlap = matchCount / queryTerms.length;
+        bonus += nameWeight * overlap * 0.6;
+      }
+    }
+    if (r.snippet && r.snippet.length > 0) {
+      const snippetLower = r.snippet.toLowerCase();
+      const hitCount = queryTerms.filter((t) => snippetLower.includes(t)).length;
+      bonus += snippetWeight * (hitCount / queryTerms.length);
+    }
+    const kw = effectiveKindWeights[r.kind] ?? 1;
+    const fp = r.filePath;
+    const fpNorm = "/" + fp;
+    const isTestPath = fpNorm.includes("/test/") || fpNorm.includes("/tests/") || fpNorm.includes("/spec/") || fpNorm.includes("/__tests__/") || fp.includes(".test.") || fp.includes(".spec.");
+    const isDistPath = fpNorm.includes("/dist/") || fpNorm.includes("/build/") || fp.endsWith(".d.ts") || fpNorm.includes("/node_modules/");
+    const pathMul = isDistPath ? PATH_MULTIPLIER_DIST : isTestPath ? PATH_MULTIPLIER_TEST : 1;
+    const clampedBonus = Math.max(0, Math.min(nameWeight + snippetWeight, bonus));
+    const finalScore = r.score * (1 + clampedBonus) * kw * pathMul;
+    return { result: r, finalScore };
+  });
+  return scored.sort((a, b) => b.finalScore - a.finalScore).map(({ result, finalScore }) => ({ ...result, score: finalScore }));
+}
+
+// src/search/hybrid-search.ts
 async function hybridSearch(graph, query, limit, options = {}) {
   const { vectorDbPath, bm25Limit = 50, vectorLimit = 50, bm25Results: precomputedBm25 } = options;
+  const rerankEnabled = options.rerank?.enabled !== false;
+  const rerankOptions = rerankEnabled && options.rerank && options.rerank.enabled !== false ? options.rerank : {};
   const bm25Promise = precomputedBm25 ? Promise.resolve(precomputedBm25) : Promise.resolve(textSearch(graph, query, bm25Limit));
   const hasVectorDb = Boolean(vectorDbPath && fs26.existsSync(vectorDbPath));
   if (!hasVectorDb) {
     const bm25Results2 = await bm25Promise;
-    return {
-      results: bm25Results2.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" })),
-      searchMode: "bm25"
-    };
+    const candidates2 = bm25Results2.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" }));
+    const final2 = rerankEnabled ? rerank(query, candidates2, rerankOptions) : candidates2;
+    return { results: final2, searchMode: "bm25" };
   }
   const vectorPromise = runVectorSearch(vectorDbPath, query, vectorLimit);
   const [bm25Results, vectorResults] = await Promise.all([bm25Promise, vectorPromise]);
   if (vectorResults === null || vectorResults.length === 0) {
-    return {
-      results: bm25Results.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" })),
-      searchMode: "bm25"
-    };
+    const candidates2 = bm25Results.slice(0, limit).map((r) => ({ ...r, searchMode: "bm25" }));
+    const final2 = rerankEnabled ? rerank(query, candidates2, rerankOptions) : candidates2;
+    return { results: final2, searchMode: "bm25" };
   }
   const vectorAsSearchResults = vectorResults.map((h) => ({
     nodeId: h.nodeId,
@@ -7040,10 +7189,9 @@ async function hybridSearch(graph, query, limit, options = {}) {
     snippet: graph.getNode(h.nodeId)?.content?.slice(0, 200)
   }));
   const merged = reciprocalRankFusion(bm25Results, vectorAsSearchResults);
-  return {
-    results: merged.slice(0, limit).map((r) => ({ ...r, searchMode: "hybrid" })),
-    searchMode: "hybrid"
-  };
+  const candidates = merged.slice(0, limit).map((r) => ({ ...r, searchMode: "hybrid" }));
+  const final = rerankEnabled ? rerank(query, candidates, rerankOptions) : candidates;
+  return { results: final, searchMode: "hybrid" };
 }
 async function runVectorSearch(vectorDbPath, query, topK) {
   try {
@@ -7073,11 +7221,19 @@ function tokenize(text) {
   return text.toLowerCase().split(/[\s\-_./\\:(){}[\]<>,"'`~!@#$%^&*+=|;?]+/).filter((t) => t.length >= 2 && t.length <= 64);
 }
 function nodeToDoc(node) {
+  const fileBaseName = node.filePath.split(/[/\\]/).pop()?.replace(/\.[^.]+$/, "") ?? "";
   return [
     node.name,
+    node.name,
+    // repeat name to boost exact-name matches
     node.kind,
     node.filePath,
-    (node.content ?? "").slice(0, 1e3)
+    fileBaseName,
+    // filename stem (class name) — extra weight
+    fileBaseName,
+    // repeat again for stronger class-name boosting
+    (node.content ?? "").slice(0, 1500)
+    // increased from 1000
   ].join(" ");
 }
 function heapTopK(scores, k) {
@@ -7174,7 +7330,7 @@ var Bm25Index = class {
       } catch {
       }
     }
-    const db = new Database2(this.dbPath);
+    const db = new Database3(this.dbPath);
     db.pragma("journal_mode = WAL");
     db.exec(`
       CREATE TABLE bm25_index   (term     TEXT PRIMARY KEY, postings TEXT NOT NULL);
@@ -7209,7 +7365,7 @@ var Bm25Index = class {
    */
   load() {
     if (!fs26.existsSync(this.dbPath)) return;
-    const db = new Database2(this.dbPath, { readonly: true });
+    const db = new Database3(this.dbPath, { readonly: true });
     try {
       const getMeta = db.prepare("SELECT value FROM bm25_meta WHERE key = ?");
       this.avgdl = parseFloat(getMeta.get("avgdl")?.value ?? "1");
@@ -7302,7 +7458,7 @@ var Bm25Index = class {
       newTermFreqs.set(node.id, tf);
     }
     const newTermSet = new Set([...newTermFreqs.values()].flatMap((m) => [...m.keys()]));
-    const db = new Database2(this.dbPath);
+    const db = new Database3(this.dbPath);
     db.pragma("journal_mode = WAL");
     const termsToRewrite = /* @__PURE__ */ new Map();
     for (const term of newTermSet) {
@@ -7564,19 +7720,24 @@ function buildNodeProps(node) {
 function escCypher(s) {
   return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "");
 }
-var GLOBAL_DIR = path32.join(os13.homedir(), ".code-intel");
-var REPOS_FILE = path32.join(GLOBAL_DIR, "repos.json");
+function getGlobalDir() {
+  return path32.join(process.env["CODE_INTEL_HOME"] ?? os13.homedir(), ".code-intel");
+}
+function getReposFile() {
+  return path32.join(getGlobalDir(), "repos.json");
+}
 function loadRegistry() {
   try {
-    const data = fs26.readFileSync(REPOS_FILE, "utf-8");
+    const data = fs26.readFileSync(getReposFile(), "utf-8");
     return JSON.parse(data);
   } catch {
     return [];
   }
 }
 function saveRegistry(entries) {
-  fs26.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs26.writeFileSync(REPOS_FILE, JSON.stringify(entries, null, 2));
+  const globalDir = getGlobalDir();
+  fs26.mkdirSync(globalDir, { recursive: true });
+  fs26.writeFileSync(getReposFile(), JSON.stringify(entries, null, 2));
 }
 function upsertRepo(entry) {
   const entries = loadRegistry();
@@ -7611,9 +7772,90 @@ function getDbPath(repoDir) {
 function getVectorDbPath(repoDir) {
   return path32.join(repoDir, ".code-intel", "vector.db");
 }
-
-// src/mcp-server/server.ts
-init_group_registry();
+var GROUPS_DIR = path32.join(os13.homedir(), ".code-intel", "groups");
+function groupFile(name) {
+  return path32.join(GROUPS_DIR, `${name}.json`);
+}
+function loadGroup(name) {
+  try {
+    return JSON.parse(fs26.readFileSync(groupFile(name), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveGroup(group) {
+  fs26.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs26.writeFileSync(groupFile(group.name), JSON.stringify(group, null, 2) + "\n");
+}
+function listGroups() {
+  const groups = [];
+  try {
+    for (const file of fs26.readdirSync(GROUPS_DIR)) {
+      if (!file.endsWith(".json") || file.endsWith(".sync.json")) continue;
+      try {
+        const g = JSON.parse(
+          fs26.readFileSync(path32.join(GROUPS_DIR, file), "utf-8")
+        );
+        groups.push(g);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return groups;
+}
+function deleteGroup(name) {
+  try {
+    fs26.unlinkSync(groupFile(name));
+  } catch {
+  }
+  try {
+    fs26.unlinkSync(path32.join(GROUPS_DIR, `${name}.sync.json`));
+  } catch {
+  }
+}
+function groupExists(name) {
+  return fs26.existsSync(groupFile(name));
+}
+function addMember(groupName, member) {
+  const group = loadGroup(groupName);
+  if (!group) throw new Error(`Group "${groupName}" not found.`);
+  const idx = group.members.findIndex((m) => m.groupPath === member.groupPath);
+  if (idx >= 0) {
+    group.members[idx] = member;
+  } else {
+    group.members.push(member);
+  }
+  saveGroup(group);
+  return group;
+}
+function removeMember(groupName, groupPath) {
+  const group = loadGroup(groupName);
+  if (!group) throw new Error(`Group "${groupName}" not found.`);
+  const before = group.members.length;
+  group.members = group.members.filter((m) => m.groupPath !== groupPath);
+  if (group.members.length === before) {
+    throw new Error(`No member at path "${groupPath}" in group "${groupName}".`);
+  }
+  saveGroup(group);
+  return group;
+}
+function saveSyncResult(result) {
+  fs26.mkdirSync(GROUPS_DIR, { recursive: true });
+  fs26.writeFileSync(
+    path32.join(GROUPS_DIR, `${result.groupName}.sync.json`),
+    JSON.stringify(result, null, 2) + "\n"
+  );
+}
+function loadSyncResult(groupName) {
+  try {
+    return JSON.parse(
+      fs26.readFileSync(path32.join(GROUPS_DIR, `${groupName}.sync.json`), "utf-8")
+    );
+  } catch {
+    return null;
+  }
+}
 init_db_manager();
 init_knowledge_graph();
 init_graph_from_db();
@@ -8712,7 +8954,7 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       // ── Search & inspect ─────────────────────────────────────────────────
       {
         name: "search",
-        description: "BM25 keyword search across all indexed symbols \u2014 functions, classes, files, routes, etc. Optionally scope to a specific repo or group.",
+        description: `BM25 keyword search across all indexed symbols \u2014 functions, classes, files, routes, etc. Optionally scope to a specific repo or group. TIP: To find a method in a specific class when multiple classes have the same method name, include the class/file name in the query (e.g. search("Token requestAccessToken redis save") to find Token.php's version vs JWT.php's). This is the preferred alternative to bare inspect() for ambiguous method names.`,
         inputSchema: {
           type: "object",
           properties: {
@@ -8728,16 +8970,31 @@ function createMcpServer(graph, repoName, workspaceRoot) {
       },
       {
         name: "inspect",
-        description: "360\xB0 view of a symbol: definition location, callers, callees, heritage (extends/implements), members, cluster, and source preview (first 500 chars)",
+        description: '360\xB0 view of a symbol: definition location, callers, callees, heritage (extends/implements), members, cluster, and source preview. When multiple files define the same symbol name, returns a disambiguation list \u2014 re-call with file_path to select the correct implementation. IMPORTANT: When you expect a symbol to be in a specific class (e.g. Token vs JWT, or CMS vs API module), always pass file_path to avoid silently resolving the wrong class. For methods that exist in multiple classes (requestAccessToken, verify, revoke, login, logout), prefer search("ClassName methodName unique-context") over bare inspect to guarantee the right class.',
         inputSchema: {
           type: "object",
           properties: {
             symbol_name: { type: "string", description: "Exact symbol name to inspect" },
+            file_path: { type: "string", description: 'Optional partial file path to disambiguate when multiple symbols share the same name (e.g. "Token.php" or "src/Modules/CMS"). Required when inspect returns a disambiguation list or when you know the target class.' },
             ..._tokenProp
           },
           required: ["symbol_name"]
         }
       },
+      {
+        name: "get_source",
+        description: `Read raw source lines from any file in the workspace. Use this to verify exact implementation details that inspect's content preview may not fully show. Supports partial file path matching (e.g. "Token.php"). Returns numbered lines.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            file_path: { type: "string", description: 'File path to read (partial match supported, e.g. "Token.php" or "src/Modules/CMS/AuthController.php")' },
+            start_line: { type: "number", description: "First line to return (1-indexed, default: 1)" },
+            end_line: { type: "number", description: "Last line to return inclusive (default: start_line + 99). Max 300 lines per call." },
+            ..._tokenProp
+          },
+          required: ["file_path"]
+        }
+      },
       {
         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).",
@@ -9290,8 +9547,41 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot, bm25Resolve
     // ── 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 filePathHint = a.file_path;
+      const allMatchingNodes = findNodesByName(graph, symbolName);
+      if (allMatchingNodes.length === 0) {
+        return { content: [{ type: "text", text: `Symbol "${symbolName}" not found. Try search first.` }] };
+      }
+      let node = allMatchingNodes[0];
+      if (allMatchingNodes.length > 1) {
+        if (filePathHint) {
+          const filtered = allMatchingNodes.filter((n) => n.filePath.includes(filePathHint));
+          if (filtered.length === 0) {
+            return {
+              content: [{
+                type: "text",
+                text: compact({
+                  disambiguation: true,
+                  message: `No match for file_path "${filePathHint}". Available definitions of "${symbolName}":`,
+                  candidates: allMatchingNodes.map((n) => ({ filePath: n.filePath, kind: n.kind, startLine: n.startLine }))
+                })
+              }]
+            };
+          }
+          node = filtered[0];
+        } else {
+          return {
+            content: [{
+              type: "text",
+              text: compact({
+                disambiguation: true,
+                message: `Multiple definitions of "${symbolName}" found. Re-call inspect with file_path to select one.`,
+                candidates: allMatchingNodes.map((n) => ({ filePath: n.filePath, kind: n.kind, startLine: n.startLine, content: n.content?.slice(0, 120) }))
+              })
+            }]
+          };
+        }
+      }
       const incoming = [...graph.findEdgesTo(node.id)];
       const outgoing = [...graph.findEdgesFrom(node.id)];
       const callers = incoming.filter((e) => e.kind === "calls").map((e) => ({
@@ -9338,12 +9628,70 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot, bm25Resolve
               kind: graph.getNode(e.target)?.kind
             })),
             cluster,
-            content: node.content?.slice(0, 500),
+            content: node.content?.slice(0, 1500),
+            contentNote: node.content && node.content.length > 1500 ? `(truncated \u2014 use get_source with file_path="${node.filePath}" start_line=${node.startLine} end_line=${node.endLine} for full source)` : void 0,
             ...suggestEnabled ? { suggested_next_tools: suggestNextTools } : {}
           })
         }]
       };
     }
+    // ── get_source ─────────────────────────────────────────────────────────
+    case "get_source": {
+      const filePathQuery = a.file_path;
+      const startLine = Math.max(1, a.start_line ?? 1);
+      const maxLines = 300;
+      const endLine = Math.min(a.end_line ?? startLine + 99, startLine + maxLines - 1);
+      if (!workspaceRoot) {
+        return { content: [{ type: "text", text: "workspaceRoot not set \u2014 cannot read files." }] };
+      }
+      const matchedFiles = /* @__PURE__ */ new Set();
+      for (const node of graph.allNodes()) {
+        if (node.filePath && node.filePath.includes(filePathQuery)) {
+          matchedFiles.add(node.filePath);
+        }
+      }
+      if (matchedFiles.size === 0) {
+        return { content: [{ type: "text", text: `No indexed file matching "${filePathQuery}". Try a different partial path or use file_symbols to browse.` }] };
+      }
+      if (matchedFiles.size > 1) {
+        return {
+          content: [{
+            type: "text",
+            text: compact({
+              disambiguation: true,
+              message: `Multiple files match "${filePathQuery}". Re-call with a more specific file_path.`,
+              candidates: [...matchedFiles]
+            })
+          }]
+        };
+      }
+      const [resolvedPath] = [...matchedFiles];
+      let fileContent;
+      try {
+        fileContent = fs26.readFileSync(resolvedPath, "utf-8");
+      } catch {
+        return { content: [{ type: "text", text: `Could not read file: ${resolvedPath}` }] };
+      }
+      const lines = fileContent.split("\n");
+      const totalLines = lines.length;
+      const sliceStart = startLine - 1;
+      const sliceEnd = Math.min(endLine, totalLines);
+      const selectedLines = lines.slice(sliceStart, sliceEnd);
+      const numbered = selectedLines.map((l, i) => `${sliceStart + i + 1}: ${l}`).join("\n");
+      return {
+        content: [{
+          type: "text",
+          text: compact({
+            filePath: resolvedPath,
+            startLine,
+            endLine: sliceEnd,
+            totalLines,
+            hasMore: sliceEnd < totalLines,
+            source: numbered
+          })
+        }]
+      };
+    }
     // ── blast_radius ───────────────────────────────────────────────────────
     case "blast_radius": {
       const target = a.target;
@@ -9476,12 +9824,12 @@ async function dispatchTool(name, a, graph, repoName, workspaceRoot, bm25Resolve
         allExports.push({ kind: node.kind, name: node.name, filePath: node.filePath, startLine: node.startLine });
       }
       const total = allExports.length;
-      const exports$1 = allExports.slice(offset, offset + effectiveLimit);
+      const exports = allExports.slice(offset, offset + effectiveLimit);
       const hasMore = offset + effectiveLimit < total;
       return {
         content: [{
           type: "text",
-          text: compact({ exports: exports$1, total, offset, limit: effectiveLimit, hasMore })
+          text: compact({ exports, total, offset, limit: effectiveLimit, hasMore })
         }]
       };
     }
@@ -9962,6 +10310,13 @@ function findNodeByName(graph, name) {
   }
   return void 0;
 }
+function findNodesByName(graph, name) {
+  const results = [];
+  for (const node of graph.allNodes()) {
+    if (node.name === name) results.push(node);
+  }
+  return results;
+}
 function parseDiff(diffText) {
   const result = [];
   let currentFile = null;
@@ -9992,7 +10347,6 @@ function parseDiff(diffText) {
   }
   return result;
 }
-init_group_registry();
 init_knowledge_graph();
 init_graph_from_db();
 init_logger();
@@ -10006,7 +10360,7 @@ var JobsDB = class {
   db;
   constructor(dbPath) {
     fs26.mkdirSync(path32.dirname(dbPath), { recursive: true });
-    this.db = new Database2(dbPath);
+    this.db = new Database3(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
     this.createTables();
@@ -12289,6 +12643,97 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
     }
     res.json(result);
   });
+  app.post("/api/v1/groups", requireAuth, requireRole("analyst"), (req, res) => {
+    const { name } = req.body;
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "Group name is required" } });
+      return;
+    }
+    const trimmed = name.trim();
+    if (groupExists(trimmed)) {
+      res.status(409).json({ error: { code: ErrorCodes.CONFLICT, message: `Group "${trimmed}" already exists` } });
+      return;
+    }
+    const group = { name: trimmed, createdAt: (/* @__PURE__ */ new Date()).toISOString(), members: [] };
+    saveGroup(group);
+    res.status(201).json(group);
+  });
+  app.delete("/api/v1/groups/:name", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    if (!groupExists(groupName)) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    deleteGroup(groupName);
+    res.status(204).end();
+  });
+  app.patch("/api/v1/groups/:name", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { name } = req.body;
+    if (!name || !name.trim()) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "New name is required" } });
+      return;
+    }
+    const newName = name.trim();
+    if (newName !== group.name && groupExists(newName)) {
+      res.status(409).json({ error: { code: ErrorCodes.CONFLICT, message: `Group "${newName}" already exists` } });
+      return;
+    }
+    if (newName !== group.name) {
+      deleteGroup(group.name);
+      group.name = newName;
+    }
+    saveGroup(group);
+    res.json(group);
+  });
+  app.post("/api/v1/groups/:name/members", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { groupPath, registryName } = req.body;
+    if (!groupPath || !registryName) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "groupPath and registryName are required" } });
+      return;
+    }
+    const registry = loadRegistry();
+    if (!registry.find((r) => r.name === registryName)) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: `Repo "${registryName}" not found in registry. Run code-intel analyze first.` } });
+      return;
+    }
+    try {
+      const updated = addMember(groupName, { groupPath, registryName });
+      res.json(updated);
+    } catch (err) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: err instanceof Error ? err.message : String(err) } });
+    }
+  });
+  app.delete("/api/v1/groups/:name/members", requireAuth, requireRole("analyst"), (req, res) => {
+    const groupName = req.params["name"];
+    const group = loadGroup(groupName);
+    if (!group) {
+      res.status(404).json({ error: { code: ErrorCodes.NOT_FOUND, message: "Group not found" } });
+      return;
+    }
+    const { groupPath } = req.body;
+    if (!groupPath) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: "groupPath is required" } });
+      return;
+    }
+    try {
+      const updated = removeMember(groupName, groupPath);
+      res.json(updated);
+    } catch (err) {
+      res.status(400).json({ error: { code: ErrorCodes.INVALID_REQUEST, message: err instanceof Error ? err.message : String(err) } });
+    }
+  });
   app.post("/api/v1/groups/:name/sync", async (req, res) => {
     const group = loadGroup(req.params.name);
     if (!group) {
@@ -12299,8 +12744,7 @@ function createApp(graph, repoName, workspaceRoot, watcherState) {
       const result = await syncGroup(group);
       saveSyncResult(result);
       group.lastSync = result.syncedAt;
-      const { saveGroup: saveGroup2 } = await Promise.resolve().then(() => (init_group_registry(), group_registry_exports));
-      saveGroup2(group);
+      saveGroup(group);
       res.json(result);
     } catch (err) {
       res.status(500).json({ error: { code: ErrorCodes.INTERNAL_ERROR, message: err instanceof Error ? err.message : String(err) } });
@@ -12800,7 +13244,6 @@ async function startHttpServer(graph, repoName, port = 4747, workspaceRoot, watc
 }
 
 // src/multi-repo/index.ts
-init_group_registry();
 init_graph_from_db();
 
 // src/multi-repo/cross-repo-search.ts