@esankhan3/code-search-mcp 0.4.2 → 0.4.3

package/dist/server.js

@@ -224,7 +224,7 @@ async function autoIndex(ctx) {
   try {
     const kbPath = getKnowledgeBasePath(ctx.projectName);
     const hasLanceDB = existsSync(join(kbPath, "lancedb"));
-    const hasGraph = existsSync(join(kbPath, "system_graph_v2.json"));
+    const hasGraph = existsSync(join(kbPath, "system_graph.sqlite")) || existsSync(join(kbPath, "system_graph_v2.json"));
     if (hasLanceDB && hasGraph) {
       ctx.indexReady = true;
       console.error(`[code-search-mcp] Index loaded for "${ctx.projectName}"`);

package/dist/tools/graph.js

@@ -5,7 +5,8 @@ import {
   loadAllProfiles,
   loadProfile,
   getAllChanges,
-  getChangedFilesList
+  getChangedFilesList,
+  openSystemGraphStore
 } from "@esankhan3/anvil-knowledge-core";
 const GRAPH_TOOL_NAMES = [
   "get_repo_graph",
@@ -19,43 +20,19 @@ const GRAPH_TOOL_NAMES = [
   "search_graph",
   "detect_changes"
 ];
-function loadSystemGraph(kbPath) {
-  const p = join(kbPath, "system_graph_v2.json");
-  if (!existsSync(p)) return null;
-  try {
-    const g = JSON.parse(readFileSync(p, "utf-8"));
-    return { nodes: g.nodes ?? [], edges: g.edges ?? [] };
-  } catch {
-    return null;
-  }
-}
-function nodeLabel(node) {
-  return node.attributes?.label ?? node.key.split("::").slice(2).join("::") ?? node.key;
-}
-const edgeType = (e) => e.attributes?.type ?? e.attributes?.relation;
-function resolveEntityNodes(nodes, name, repo, fuzzy = false) {
-  const inRepo = (key) => !repo || key.startsWith(repo + "::");
-  if (fuzzy) {
-    return nodes.filter((n) => inRepo(n.key) && ((n.attributes?.label ?? "").includes(name) || n.key.includes(name))).map((n) => n.key);
-  }
-  return nodes.filter((n) => inRepo(n.key) && (n.attributes?.label === name || n.key.endsWith("::" + name))).map((n) => n.key);
-}
-function buildAdjacency(edges, direction) {
-  const adj = /* @__PURE__ */ new Map();
-  const add = (a, b) => {
-    if (!adj.has(a)) adj.set(a, /* @__PURE__ */ new Set());
-    adj.get(a).add(b);
+const repoOf = (key) => key.split("::")[0] ?? "";
+function makeNeighborGetter(store, direction) {
+  const cache = /* @__PURE__ */ new Map();
+  return (key) => {
+    let v = cache.get(key);
+    if (v === void 0) {
+      v = store.neighborsOf(key, direction);
+      cache.set(key, v);
+    }
+    return v;
   };
-  for (const e of edges) {
-    if (!e.source || !e.target) continue;
-    if (edgeType(e) === "contains") continue;
-    if ((e.attributes?.confidence ?? 0.8) < 0.7) continue;
-    if (direction === "callees" || direction === "both") add(e.source, e.target);
-    if (direction === "callers" || direction === "both") add(e.target, e.source);
-  }
-  return adj;
 }
-function shortestPath(adj, fromKeys, toKeys, maxDepth) {
+function shortestPath(getNeighbors, fromKeys, toKeys, maxDepth) {
   const seed = fromKeys.find((k) => toKeys.has(k));
   if (seed) return [seed];
   const visited = new Set(fromKeys);
@@ -63,7 +40,7 @@ function shortestPath(adj, fromKeys, toKeys, maxDepth) {
   for (let depth = 0; depth < maxDepth && frontier.length > 0; depth++) {
     const next = [];
     for (const path of frontier) {
-      for (const nb of adj.get(path[path.length - 1]) ?? []) {
+      for (const nb of getNeighbors(path[path.length - 1])) {
         if (visited.has(nb)) continue;
         if (toKeys.has(nb)) return [...path, nb];
         visited.add(nb);
@@ -74,14 +51,14 @@ function shortestPath(adj, fromKeys, toKeys, maxDepth) {
   }
   return null;
 }
-function reachable(adj, fromKeys, maxDepth, cap = 50) {
+function reachable(getNeighbors, fromKeys, maxDepth, cap = 50) {
   const visited = new Set(fromKeys);
   const out = [];
   let frontier = [...fromKeys];
   for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth++) {
     const next = [];
     for (const k of frontier) {
-      for (const nb of adj.get(k) ?? []) {
+      for (const nb of getNeighbors(k)) {
         if (visited.has(nb)) continue;
         visited.add(nb);
         out.push({ key: nb, depth });
@@ -219,14 +196,14 @@ function registerGraphTools() {
 }
 async function handleGraphTool(name, args, ctx) {
   if (!GRAPH_TOOL_NAMES.includes(name)) return null;
+  const text = (t) => ({ content: [{ type: "text", text: t }] });
+  const NO_GRAPH = "No system graph found. Build KB first.";
   try {
     const kbPath = getKnowledgeBasePath(ctx.projectName);
     if (name === "get_repo_graph") {
       const repo = args.repo;
       const graphPath = join(kbPath, repo, "graph.json");
-      if (!existsSync(graphPath)) {
-        return { content: [{ type: "text", text: `No graph found for repo "${repo}"` }] };
-      }
+      if (!existsSync(graphPath)) return text(`No graph found for repo "${repo}"`);
       const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
       const summary = `# ${repo} AST Graph
 
@@ -237,140 +214,132 @@ async function handleGraphTool(name, args, ctx) {
 ${(graph.nodes ?? []).slice(0, 50).map((n) => `- \`${n.id}\` (${n.type})`).join("\n")}
 
 ${graph.nodes?.length > 50 ? `... and ${graph.nodes.length - 50} more` : ""}`;
-      return { content: [{ type: "text", text: summary }] };
+      return text(summary);
     }
     if (name === "get_cross_repo_edges") {
-      const sys = loadSystemGraph(kbPath);
-      if (!sys) return { content: [{ type: "text", text: "No system graph found. Build KB first." }] };
-      const repo = args.repo;
-      const relevant = repo ? sys.edges.filter((e) => e.source.startsWith(repo + "::") || e.target.startsWith(repo + "::")) : sys.edges;
-      const crossRepo = relevant.filter((e) => {
-        const src = e.source.split("::")[0];
-        const tgt = e.target.split("::")[0];
-        return src && tgt && src !== tgt;
-      });
-      if (crossRepo.length === 0) {
-        return { content: [{ type: "text", text: repo ? `No cross-repo edges found for "${repo}"` : "No cross-repo edges found" }] };
-      }
-      const text = crossRepo.slice(0, 50).map(
-        (e) => `- ${e.source.split("::")[0]} \u2192 ${e.target.split("::")[0]} (${edgeType(e) ?? "edge"})`
-      ).join("\n");
-      return { content: [{ type: "text", text: `# Cross-Repo Edges${repo ? ` for ${repo}` : ""}
+      const store = await openSystemGraphStore(kbPath);
+      if (!store) return text(NO_GRAPH);
+      try {
+        const repo = args.repo;
+        const { edges, total } = store.crossRepoEdges(repo, 50);
+        if (total === 0) return text(repo ? `No cross-repo edges found for "${repo}"` : "No cross-repo edges found");
+        const body = edges.map((e) => `- ${repoOf(e.source)} \u2192 ${repoOf(e.target)} (${e.type ?? "edge"})`).join("\n");
+        return text(`# Cross-Repo Edges${repo ? ` for ${repo}` : ""}
 
-${crossRepo.length} edges found:
+${total} edges found:
 
-${text}${crossRepo.length > 50 ? `
+${body}${total > edges.length ? `
 
-... and ${crossRepo.length - 50} more` : ""}` }] };
+... and ${total - edges.length} more` : ""}`);
+      } finally {
+        store.close();
+      }
     }
     if (name === "find_callers" || name === "find_dependencies") {
-      const funcName = args.function;
-      const repoFilter = args.repo;
-      const fuzzy = args.fuzzy === true;
-      const sys = loadSystemGraph(kbPath);
-      if (!sys) return { content: [{ type: "text", text: "No system graph found." }] };
-      const matchKeys = new Set(resolveEntityNodes(sys.nodes, funcName, repoFilter, fuzzy));
-      if (matchKeys.size === 0) {
-        return { content: [{ type: "text", text: `No entity found matching "${funcName}"${repoFilter ? ` in ${repoFilter}` : ""}. Try fuzzy:true for substring matching.` }] };
-      }
-      const results = name === "find_callers" ? sys.edges.filter((e) => matchKeys.has(e.target) && edgeType(e) !== "contains").map((e) => e.source) : sys.edges.filter((e) => matchKeys.has(e.source) && edgeType(e) !== "contains").map((e) => e.target);
-      const unique = [...new Set(results)].slice(0, 30);
-      const direction = name === "find_callers" ? "Callers of" : "Dependencies of";
-      if (unique.length === 0) {
-        return { content: [{ type: "text", text: `# ${direction} "${funcName}"
+      const store = await openSystemGraphStore(kbPath);
+      if (!store) return text("No system graph found.");
+      try {
+        const funcName = args.function;
+        const repoFilter = args.repo;
+        const fuzzy = args.fuzzy === true;
+        const matched = store.resolveNodes(funcName, repoFilter, fuzzy);
+        if (matched.length === 0) {
+          return text(`No entity found matching "${funcName}"${repoFilter ? ` in ${repoFilter}` : ""}. Try fuzzy:true for substring matching.`);
+        }
+        const keys = matched.map((m) => m.key);
+        const unique = name === "find_callers" ? store.callers(keys, 30) : store.dependencies(keys, 30);
+        const direction = name === "find_callers" ? "Callers of" : "Dependencies of";
+        if (unique.length === 0) {
+          return text(`# ${direction} "${funcName}"
 
-Matched ${matchKeys.size} entit${matchKeys.size === 1 ? "y" : "ies"}, but no ${name === "find_callers" ? "callers" : "dependencies"} found.` }] };
-      }
-      return { content: [{ type: "text", text: `# ${direction} "${funcName}"
+Matched ${matched.length} entit${matched.length === 1 ? "y" : "ies"}, but no ${name === "find_callers" ? "callers" : "dependencies"} found.`);
+        }
+        return text(`# ${direction} "${funcName}"
 
 ${unique.length} found:
-${unique.map((r) => `- \`${r}\``).join("\n")}` }] };
+${unique.map((r) => `- \`${r}\``).join("\n")}`);
+      } finally {
+        store.close();
+      }
     }
     if (name === "impact_analysis") {
-      const file = args.file;
-      const repo = args.repo;
-      const entity = args.entity;
-      const sys = loadSystemGraph(kbPath);
-      if (!sys) return { content: [{ type: "text", text: "No system graph found." }] };
-      const fileNodes = sys.nodes.filter((n) => {
-        const matchesFile = n.key.includes(`${repo}::${file}::`);
-        const matchesEntity = !entity || n.key.endsWith(`::${entity}`);
-        return matchesFile && matchesEntity;
-      });
-      const nodeKeys = new Set(fileNodes.map((n) => n.key));
-      const dependents = sys.edges.filter((e) => nodeKeys.has(e.target) && !nodeKeys.has(e.source) && edgeType(e) !== "contains");
-      const dependentRepos = new Set(dependents.map((e) => e.source.split("::")[0]));
-      const text = [
-        `# Impact Analysis: ${repo}/${file}${entity ? `::${entity}` : ""}`,
-        "",
-        `## Entities in scope: ${fileNodes.length}`,
-        ...fileNodes.slice(0, 20).map((n) => `- \`${n.key}\``),
-        "",
-        `## Dependents: ${dependents.length} edges from ${dependentRepos.size} repos`,
-        ...dependents.slice(0, 30).map((e) => `- \`${e.source}\` \u2192 \`${e.target}\` (${edgeType(e) ?? "edge"})`),
-        dependents.length > 30 ? `
-... and ${dependents.length - 30} more` : "",
-        "",
-        `## Affected repos: ${[...dependentRepos].join(", ") || "none"}`
-      ].join("\n");
-      return { content: [{ type: "text", text }] };
+      const store = await openSystemGraphStore(kbPath);
+      if (!store) return text("No system graph found.");
+      try {
+        const file = args.file;
+        const repo = args.repo;
+        const entity = args.entity;
+        const fileKeys = store.nodesInFiles(repo, [file], entity);
+        const { edges: dependents, total, repos } = store.dependents(fileKeys, 30);
+        const body = [
+          `# Impact Analysis: ${repo}/${file}${entity ? `::${entity}` : ""}`,
+          "",
+          `## Entities in scope: ${fileKeys.length}`,
+          ...fileKeys.slice(0, 20).map((k) => `- \`${k}\``),
+          "",
+          `## Dependents: ${total} edges from ${repos.length} repos`,
+          ...dependents.map((e) => `- \`${e.source}\` \u2192 \`${e.target}\` (${e.type ?? "edge"})`),
+          total > dependents.length ? `
+... and ${total - dependents.length} more` : "",
+          "",
+          `## Affected repos: ${repos.join(", ") || "none"}`
+        ].join("\n");
+        return text(body);
+      } finally {
+        store.close();
+      }
     }
     if (name === "trace_path") {
-      const sys = loadSystemGraph(kbPath);
-      if (!sys) return { content: [{ type: "text", text: "No system graph found." }] };
-      const from = args.from;
-      const to = args.to;
-      const repo = args.repo;
-      const fuzzy = args.fuzzy === true;
-      const direction = args.direction ?? "callees";
-      const maxDepth = Math.max(1, Math.min(10, args.maxDepth || 4));
-      const fromKeys = resolveEntityNodes(sys.nodes, from, repo, fuzzy);
-      if (fromKeys.length === 0) {
-        return { content: [{ type: "text", text: `No entity found matching "${from}". Try fuzzy:true.` }] };
-      }
-      const labelOf = new Map(sys.nodes.map((n) => [n.key, nodeLabel(n)]));
-      const adj = buildAdjacency(sys.edges, direction);
-      if (to) {
-        const toKeys = new Set(resolveEntityNodes(sys.nodes, to, repo, fuzzy));
-        if (toKeys.size === 0) {
-          return { content: [{ type: "text", text: `No entity found matching target "${to}". Try fuzzy:true.` }] };
-        }
-        const path = shortestPath(adj, fromKeys, toKeys, maxDepth);
-        if (!path) {
-          return { content: [{ type: "text", text: `No path from "${from}" to "${to}" within ${maxDepth} hops (direction: ${direction}).` }] };
-        }
-        const arrow = direction === "callers" ? " \u2190 " : " \u2192 ";
-        const rendered = path.map((k) => labelOf.get(k) ?? k).join(arrow);
-        return { content: [{ type: "text", text: `# Path (${path.length - 1} hops)
+      const store = await openSystemGraphStore(kbPath);
+      if (!store) return text("No system graph found.");
+      try {
+        const from = args.from;
+        const to = args.to;
+        const repo = args.repo;
+        const fuzzy = args.fuzzy === true;
+        const direction = args.direction ?? "callees";
+        const maxDepth = Math.max(1, Math.min(10, args.maxDepth || 4));
+        const fromKeys = store.resolveNodes(from, repo, fuzzy).map((m) => m.key);
+        if (fromKeys.length === 0) return text(`No entity found matching "${from}". Try fuzzy:true.`);
+        const getNeighbors = makeNeighborGetter(store, direction);
+        if (to) {
+          const toKeys = new Set(store.resolveNodes(to, repo, fuzzy).map((m) => m.key));
+          if (toKeys.size === 0) return text(`No entity found matching target "${to}". Try fuzzy:true.`);
+          const path = shortestPath(getNeighbors, fromKeys, toKeys, maxDepth);
+          if (!path) return text(`No path from "${from}" to "${to}" within ${maxDepth} hops (direction: ${direction}).`);
+          const labelOf2 = store.labelsOf(path);
+          const arrow = direction === "callers" ? " \u2190 " : " \u2192 ";
+          const rendered = path.map((k) => labelOf2.get(k) ?? k).join(arrow);
+          return text(`# Path (${path.length - 1} hops)
 
 ${rendered}
 
-${path.map((k) => `- \`${k}\``).join("\n")}` }] };
-      }
-      const nodes = reachable(adj, fromKeys, maxDepth);
-      if (nodes.length === 0) {
-        return { content: [{ type: "text", text: `No ${direction} reachable from "${from}" within ${maxDepth} hops.` }] };
-      }
-      const byDepth = /* @__PURE__ */ new Map();
-      for (const { key, depth } of nodes) {
-        if (!byDepth.has(depth)) byDepth.set(depth, []);
-        byDepth.get(depth).push(`\`${labelOf.get(key) ?? key}\` (${key})`);
-      }
-      const sections = [...byDepth.entries()].sort((a, b) => a[0] - b[0]).map(([d, ks]) => `## Depth ${d}
+${path.map((k) => `- \`${k}\``).join("\n")}`);
+        }
+        const nodes = reachable(getNeighbors, fromKeys, maxDepth);
+        if (nodes.length === 0) return text(`No ${direction} reachable from "${from}" within ${maxDepth} hops.`);
+        const labelOf = store.labelsOf(nodes.map((n) => n.key));
+        const byDepth = /* @__PURE__ */ new Map();
+        for (const { key, depth } of nodes) {
+          if (!byDepth.has(depth)) byDepth.set(depth, []);
+          byDepth.get(depth).push(`\`${labelOf.get(key) ?? key}\` (${key})`);
+        }
+        const sections = [...byDepth.entries()].sort((a, b) => a[0] - b[0]).map(([d, ks]) => `## Depth ${d}
 ${ks.map((k) => `- ${k}`).join("\n")}`).join("\n\n");
-      return { content: [{ type: "text", text: `# Reachable from "${from}" (${direction}, \u2264${maxDepth} hops)
+        return text(`# Reachable from "${from}" (${direction}, \u2264${maxDepth} hops)
 
 ${nodes.length} nodes:
 
-${sections}` }] };
+${sections}`);
+      } finally {
+        store.close();
+      }
     }
     if (name === "find_dead_code") {
       const repo = args.repo;
       const limit = args.limit || 50;
       const graphPath = join(kbPath, repo, "graph.json");
-      if (!existsSync(graphPath)) {
-        return { content: [{ type: "text", text: `No graph found for repo "${repo}"` }] };
-      }
+      if (!existsSync(graphPath)) return text(`No graph found for repo "${repo}"`);
       const graph = JSON.parse(readFileSync(graphPath, "utf-8"));
       const ENTITY_TYPES = /* @__PURE__ */ new Set(["function", "method", "class", "struct", "enum", "trait"]);
       const inDegree = /* @__PURE__ */ new Map();
@@ -379,13 +348,11 @@ ${sections}` }] };
         inDegree.set(l.target, (inDegree.get(l.target) ?? 0) + 1);
       }
       const dead = (graph.nodes ?? []).filter((n) => ENTITY_TYPES.has(n.type) && (inDegree.get(n.id) ?? 0) === 0);
-      if (dead.length === 0) {
-        return { content: [{ type: "text", text: `# Dead code in ${repo}
+      if (dead.length === 0) return text(`# Dead code in ${repo}
 
-No zero-caller entities found.` }] };
-      }
+No zero-caller entities found.`);
       const rows = dead.slice(0, limit).map((n) => `- \`${n.label ?? n.id}\` (${n.type})${n.file ? ` \u2014 ${n.file}` : ""}`).join("\n");
-      return { content: [{ type: "text", text: `# Dead code in ${repo} (heuristic)
+      return text(`# Dead code in ${repo} (heuristic)
 
 ${dead.length} zero-caller entit${dead.length === 1 ? "y" : "ies"}:
 
@@ -393,17 +360,15 @@ ${rows}${dead.length > limit ? `
 
 ... and ${dead.length - limit} more` : ""}
 
-_Note: exported APIs, reflection, and dynamic dispatch can cause false positives._` }] };
+_Note: exported APIs, reflection, and dynamic dispatch can cause false positives._`);
     }
     if (name === "get_architecture") {
       const repo = args.repo;
       if (repo) {
         const profile = loadProfile(ctx.projectName, repo);
-        if (!profile) {
-          return { content: [{ type: "text", text: `No profile for "${repo}". Run profiling (requires LLM) to generate one.` }] };
-        }
+        if (!profile) return text(`No profile for "${repo}". Run profiling (requires LLM) to generate one.`);
         const ep = (xs) => xs?.length ? xs.map((e) => `  - ${e.type}: ${e.identifier} \u2014 ${e.description}`).join("\n") : "  - (none)";
-        const text = [
+        const body = [
           `# ${profile.name} \u2014 ${profile.role} (${profile.domain})`,
           "",
           profile.description,
@@ -417,7 +382,7 @@ _Note: exported APIs, reflection, and dynamic dispatch can cause false positives
           "## Consumes",
           ep(profile.consumes)
         ].join("\n");
-        return { content: [{ type: "text", text }] };
+        return text(body);
       }
       const pgPath = join(kbPath, "PROJECT_GRAPH.json");
       const pg = existsSync(pgPath) ? JSON.parse(readFileSync(pgPath, "utf-8")) : null;
@@ -425,15 +390,13 @@ _Note: exported APIs, reflection, and dynamic dispatch can cause false positives
         const lines = ["# Project Architecture", "", pg.architectureSummary ?? ""];
         if (pg.repoRoles && Object.keys(pg.repoRoles).length) {
           lines.push("", "## Repo Roles");
-          for (const [name2, r] of Object.entries(pg.repoRoles)) {
-            lines.push(`- **${name2}** \u2014 ${r.role} (${r.criticality}): ${(r.responsibilities ?? []).join("; ")}`);
+          for (const [n, r] of Object.entries(pg.repoRoles)) {
+            lines.push(`- **${n}** \u2014 ${r.role} (${r.criticality}): ${(r.responsibilities ?? []).join("; ")}`);
           }
         }
         if (pg.relationships?.length) {
           lines.push("", "## Relationships");
-          for (const rel of pg.relationships) {
-            lines.push(`- ${rel.from} \u2192 ${rel.to} (${rel.type}): ${rel.description}`);
-          }
+          for (const rel of pg.relationships) lines.push(`- ${rel.from} \u2192 ${rel.to} (${rel.type}): ${rel.description}`);
         }
         if (pg.keyFlows?.length) {
           lines.push("", "## Key Flows");
@@ -442,77 +405,51 @@ _Note: exported APIs, reflection, and dynamic dispatch can cause false positives
             for (const s of f.steps ?? []) lines.push(`  - ${s.repo}/${s.component}: ${s.action} [${s.protocol}]`);
           }
         }
-        return { content: [{ type: "text", text: lines.join("\n") }] };
+        return text(lines.join("\n"));
       }
       const summaryPath = join(kbPath, "PROJECT_SUMMARY.md");
-      if (existsSync(summaryPath)) {
-        return { content: [{ type: "text", text: readFileSync(summaryPath, "utf-8") }] };
-      }
+      if (existsSync(summaryPath)) return text(readFileSync(summaryPath, "utf-8"));
       const profiles = loadAllProfiles(ctx.projectName);
       if (profiles.length) {
-        const text = `# Project Repos
+        return text(`# Project Repos
 
 ${profiles.map((p) => `- **${p.name}** \u2014 ${p.role} (${p.domain}): ${p.description}`).join("\n")}
 
-_Run project-graph generation (requires LLM) for a full architecture view._`;
-        return { content: [{ type: "text", text }] };
+_Run project-graph generation (requires LLM) for a full architecture view._`);
       }
-      return { content: [{ type: "text", text: "No architecture data yet. Index the project, then run profiling / project-graph generation (requires an LLM) for an architecture overview." }] };
+      return text("No architecture data yet. Index the project, then run profiling / project-graph generation (requires an LLM) for an architecture overview.");
     }
     if (name === "search_graph") {
-      const sys = loadSystemGraph(kbPath);
-      if (!sys) return { content: [{ type: "text", text: "No system graph found. Build KB first." }] };
-      const repo = args.repo;
-      const type = args.type;
-      const file = args.file;
-      const minDegree = args.minDegree ?? 0;
-      const limit = args.limit || 50;
-      const nameArg = args.name;
-      let nameTest = () => true;
-      if (nameArg) {
-        try {
-          const re = new RegExp(nameArg, "i");
-          nameTest = (s) => re.test(s);
-        } catch {
-          const lc = nameArg.toLowerCase();
-          nameTest = (s) => s.toLowerCase().includes(lc);
-        }
-      }
-      const degree = /* @__PURE__ */ new Map();
-      for (const e of sys.edges) {
-        if (edgeType(e) === "contains") continue;
-        degree.set(e.source, (degree.get(e.source) ?? 0) + 1);
-        degree.set(e.target, (degree.get(e.target) ?? 0) + 1);
-      }
-      const matches = sys.nodes.filter((n) => {
-        if (repo && !n.key.startsWith(repo + "::")) return false;
-        if (type && n.attributes?.type !== type) return false;
-        const f = n.attributes?.file ?? n.key.split("::")[1] ?? "";
-        if (file && !f.includes(file)) return false;
-        if (nameArg && !(nameTest(n.attributes?.label ?? "") || nameTest(n.key))) return false;
-        return (degree.get(n.key) ?? 0) >= minDegree;
-      }).map((n) => ({ key: n.key, label: nodeLabel(n), type: n.attributes?.type ?? "?", file: n.attributes?.file ?? n.key.split("::")[1] ?? "", deg: degree.get(n.key) ?? 0 })).sort((a, b) => b.deg - a.deg);
-      if (matches.length === 0) {
-        return { content: [{ type: "text", text: "No entities match the given filters." }] };
-      }
-      const rows = matches.slice(0, limit).map((m) => `- \`${m.label}\` (${m.type}, ${m.file}) \u2014 degree ${m.deg}  \`${m.key}\``).join("\n");
-      return { content: [{ type: "text", text: `# search_graph \u2014 ${matches.length} match${matches.length === 1 ? "" : "es"}
+      const store = await openSystemGraphStore(kbPath);
+      if (!store) return text(NO_GRAPH);
+      try {
+        const { rows, total } = store.searchNodes({
+          name: args.name,
+          type: args.type,
+          file: args.file,
+          repo: args.repo,
+          minDegree: args.minDegree ?? 0
+        }, args.limit || 50);
+        if (total === 0) return text("No entities match the given filters.");
+        const body = rows.map((m) => `- \`${m.label}\` (${m.type}, ${m.file}) \u2014 degree ${m.degree}  \`${m.key}\``).join("\n");
+        return text(`# search_graph \u2014 ${total} match${total === 1 ? "" : "es"}
 
-${rows}${matches.length > limit ? `
+${body}${total > rows.length ? `
 
-... and ${matches.length - limit} more` : ""}` }] };
+... and ${total - rows.length} more` : ""}`);
+      } finally {
+        store.close();
+      }
     }
     if (name === "detect_changes") {
       const repo = args.repo;
       const limit = args.limit || 50;
       if (!ctx.directoryPath) {
-        return { content: [{ type: "text", text: "detect_changes needs a local repo path \u2014 available in local/serve mode only (not remote-proxy mode)." }] };
+        return text("detect_changes needs a local repo path \u2014 available in local/serve mode only (not remote-proxy mode).");
       }
       const candidate = join(ctx.directoryPath, repo);
       const repoPath = existsSync(join(candidate, ".git")) ? candidate : ctx.directoryPath;
-      if (!existsSync(repoPath)) {
-        return { content: [{ type: "text", text: `Repo path not found: ${repoPath}` }] };
-      }
+      if (!existsSync(repoPath)) return text(`Repo path not found: ${repoPath}`);
       let baseSha = args.baseSha;
       if (!baseSha) {
         const metaPath = join(kbPath, repo, "index_meta.json");
@@ -523,43 +460,42 @@ ${rows}${matches.length > limit ? `
           }
         }
       }
-      if (!baseSha) {
-        return { content: [{ type: "text", text: "No base commit available. Pass baseSha, or index the repo first so a last-indexed SHA exists." }] };
-      }
+      if (!baseSha) return text("No base commit available. Pass baseSha, or index the repo first so a last-indexed SHA exists.");
       const diff = getAllChanges(repoPath, baseSha);
-      if (diff.fallbackToFull) {
-        return { content: [{ type: "text", text: `git diff against ${baseSha.slice(0, 7)} failed or is too large to map incrementally. Check the base SHA.` }] };
-      }
+      if (diff.fallbackToFull) return text(`git diff against ${baseSha.slice(0, 7)} failed or is too large to map incrementally. Check the base SHA.`);
       const changedFiles = getChangedFilesList(diff);
-      if (changedFiles.length === 0 && diff.deleted.length === 0) {
-        return { content: [{ type: "text", text: `No source changes since ${baseSha.slice(0, 7)}.` }] };
-      }
-      const sys = loadSystemGraph(kbPath);
-      const changedKeys = /* @__PURE__ */ new Set();
-      if (sys) {
-        for (const f of changedFiles) {
-          for (const n of sys.nodes) {
-            if (n.key.startsWith(`${repo}::${f}::`) || n.key === `${repo}::${f}`) changedKeys.add(n.key);
-          }
+      if (changedFiles.length === 0 && diff.deleted.length === 0) return text(`No source changes since ${baseSha.slice(0, 7)}.`);
+      const store = await openSystemGraphStore(kbPath);
+      let changedKeys = [];
+      let dependents = [];
+      let depTotal = 0;
+      let depRepos = [];
+      if (store) {
+        try {
+          changedKeys = store.nodesInFiles(repo, changedFiles);
+          const d = store.dependents(changedKeys, limit);
+          dependents = d.edges;
+          depTotal = d.total;
+          depRepos = d.repos;
+        } finally {
+          store.close();
         }
       }
-      const dependents = sys ? sys.edges.filter((e) => changedKeys.has(e.target) && !changedKeys.has(e.source) && edgeType(e) !== "contains") : [];
-      const dependentRepos = new Set(dependents.map((e) => e.source.split("::")[0]));
       const lines = [
         `# Changes since ${baseSha.slice(0, 7)} \u2014 ${repo}`,
         "",
         `## Changed files: ${changedFiles.length} (+${diff.added.length} / ~${diff.modified.length}), deleted ${diff.deleted.length}`,
         ...changedFiles.slice(0, 30).map((f) => `- ${f}`),
         "",
-        `## Affected entities: ${changedKeys.size}`,
-        ...[...changedKeys].slice(0, 30).map((k) => `- \`${k}\``),
+        `## Affected entities: ${changedKeys.length}`,
+        ...changedKeys.slice(0, 30).map((k) => `- \`${k}\``),
         "",
-        `## Dependents: ${dependents.length} edges from ${dependentRepos.size} repo(s)`,
-        ...dependents.slice(0, limit).map((e) => `- \`${e.source}\` \u2192 \`${e.target}\` (${edgeType(e) ?? "edge"})`),
+        `## Dependents: ${depTotal} edges from ${depRepos.length} repo(s)`,
+        ...dependents.map((e) => `- \`${e.source}\` \u2192 \`${e.target}\` (${e.type ?? "edge"})`),
         "",
-        `## Affected repos: ${[...dependentRepos].join(", ") || "none"}`
+        `## Affected repos: ${depRepos.join(", ") || "none"}`
       ];
-      return { content: [{ type: "text", text: lines.join("\n") }] };
+      return text(lines.join("\n"));
     }
     return null;
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esankhan3/code-search-mcp",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "MCP server for multi-repo code search — GitHub org or local path, zero config",
   "type": "module",
   "license": "MIT",