@esankhan3/code-search-mcp 1.1.2 → 1.1.4

package/dist/__tests__/graph-traversal.test.js

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 import { createSystemGraphSqliteWriter, getGraphStore, invalidateRetriever } from "@esankhan3/anvil-knowledge-core";
 import { handleGraphTool } from "../tools/graph.js";
 const MAX_NODES = 5e4;
+const FUZZY_CAP = 200;
 let tmp = "";
 let stashDataDir;
 function ctx(projectName) {
@@ -260,3 +261,43 @@ describe("traversal budget on a high-fan-out graph", () => {
     }
   });
 });
+describe("fuzzy resolution", () => {
+  before(async () => {
+    const names = [...Array.from({ length: 250 }, (_, i) => `handleThing${i}`), "ab"];
+    await writeGraph("fuzzy", [...names, "sink"].map((name) => ({ name })), names.map((s) => ({ s, t: "sink", type: "calls", confidence: 0.9 })));
+  });
+  it("a name matching more than FUZZY_CAP symbols starts from the first FUZZY_CAP and says so", async () => {
+    const store = await getGraphStore("fuzzy");
+    const firstBatch = [];
+    const orig = store.neighborEdges;
+    store.neighborEdges = (keys, ...rest) => {
+      firstBatch.push(keys.length);
+      return orig.call(store, keys, ...rest);
+    };
+    try {
+      const t = await call("fuzzy", "trace_path", { from: "thing", fuzzy: true });
+      assert.match(t, /^# Reachable from "thing"/);
+      assert.match(t, new RegExp(`"thing" matched more than ${FUZZY_CAP} symbols \u2014 be more specific`));
+      assert.equal(firstBatch[0], FUZZY_CAP);
+    } finally {
+      delete store.neighborEdges;
+    }
+    const deps = await call("fuzzy", "find_dependencies", { function: "Thing", fuzzy: true });
+    assert.match(deps, /sink/);
+    assert.match(deps, new RegExp(`matched more than ${FUZZY_CAP} symbols`));
+  });
+  it("no note under the cap", async () => {
+    const t = await call("fuzzy", "trace_path", { from: "Thing1", to: "sink", fuzzy: true });
+    assert.match(t, /^# Path \(1 hops\)/);
+    assert.doesNotMatch(t, /matched more than/);
+  });
+  it("a term under 3 characters is matched exactly, and the answer says so", async () => {
+    const t = await call("fuzzy", "trace_path", { from: "ab", to: "sink", fuzzy: true });
+    assert.match(t, /^# Path \(1 hops\)\n\nab → sink/);
+    assert.match(t, /needs at least 3 characters — "ab" was matched exactly/);
+    const none = await call("fuzzy", "find_callers", { function: "AB", fuzzy: true });
+    assert.match(none, /^No entity found matching "AB"/);
+    assert.match(none, /needs at least 3 characters/);
+    assert.doesNotMatch(none, /Try fuzzy:true/);
+  });
+});

package/dist/tools/graph.js

@@ -10,6 +10,7 @@ import {
   loadProfile,
   getAllChanges,
   getChangedFilesList,
+  FUZZY_MIN_CHARS,
   SYMMETRIC_EDGE_TYPES
 } from "@esankhan3/anvil-knowledge-core";
 import { resolvedKnowledgeConfig } from "../core/env-config.js";
@@ -105,6 +106,17 @@ function reachable(store, fromKeys, maxDepth, direction, types, budget, cap = 50
   }
   return out;
 }
+const FUZZY_MATCH_CAP = 200;
+function resolveKeys(store, name, repo, fuzzy) {
+  if (!fuzzy) return { keys: store.resolveNodes(name, repo).map((m) => m.key), note: "" };
+  const keys = store.resolveNodes(name, repo, true, FUZZY_MATCH_CAP + 1).map((m) => m.key);
+  const notes = [];
+  if ([...name].length < FUZZY_MIN_CHARS) notes.push(`_Fuzzy matching needs at least ${FUZZY_MIN_CHARS} characters \u2014 "${name}" was matched exactly._`);
+  if (keys.length > FUZZY_MATCH_CAP) notes.push(`_"${name}" matched more than ${FUZZY_MATCH_CAP} symbols \u2014 be more specific; using the first ${FUZZY_MATCH_CAP}._`);
+  return { keys: keys.slice(0, FUZZY_MATCH_CAP), note: notes.map((n) => `
+
+${n}`).join("") };
+}
 function endpointsIn(store, keys) {
   const types = store.nodeTypes(keys);
   return keys.filter((k) => types.get(k) === "external");
@@ -154,8 +166,8 @@ async function indexedSources(project, repo, files) {
   } catch {
   }
   const missing = new Set(files.filter((f) => !parts.has(f)));
-  if (missing.size > 0 && await getBlobStore(project, cfg).exists("chunks.json")) {
-    const found = await findChunksInProject(project, (c) => c.repoName === repo && missing.has(c.filePath), Number.POSITIVE_INFINITY, cfg);
+  if (missing.size > 0) {
+    const found = await findChunksInProject(project, (c) => c.repoName === repo && missing.has(c.filePath), Number.POSITIVE_INFINITY, cfg, repo);
     for (const c of found) {
       if (!parts.has(c.filePath)) parts.set(c.filePath, []);
       parts.get(c.filePath).push(c.content);
@@ -254,7 +266,7 @@ function registerGraphTools() {
         properties: {
           function: { type: "string", minLength: 1, description: "Symbol name or qualified id (repo::file::entity)" },
           repo: { type: "string", minLength: 1, description: "Limit resolution to this repo (optional)" },
-          fuzzy: { type: "boolean", description: "Case-insensitive substring match on symbol names instead of exact (default false)" },
+          fuzzy: { type: "boolean", description: "Case-insensitive substring match on symbol names instead of exact (default false). Needs 3+ characters (a shorter term matches exactly); uses the first 200 matches." },
           relations: relationsProp("callers")
         },
         required: ["function"]
@@ -268,7 +280,7 @@ function registerGraphTools() {
         properties: {
           function: { type: "string", minLength: 1, description: "Symbol name or qualified id (repo::file::entity)" },
           repo: { type: "string", minLength: 1, description: "Limit resolution to this repo (optional)" },
-          fuzzy: { type: "boolean", description: "Case-insensitive substring match on symbol names instead of exact (default false)" },
+          fuzzy: { type: "boolean", description: "Case-insensitive substring match on symbol names instead of exact (default false). Needs 3+ characters (a shorter term matches exactly); uses the first 200 matches." },
           relations: relationsProp("dependencies")
         },
         required: ["function"]
@@ -299,7 +311,7 @@ function registerGraphTools() {
           repo: { type: "string", minLength: 1, description: "Limit resolution to this repo (optional)" },
           direction: { type: "string", enum: ["callees", "callers", "both"], description: "Traverse callees (what it calls), callers (who calls it), or both. Default callees." },
           maxDepth: { type: "integer", minimum: 1, maximum: 10, description: "Max hops to traverse (default 4, max 10)" },
-          fuzzy: { type: "boolean", description: "Case-insensitive substring match on symbol names instead of exact (default false)" },
+          fuzzy: { type: "boolean", description: "Case-insensitive substring match on symbol names instead of exact (default false). Needs 3+ characters (a shorter term matches exactly); uses the first 200 matches." },
           relations: relationsProp("the traversal")
         },
         required: ["from"]
@@ -427,11 +439,10 @@ async function handleGraphTool(name, args, ctx) {
       const repoFilter = args.repo;
       const fuzzy = args.fuzzy === true;
       const types = edgeTypes(args);
-      const matched = store.resolveNodes(funcName, repoFilter, fuzzy);
-      if (matched.length === 0) {
-        return text(`No entity found matching "${funcName}"${repoFilter ? ` in ${repoFilter}` : ""}.${fuzzy ? "" : " Try fuzzy:true for substring matching."}`);
+      const { keys, note } = resolveKeys(store, funcName, repoFilter, fuzzy);
+      if (keys.length === 0) {
+        return text(`No entity found matching "${funcName}"${repoFilter ? ` in ${repoFilter}` : ""}.${fuzzy ? "" : " Try fuzzy:true for substring matching."}${note}`);
       }
-      const keys = matched.map((m) => m.key);
       const fetch = (t) => name === "find_callers" ? store.callers(keys, 30, t) : store.dependencies(keys, 30, t);
       const found = fetch(types);
       const noun = name === "find_callers" ? "callers" : "dependencies";
@@ -445,7 +456,7 @@ async function handleGraphTool(name, args, ctx) {
 Other relations: ${[...other].map(([t, n]) => `${t} ${n}`).join(", ")} \u2014 pass relations: ${JSON.stringify([...other.keys()])} to list them.` : "";
         return text(`${title}
 
-Matched ${matched.length} entit${matched.length === 1 ? "y" : "ies"}, but no ${noun} via ${relLabel}.${hint}`);
+Matched ${keys.length} entit${keys.length === 1 ? "y" : "ies"}, but no ${noun} via ${relLabel}.${hint}${note}`);
       }
       const byType = /* @__PURE__ */ new Map();
       for (const f of found) {
@@ -458,7 +469,7 @@ ${ks.map((k) => `- \`${k}\``).join("\n")}`).join("\n\n");
 
 ${found.length} found (${relLabel}):
 
-${sections}`);
+${sections}${note}`);
     }
     if (name === "impact_analysis") {
       const store = await getGraphStore(ctx.projectName, resolvedKnowledgeConfig());
@@ -513,18 +524,19 @@ ${sections}`);
       const fuzzy = args.fuzzy === true;
       const direction = args.direction ?? "callees";
       const maxDepth = 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}".${fuzzy ? "" : " Try fuzzy:true."}`);
+      const { keys: fromKeys, note: fromNote } = resolveKeys(store, from, repo, fuzzy);
+      if (fromKeys.length === 0) return text(`No entity found matching "${from}".${fuzzy ? "" : " Try fuzzy:true."}${fromNote}`);
       const types = edgeTypes(args);
       const budget = new TraversalBudget();
       if (to) {
-        const toKeys = store.resolveNodes(to, repo, fuzzy).map((m) => m.key);
-        if (toKeys.length === 0) return text(`No entity found matching target "${to}".${fuzzy ? "" : " Try fuzzy:true."}`);
+        const { keys: toKeys, note: toNote } = resolveKeys(store, to, repo, fuzzy);
+        if (toKeys.length === 0) return text(`No entity found matching target "${to}".${fuzzy ? "" : " Try fuzzy:true."}${toNote}`);
+        const notes = fromNote + toNote;
         const { path, depth } = shortestPath(store, fromKeys, toKeys, maxDepth, direction, types, budget);
         if (!path && budget.exhausted) {
-          return text(`No path from "${from}" to "${to}" found within the traversal budget (explored ${budget.explored} nodes, depth ${depth} of ${maxDepth}, direction: ${direction}) \u2014 narrow the search (repo, exact names, relations) or lower maxDepth.`);
+          return text(`No path from "${from}" to "${to}" found within the traversal budget (explored ${budget.explored} nodes, depth ${depth} of ${maxDepth}, direction: ${direction}) \u2014 narrow the search (repo, exact names, relations) or lower maxDepth.${notes}`);
         }
-        if (!path) return text(`No path from "${from}" to "${to}" within ${maxDepth} hops (direction: ${direction}).`);
+        if (!path) return text(`No path from "${from}" to "${to}" within ${maxDepth} hops (direction: ${direction}).${notes}`);
         const labelOf2 = store.labelsOf(path);
         const arrow = direction === "callers" ? " \u2190 " : " \u2192 ";
         const rendered = path.map((k) => labelOf2.get(k) ?? k).join(arrow);
@@ -532,13 +544,13 @@ ${sections}`);
 
 ${rendered}
 
-${path.map((k) => `- \`${k}\``).join("\n")}`);
+${path.map((k) => `- \`${k}\``).join("\n")}${notes}`);
       }
       const nodes = reachable(store, fromKeys, maxDepth, direction, types, budget);
       const stopped = budget.exhausted ? `
 
 _Stopped early at the traversal budget (explored ${budget.explored} nodes) \u2014 narrow the search or lower maxDepth._` : "";
-      if (nodes.length === 0) return text(`No ${direction} reachable from "${from}" within ${maxDepth} hops.${stopped}`);
+      if (nodes.length === 0) return text(`No ${direction} reachable from "${from}" within ${maxDepth} hops.${stopped}${fromNote}`);
       const labelOf = store.labelsOf(nodes.map((n) => n.key));
       const byDepth = /* @__PURE__ */ new Map();
       for (const { key, depth } of nodes) {
@@ -551,7 +563,7 @@ ${ks.map((k) => `- ${k}`).join("\n")}`).join("\n\n");
 
 ${nodes.length} nodes:
 
-${sections}${stopped}`);
+${sections}${stopped}${fromNote}`);
     }
     if (name === "find_dead_code") {
       const repo = args.repo;

package/dist/tools/search.js

@@ -1,4 +1,4 @@
-import { getRetriever, getBlobStore, findChunksInProject } from "@esankhan3/anvil-knowledge-core";
+import { getRetriever, findChunksInProject } from "@esankhan3/anvil-knowledge-core";
 import { resolvedKnowledgeConfig } from "../core/env-config.js";
 import { metrics } from "../observability/metrics.js";
 import { toolError, toolText, validateArgs } from "./validate.js";
@@ -139,15 +139,16 @@ async function handleGetCodeSnippet(args, ctx) {
       matches = scored.slice(0, 5).map((sc) => sc.chunk);
     } catch {
     }
-    if (matches.length === 0 && await getBlobStore(ctx.projectName, resolvedKnowledgeConfig()).exists("chunks.json")) {
+    if (matches.length === 0) {
       matches = await findChunksInProject(
         ctx.projectName,
         (c) => c.repoName === repo && c.filePath === file && (!entity || namesEntity(c, entity)),
         5,
-        resolvedKnowledgeConfig()
+        resolvedKnowledgeConfig(),
+        repo
       );
       if (matches.length === 0 && entity) {
-        matches = await findChunksInProject(ctx.projectName, (c) => c.repoName === repo && namesEntity(c, entity), 5, resolvedKnowledgeConfig());
+        matches = await findChunksInProject(ctx.projectName, (c) => c.repoName === repo && namesEntity(c, entity), 5, resolvedKnowledgeConfig(), repo);
       }
     }
     if (matches.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esankhan3/code-search-mcp",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "MCP server for multi-repo code search \u2014 GitHub org or local path, zero config",
   "type": "module",
   "license": "MIT",
@@ -24,7 +24,7 @@
   },
   "dependencies": {
     "@esankhan3/anvil-agent-core": "^0.5.0",
-    "@esankhan3/anvil-knowledge-core": "^0.4.8",
+    "@esankhan3/anvil-knowledge-core": "^0.4.10",
     "@modelcontextprotocol/node": "^2.0.0",
     "@modelcontextprotocol/server": "^2.0.0"
   },