@esankhan3/code-search-mcp 1.0.6 → 1.1.1

package/dist/__tests__/daemon-rpc-protocol.test.js

@@ -0,0 +1,95 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { createConnection } from "node:net";
+import { existsSync, rmSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { RpcServer } from "../daemon/rpc-server.js";
+import { tmp } from "./_harness.js";
+let dir;
+let server;
+let socketPath;
+let healthCalls = 0;
+const handlers = {
+  "search.code": async (p) => ({ query: p.query, totalTokens: 0, chunks: [] }),
+  "index.status": async () => ({}),
+  "index.force": async () => ({}),
+  "index.invalidate": async () => ({ ok: true }),
+  "health": () => {
+    healthCalls++;
+    return { ok: true, uptime: 1 };
+  }
+};
+before(async () => {
+  dir = tmp("cs-rpcp-");
+  socketPath = join(dir, "s.sock");
+  server = new RpcServer({ socketPath, handlers });
+  await server.start();
+});
+after(async () => {
+  await server.stop();
+  rmSync(dir, { recursive: true, force: true });
+});
+function exchange(lines, expect) {
+  return new Promise((resolve, reject) => {
+    const sock = createConnection(socketPath);
+    let buf = "";
+    const replies = [];
+    const done = () => {
+      sock.destroy();
+      resolve(replies);
+    };
+    let idle = setTimeout(done, 500);
+    sock.on("connect", () => sock.write(lines.map((l) => l + "\n").join("")));
+    sock.on("data", (c) => {
+      buf += c.toString();
+      let i;
+      while ((i = buf.indexOf("\n")) >= 0) {
+        replies.push(JSON.parse(buf.slice(0, i)));
+        buf = buf.slice(i + 1);
+      }
+      clearTimeout(idle);
+      if (replies.length >= expect) setTimeout(done, 100);
+      else idle = setTimeout(done, 500);
+    });
+    sock.on("error", reject);
+  });
+}
+describe("daemon RPC protocol", { skip: process.platform === "win32" }, () => {
+  it("does not dispatch prototype method names", async () => {
+    for (const method of ["constructor", "toString", "__proto__", "hasOwnProperty"]) {
+      const [r] = await exchange([JSON.stringify({ jsonrpc: "2.0", id: 1, method, params: {} })], 1);
+      assert.equal(r?.error?.code, -32601, `${method}: ${JSON.stringify(r)}`);
+    }
+  });
+  it("runs notifications without answering them", async () => {
+    const before2 = healthCalls;
+    const replies = await exchange([
+      JSON.stringify({ jsonrpc: "2.0", method: "health", params: {} }),
+      JSON.stringify({ jsonrpc: "2.0", method: "nope", params: {} }),
+      JSON.stringify({ jsonrpc: "2.0", id: 7, method: "health", params: {} })
+    ], 2);
+    assert.deepEqual(replies.map((r) => r.id), [7]);
+    assert.equal(healthCalls - before2, 2);
+  });
+  it("answers a batch with a single invalid-request error", async () => {
+    const replies = await exchange([JSON.stringify([
+      { jsonrpc: "2.0", id: 1, method: "health", params: {} },
+      { jsonrpc: "2.0", id: 2, method: "health", params: {} }
+    ])], 2);
+    assert.equal(replies.length, 1);
+    assert.equal(replies[0].id, null);
+    assert.equal(replies[0].error.code, -32600);
+  });
+  it("stop() leaves a socket file another server created", async () => {
+    const path = join(dir, "own.sock");
+    const a = new RpcServer({ socketPath: path, handlers });
+    await a.start();
+    unlinkSync(path);
+    const b = new RpcServer({ socketPath: path, handlers });
+    await b.start();
+    await a.stop();
+    assert.equal(existsSync(path), true);
+    await b.stop();
+    assert.equal(existsSync(path), false);
+  });
+});

package/dist/__tests__/daemon-runtime.test.js

@@ -0,0 +1,145 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { DaemonBackend } from "../backends/daemon-client.js";
+import {
+  BIN,
+  tmp,
+  makeWorkspace,
+  baseEnv,
+  spawnProc,
+  run,
+  waitFor,
+  exitWithin,
+  startFakeEmbedder
+} from "./_harness.js";
+let root;
+let ws;
+let dataDir;
+let embedder;
+let env;
+let wrapper;
+const sock = () => join(dataDir, "daemon", "ws.sock");
+const pidFile = () => join(dataDir, "daemon", "ws.pid");
+const client = () => new DaemonBackend({ project: "ws", workspaceDir: null, knowledge: {}, preferDaemon: true, socketPath: sock() });
+before(async () => {
+  root = tmp("cs-d-");
+  ws = makeWorkspace(root);
+  dataDir = join(root, "d");
+  embedder = await startFakeEmbedder(47394);
+  env = baseEnv({ home: join(root, "h"), dataDir, embedderUrl: embedder.url });
+});
+after(async () => {
+  wrapper?.kill();
+  try {
+    process.kill(Number(readFileSync(pidFile(), "utf-8")), "SIGKILL");
+  } catch {
+  }
+  await embedder.close();
+  rmSync(root, { recursive: true, force: true });
+});
+describe("daemon", { skip: process.platform === "win32" }, () => {
+  it("starts via the wrapper with --workspace . and names the project after the directory", async () => {
+    wrapper = spawnProc(BIN.cli, ["daemon", "--workspace", "."], env, ws);
+    await wrapper.waitForStderr(/initial index ready/, 6e4);
+    assert.equal(existsSync(sock()), true, "socket at <dataDir>/daemon/ws.sock");
+    const pid = Number(readFileSync(pidFile(), "utf-8"));
+    assert.ok(pid > 0 && pid !== wrapper.child.pid, "pid file holds the daemon (child) pid");
+    const status = JSON.parse((await run(BIN.cli, ["status", "--project", "ws"], env)).stdout);
+    assert.equal(status.daemonAlive, true);
+  });
+  it("refuses a second daemon for the same project", async () => {
+    const r = await run(BIN.daemon, ["--workspace", ws], env);
+    assert.equal(r.code, 1);
+    assert.match(r.stderr, /already running/);
+    assert.equal(await client().ping(), true, "the first daemon keeps its socket");
+  });
+  it("serves fresh results right after its own reindex, one run per watcher batch", async () => {
+    const before2 = await client().search("zebraQuasar", { mode: "bm25", maxResults: 20 });
+    assert.ok(!before2.chunks.some((c) => c.content.includes("zebraQuasar")));
+    const genFile = join(dataDir, "ws", "index_generation");
+    const gens = /* @__PURE__ */ new Set();
+    const poll = setInterval(() => {
+      try {
+        gens.add(readFileSync(genFile, "utf-8"));
+      } catch {
+      }
+    }, 5);
+    const startGen = readFileSync(genFile, "utf-8");
+    try {
+      const mark = wrapper.stderr().length;
+      appendFileSync(join(ws, "orders", "src", "orders.ts"), '\nexport function zebraQuasar() {\n  return "zebra quasar";\n}\n');
+      await waitFor(() => /reindex finished \(watcher\)/.test(wrapper.stderr().slice(mark)), 6e4, `watcher reindex
+${wrapper.stderr()}`);
+      const after2 = await client().search("zebraQuasar", { mode: "bm25", maxResults: 20 });
+      assert.ok(after2.chunks.some((c) => c.content.includes("zebraQuasar")), "the daemon must not serve its pre-reindex retriever");
+      await new Promise((r) => setTimeout(r, 2e3));
+      gens.delete(startGen);
+      assert.equal(gens.size, 2, `one index run (graph + embed phases) per batch, saw ${gens.size} generation bumps`);
+      assert.equal((wrapper.stderr().slice(mark).match(/reindex started \(watcher\)/g) ?? []).length, 1);
+    } finally {
+      clearInterval(poll);
+    }
+  });
+  it("drops invalidated rows from results immediately", async () => {
+    const hasBilling = async () => (await client().search("chargeOrder", { mode: "vector", maxResults: 50 })).chunks.some((c) => c.filePath === "src/billing.ts");
+    assert.equal(await hasBilling(), true);
+    await client().invalidate(["src/billing.ts"]);
+    assert.equal(await hasBilling(), false);
+  });
+  it("honours --no-daemon", async () => {
+    const args = ["query", "--project", "ws", "--mode", "vector", "--format", "json", "--embedding.base-url", "http://127.0.0.1:9", "zebra"];
+    assert.equal((await run(BIN.cli, args, env)).code, 0, "routed to the daemon");
+    assert.notEqual((await run(BIN.cli, [...args, "--no-daemon"], env)).code, 0, "searched in-process");
+  });
+  it("the wrapper forwards SIGTERM; the daemon removes its own socket + pid file", async () => {
+    wrapper.child.kill("SIGTERM");
+    const exit = await exitWithin(wrapper, 1e4);
+    assert.notEqual(exit, "timeout", "wrapper must exit on SIGTERM");
+    assert.equal(existsSync(sock()), false);
+    assert.equal(existsSync(pidFile()), false);
+  });
+  it("status sees a SIGKILLed daemon as dead and a new daemon replaces its stale socket", async () => {
+    const d = spawnProc(BIN.daemon, ["--workspace", ws], env);
+    try {
+      await d.waitForStderr(/initial index ready/, 6e4);
+      d.child.kill("SIGKILL");
+      await d.exited;
+      assert.equal(existsSync(sock()), true, "stale socket left behind");
+      const status = JSON.parse((await run(BIN.cli, ["status", "--project", "ws"], env)).stdout);
+      assert.equal(status.daemonAlive, false);
+      const d2 = spawnProc(BIN.daemon, ["--workspace", ws], env);
+      try {
+        await d2.waitForStderr(/RPC listening/, 3e4);
+        await waitFor(() => client().ping(), 1e4, "second daemon answering");
+      } finally {
+        d2.child.kill("SIGTERM");
+        await exitWithin(d2, 1e4);
+      }
+    } finally {
+      d.kill();
+    }
+  });
+});
+describe("reset", () => {
+  it("rejects names that escape or collide inside the data dir", async () => {
+    const dd = join(root, "rp", "inner", "dd");
+    mkdirSync(join(dd, "daemon"), { recursive: true });
+    mkdirSync(join(dd, "projects"), { recursive: true });
+    writeFileSync(join(root, "rp", "keep.txt"), "x");
+    const e = { ...env, CODE_SEARCH_DATA_DIR: dd };
+    for (const bad of ["..", ".", "daemon", "projects", "a/b", "../inner"]) {
+      const r = await run(BIN.cli, ["reset", "--project", bad], e);
+      assert.equal(r.code, 2, `${bad}: ${r.stderr}`);
+    }
+    assert.equal(existsSync(join(root, "rp", "keep.txt")), true);
+    assert.equal(existsSync(join(dd, "daemon")), true);
+    assert.equal(existsSync(join(dd, "projects")), true);
+    mkdirSync(join(dd, "p1", "lancedb"), { recursive: true });
+    const ok = await run(BIN.cli, ["reset", "--project", "p1"], e);
+    assert.equal(ok.code, 0, ok.stderr);
+    assert.equal(existsSync(join(dd, "p1")), false);
+    assert.equal(existsSync(dd), true);
+  });
+});

package/dist/__tests__/graph-tools-store.test.js

@@ -0,0 +1,314 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+import {
+  createSystemGraphSqliteWriter,
+  invalidateRetriever
+} from "@esankhan3/anvil-knowledge-core";
+import { handleGraphTool } from "../tools/graph.js";
+const PROJECT = "gts";
+let tmp = "";
+let ws = "";
+let headSha = "";
+let stashDataDir;
+function ctx(directoryPath = null) {
+  return {
+    projectName: PROJECT,
+    directoryPath,
+    indexReady: true,
+    startedAt: 0,
+    indexing: {
+      status: "idle",
+      phase: null,
+      message: null,
+      percent: 0,
+      startedAt: null,
+      error: null,
+      lastSuccess: null,
+      lastDurationMs: 0,
+      history: []
+    }
+  };
+}
+const text = (r) => r?.content?.[0]?.text ?? "";
+const call = (name, args, c = ctx()) => handleGraphTool(name, args, c);
+const SERVER_TS = [
+  "import express from 'express';",
+  "const app = express();",
+  "export async function getOrderById(req: any, res: any) {",
+  "  res.json({ id: req.params.id });",
+  "}",
+  "export function listOrders(req: any, res: any) {",
+  "  res.json([]);",
+  "}",
+  "export function publishOrderCreated(order: any) {",
+  "  return order;",
+  "}",
+  "app.get('/api/orders/:id', getOrderById);",
+  "app.get('/api/orders', listOrders);"
+].join("\n") + "\n";
+const REFUNDS_TS = "export function refund(id: string) {\n  return id;\n}\n";
+const mod = (file) => ({ id: file, label: file.split("/").pop(), type: "module", file });
+const ent = (file, name, type = "function") => ({ id: `${file}::${name}`, label: name, type, file });
+const contains = (file, name) => ({ source: file, target: `${file}::${name}`, type: "contains", confidence: 1 });
+const rel = (s, t, type, confidence = 0.9) => ({ source: s, target: t, type, confidence });
+const ORDERS = {
+  nodes: [
+    mod("src/server.ts"),
+    ent("src/server.ts", "getOrderById"),
+    ent("src/server.ts", "listOrders"),
+    ent("src/server.ts", "publishOrderCreated"),
+    mod("src/models.ts"),
+    ent("src/models.ts", "LineItem", "interface"),
+    ent("src/models.ts", "Order", "class"),
+    ent("src/models.ts", "total", "method"),
+    mod("src/checkout.ts"),
+    ent("src/checkout.ts", "checkoutHandler"),
+    mod("src/cart.ts"),
+    ent("src/cart.ts", "cartTotal"),
+    mod("src/refunds.ts"),
+    ent("src/refunds.ts", "refund"),
+    mod("src/pipeline/chainA.ts"),
+    ent("src/pipeline/chainA.ts", "startPipeline"),
+    mod("src/pipeline/chainB.ts"),
+    ent("src/pipeline/chainB.ts", "stepTwo"),
+    mod("src/pipeline/stepThree.ts"),
+    ent("src/pipeline/stepThree.ts", "stepThree")
+  ],
+  links: [
+    contains("src/server.ts", "getOrderById"),
+    contains("src/server.ts", "listOrders"),
+    contains("src/server.ts", "publishOrderCreated"),
+    contains("src/models.ts", "LineItem"),
+    contains("src/models.ts", "Order"),
+    { source: "src/models.ts::Order", target: "src/models.ts::total", type: "contains", confidence: 1 },
+    contains("src/checkout.ts", "checkoutHandler"),
+    contains("src/cart.ts", "cartTotal"),
+    contains("src/refunds.ts", "refund"),
+    contains("src/pipeline/chainA.ts", "startPipeline"),
+    contains("src/pipeline/chainB.ts", "stepTwo"),
+    contains("src/pipeline/stepThree.ts", "stepThree"),
+    rel("src/pipeline/chainA.ts::startPipeline", "src/pipeline/chainB.ts::stepTwo", "calls"),
+    rel("src/pipeline/chainB.ts::stepTwo", "src/pipeline/stepThree.ts::stepThree", "calls"),
+    rel("src/pipeline/chainA.ts", "src/pipeline/chainB.ts", "imports", 1),
+    rel("src/pipeline/chainA.ts", "src/pipeline/chainB.ts::stepTwo", "uses", 0.95),
+    rel("src/server.ts::getOrderById", "src/models.ts::LineItem", "type-ref", 0.85),
+    rel("src/cart.ts::cartTotal", "src/checkout.ts::checkoutHandler", "calls"),
+    rel("src/checkout.ts::checkoutHandler", "src/server.ts::getOrderById", "calls"),
+    rel("src/checkout.ts::checkoutHandler", "src/refunds.ts::refund", "calls"),
+    rel("src/checkout.ts", "src/refunds.ts", "imports", 1)
+  ]
+};
+const WEB = { nodes: [mod("src/api/orders.ts"), ent("src/api/orders.ts", "fetchOrder")], links: [contains("src/api/orders.ts", "fetchOrder")] };
+const ANALYTICS = { nodes: [mod("consumer.py"), ent("consumer.py", "consume")], links: [contains("consumer.py", "consume")] };
+const MONO = {
+  nodes: [{ id: "pkg::@m/a", label: "@m/a", type: "package", file: "packages/a" }, { id: "pkg::@m/b", label: "@m/b", type: "package", file: "packages/b" }],
+  links: []
+};
+const CROSS = [
+  {
+    sourceRepo: "web-app",
+    sourceNode: "src/api/orders.ts::/api/orders/:param",
+    targetRepo: "orders-svc",
+    targetNode: "src/server.ts::/api/orders/:param",
+    edgeType: "http",
+    evidence: "API endpoint: /api/orders/:param",
+    confidence: 0.8
+  },
+  {
+    sourceRepo: "analytics-py",
+    sourceNode: "consumer.py::order-created",
+    targetRepo: "orders-svc",
+    targetNode: "src/server.ts::order-created",
+    edgeType: "event-schema",
+    evidence: "Shared event/topic: order-created",
+    confidence: 0.85
+  },
+  {
+    sourceRepo: "mono",
+    sourceNode: "pkg::@m/a",
+    targetRepo: "mono",
+    targetNode: "pkg::@m/b",
+    edgeType: "workspace-dep",
+    evidence: "@m/a depends on @m/b (packages/a/package.json)",
+    confidence: 1
+  }
+];
+function chunk(filePath, startLine, endLine, entityName, content) {
+  return { id: `${filePath}:${startLine}`, repoName: "orders-svc", filePath, startLine, endLine, entityName, content, language: "typescript" };
+}
+const serverLines = SERVER_TS.split("\n");
+const lines = (a, b) => serverLines.slice(a - 1, b).join("\n");
+const CHUNKS = [
+  chunk("src/server.ts", 1, 2, void 0, lines(1, 2)),
+  chunk("src/server.ts", 3, 5, "getOrderById", lines(3, 5)),
+  chunk("src/server.ts", 6, 8, "listOrders", lines(6, 8)),
+  chunk("src/server.ts", 9, 13, "publishOrderCreated", lines(9, 13)),
+  chunk("src/refunds.ts", 1, 3, "refund", REFUNDS_TS.trimEnd())
+];
+const git = (cwd, ...a) => execFileSync("git", ["-c", "user.email=t@t", "-c", "user.name=t", "-c", "commit.gpgsign=false", ...a], { cwd, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+before(async () => {
+  stashDataDir = process.env.CODE_SEARCH_DATA_DIR;
+  tmp = mkdtempSync(join(tmpdir(), "cs-gts-"));
+  process.env.CODE_SEARCH_DATA_DIR = tmp;
+  const kb = join(tmp, PROJECT);
+  mkdirSync(join(kb, "orders-svc"), { recursive: true });
+  const w = await createSystemGraphSqliteWriter(kb);
+  assert.ok(w, "no sqlite driver");
+  for (const [name, g] of [["orders-svc", ORDERS], ["web-app", WEB], ["analytics-py", ANALYTICS], ["mono", MONO]]) w.addRepoGraph(name, g);
+  w.addCrossRepoEdges(CROSS);
+  w.finalize();
+  writeFileSync(join(kb, "orders-svc", "graph.json"), JSON.stringify(ORDERS));
+  writeFileSync(join(kb, "chunks.json"), CHUNKS.map((c) => JSON.stringify(c)).join("\n") + "\n");
+  ws = mkdtempSync(join(tmpdir(), "cs-gts-ws-"));
+  const repo = join(ws, "orders-svc");
+  mkdirSync(join(repo, "src"), { recursive: true });
+  writeFileSync(join(repo, "src", "server.ts"), SERVER_TS);
+  writeFileSync(join(repo, "src", "refunds.ts"), REFUNDS_TS);
+  git(repo, "init", "-q");
+  git(repo, "add", "-A");
+  git(repo, "commit", "-qm", "init");
+  headSha = git(repo, "rev-parse", "HEAD");
+});
+after(async () => {
+  await invalidateRetriever();
+  rmSync(tmp, { recursive: true, force: true });
+  rmSync(ws, { recursive: true, force: true });
+  if (stashDataDir === void 0) delete process.env.CODE_SEARCH_DATA_DIR;
+  else process.env.CODE_SEARCH_DATA_DIR = stashDataDir;
+});
+describe("get_cross_repo_edges", () => {
+  it("names the evidence behind each edge", async () => {
+    const t = text(await call("get_cross_repo_edges", { repo: "web-app" }));
+    assert.match(t, /web-app → orders-svc \(http\).*API endpoint: \/api\/orders\/:param/);
+  });
+  it("lists same-repo workspace-dep edges in their own section", async () => {
+    const t = text(await call("get_cross_repo_edges", {}));
+    assert.match(t, /## Within a repo/);
+    assert.match(t, /mono: @m\/a → @m\/b \(workspace-dep\).*@m\/a depends on @m\/b/);
+  });
+});
+describe("impact_analysis", () => {
+  it("counts the other side of a symmetric edge as a dependent", async () => {
+    const t = text(await call("impact_analysis", { repo: "analytics-py", file: "consumer.py" }));
+    assert.match(t, /Affected repos: orders-svc/);
+  });
+  it("entity scope: file-level cross-repo dependents + multi-hop callers", async () => {
+    const t = text(await call("impact_analysis", { repo: "orders-svc", file: "src/server.ts", entity: "getOrderById" }));
+    assert.match(t, /checkoutHandler/);
+    assert.match(t, /cartTotal/);
+    assert.match(t, /web-app.*file-level/);
+    assert.match(t, /Affected repos: .*web-app/);
+    const shallow = text(await call("impact_analysis", { repo: "orders-svc", file: "src/server.ts", entity: "getOrderById", depth: 1 }));
+    assert.doesNotMatch(shallow, /cartTotal/);
+  });
+  it("accepts the full id as entity", async () => {
+    const t = text(await call("impact_analysis", { repo: "orders-svc", file: "src/server.ts", entity: "orders-svc::src/server.ts::getOrderById" }));
+    assert.match(t, /checkoutHandler/);
+  });
+  it("a file with no graph nodes is an error, not an empty report", async () => {
+    const r = await call("impact_analysis", { repo: "orders-svc", file: "src/nope.ts" });
+    assert.equal(r.isError, true);
+    assert.match(text(r), /No graph nodes/);
+  });
+});
+describe("symbol resolution", () => {
+  it("trace_path accepts a full repo::file::entity id", async () => {
+    const t = text(await call("trace_path", { from: "orders-svc::src/pipeline/chainA.ts::startPipeline", to: "stepThree" }));
+    assert.match(t, /2 hops/);
+  });
+  it('exact names are literal: "%" matches nothing', async () => {
+    assert.match(text(await call("find_callers", { function: "%" })), /No entity found/);
+  });
+  it("fuzzy trace_path matches symbol names, never a 0-hop file match", async () => {
+    const t = text(await call("trace_path", { from: "Pipeline", to: "Three", fuzzy: true }));
+    assert.match(t, /2 hops/);
+    assert.doesNotMatch(t, /0 hops/);
+  });
+});
+describe("relation-typed traversal", () => {
+  it("find_callers returns call edges only by default", async () => {
+    const t = text(await call("find_callers", { function: "stepTwo" }));
+    assert.match(t, /startPipeline/);
+    assert.doesNotMatch(t, /chainA\.ts`/);
+  });
+  it("other relations are named, and listed on request", async () => {
+    const t = text(await call("find_callers", { function: "LineItem" }));
+    assert.match(t, /no callers/i);
+    assert.match(t, /type-ref/);
+    const typed = text(await call("find_callers", { function: "LineItem", relations: ["type-ref"] }));
+    assert.match(typed, /## type-ref \(1\)[\s\S]*getOrderById/);
+  });
+  it("find_dependencies defaults to calls", async () => {
+    const t = text(await call("find_dependencies", { function: "checkoutHandler" }));
+    assert.match(t, /getOrderById/);
+    assert.match(t, /refund/);
+  });
+});
+describe("search_graph", () => {
+  it("name is a regex over symbol names", async () => {
+    const t = text(await call("search_graph", { name: "^step.*$" }));
+    assert.match(t, /stepTwo/);
+    assert.match(t, /stepThree/);
+    assert.doesNotMatch(t, /\(module/);
+  });
+  it("type filter matches any node type the graph has", async () => {
+    assert.match(text(await call("search_graph", { type: "method" })), /`total`/);
+  });
+  it("rejects an invalid regex", async () => {
+    const r = await call("search_graph", { name: "(" });
+    assert.equal(r.isError, true);
+    assert.match(text(r), /Invalid regex/);
+  });
+});
+describe("get_repo_graph", () => {
+  it("lists edges, bounded by limit", async () => {
+    const t = text(await call("get_repo_graph", { repo: "orders-svc", limit: 2 }));
+    assert.match(t, /## Edges/);
+    assert.match(t, /startPipeline` → `src\/pipeline\/chainB\.ts::stepTwo` \(calls\)/);
+    assert.equal((t.split("## Edges")[1].match(/^- /gm) ?? []).length, 2);
+  });
+  it("validates repo", async () => {
+    const missing = await call("get_repo_graph", {});
+    assert.equal(missing.isError, true);
+    const unknown = await call("get_repo_graph", { repo: "nope" });
+    assert.equal(unknown.isError, true);
+  });
+});
+describe("find_dead_code", () => {
+  it("does not flag a function referenced elsewhere in its file", async () => {
+    const t = text(await call("find_dead_code", { repo: "orders-svc" }));
+    assert.match(t, /publishOrderCreated/);
+    assert.doesNotMatch(t, /listOrders/);
+  });
+});
+describe("detect_changes", () => {
+  it("reports only the entities whose lines changed", async () => {
+    const repo = join(ws, "orders-svc");
+    writeFileSync(join(repo, "src", "server.ts"), SERVER_TS.replace("res.json({ id: req.params.id });", "res.json({ id: Number(req.params.id) });"));
+    try {
+      const t = text(await call("detect_changes", { repo: "orders-svc", baseSha: headSha }, ctx(ws)));
+      const affected = t.split("## Affected entities")[1].split("##")[0];
+      assert.match(affected, /getOrderById/);
+      assert.doesNotMatch(affected, /listOrders|publishOrderCreated/);
+      assert.match(t, /checkoutHandler/);
+    } finally {
+      git(repo, "checkout", "--", ".");
+    }
+  });
+  it("reports deleted files, their entities and dependents", async () => {
+    const repo = join(ws, "orders-svc");
+    git(repo, "rm", "-q", "src/refunds.ts");
+    try {
+      const t = text(await call("detect_changes", { repo: "orders-svc", baseSha: headSha }, ctx(ws)));
+      assert.match(t, /Deleted files: 1[\s\S]*src\/refunds\.ts/);
+      assert.match(t.split("## Affected entities")[1], /refund/);
+      assert.match(t, /checkoutHandler` → `orders-svc::src\/refunds\.ts::refund/);
+    } finally {
+      git(repo, "reset", "-q", "--hard");
+    }
+  });
+});

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

@@ -1,6 +1,6 @@
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, appendFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -57,7 +57,9 @@ const REPO_GRAPH = {
   ]
 };
 const CHUNKS = [
-  { id: "c1", repoName: "app", filePath: "a.ts", entityName: "handleRequest", startLine: 1, endLine: 3, content: "function handleRequest() { return 1; }", language: "typescript" }
+  { id: "c1", repoName: "app", filePath: "a.ts", entityName: "handleRequest", startLine: 1, endLine: 3, content: "function handleRequest() { return 1; }", language: "typescript" },
+  { id: "c2", repoName: "app", filePath: "ui.ts", entityName: "render", parentEntity: "Board", startLine: 2, endLine: 2, content: 'render() { return "board"; }', language: "typescript" },
+  { id: "c3", repoName: "app", filePath: "ui.ts", entityName: "render", parentEntity: "Card", startLine: 5, endLine: 5, content: 'render() { return "card"; }', language: "typescript" }
 ];
 const PROJECT_GRAPH = {
   architectureSummary: "Two services talk over HTTP.",
@@ -141,6 +143,11 @@ describe("get_code_snippet", () => {
     const r = await handleSearchTool("get_code_snippet", { id: "app::a.ts::handleRequest" }, ctx());
     assert.match(text(r), /function handleRequest/);
   });
+  it("resolves a class-qualified method id to that class's method", async () => {
+    const t = text(await handleSearchTool("get_code_snippet", { id: "app::ui.ts::Card.render" }, ctx()));
+    assert.match(t, /"card"/);
+    assert.doesNotMatch(t, /"board"/);
+  });
   it("reports when nothing matches", async () => {
     const r = await handleSearchTool("get_code_snippet", { id: "app::a.ts::nope" }, ctx());
     assert.match(text(r), /No snippet found/);
@@ -187,11 +194,11 @@ describe("detect_changes", () => {
       git("config user.name test");
       git("config commit.gpgsign false");
       writeFileSync(join(repoDir, "a.ts"), "export function handleRequest() {}\n");
-      writeFileSync(join(repoDir, "b.ts"), "export function dbQuery() {}\n");
+      writeFileSync(join(repoDir, "b.ts"), "export function dbQuery() {\n  return 1;\n}\n");
       git("add -A");
       git("commit -q -m init");
       baseSha = execSync("git rev-parse HEAD", { cwd: repoDir }).toString().trim();
-      appendFileSync(join(repoDir, "b.ts"), "// touched\n");
+      writeFileSync(join(repoDir, "b.ts"), "export function dbQuery() {\n  return 2;\n}\n");
     } catch {
       rmSync(ws, { recursive: true, force: true });
       return;