@esankhan3/code-search-mcp 1.0.6 → 1.1.1

package/dist/__tests__/remote-proxy.test.js

@@ -0,0 +1,105 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { rmSync } from "node:fs";
+import { Client } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import { BIN, tmp, baseEnv } from "./_harness.js";
+const PORT = 47389;
+const GOOD_KEY = "good-key-1234";
+let remote;
+let root;
+before(async () => {
+  root = tmp("cs-proxy-");
+  remote = createServer((req, res) => {
+    if (req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", project: "remote", indexReady: true }));
+      return;
+    }
+    let body = "";
+    req.on("data", (c) => {
+      body += c.toString();
+    });
+    req.on("end", () => {
+      if (req.headers.authorization !== `Bearer ${GOOD_KEY}`) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid API key" }));
+        return;
+      }
+      const msg = JSON.parse(body);
+      if (msg.method === "initialize") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ jsonrpc: "2.0", id: msg.id, result: { protocolVersion: "2024-11-05", capabilities: {}, serverInfo: { name: "fake", version: "0" } } }));
+        return;
+      }
+      if (msg.method === "resources/list") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ jsonrpc: "2.0", id: msg.id, error: { code: -32601, message: "Method not found: resources/list" } }));
+        return;
+      }
+      const reply = JSON.stringify({ jsonrpc: "2.0", id: msg.id, result: { tools: [{ name: "remote_tool", inputSchema: { type: "object" } }] } });
+      const half = Math.floor(reply.length / 2);
+      res.writeHead(200, { "Content-Type": "text/event-stream" });
+      res.end(
+        `event: message
+data: ${JSON.stringify({ jsonrpc: "2.0", method: "notifications/message", params: { level: "info", data: "hi" } })}
+
+event: message
+data: ${JSON.stringify({ jsonrpc: "2.0", id: 999, result: { tools: [] } })}
+
+event: message
+data: ${reply.slice(0, half)}
+data: ${reply.slice(half)}
+
+`
+      );
+    });
+  });
+  await new Promise((r) => remote.listen(PORT, "127.0.0.1", () => r()));
+});
+after(async () => {
+  remote.closeAllConnections();
+  await new Promise((r) => remote.close(r));
+  rmSync(root, { recursive: true, force: true });
+});
+async function proxyClient(key) {
+  const client = new Client({ name: "proxy-test", version: "1.0.0" });
+  const env = baseEnv({ home: join(root, "home") });
+  await client.connect(new StdioClientTransport({
+    command: process.execPath,
+    args: [BIN.mcp, "--remote", `http://127.0.0.1:${PORT}`, "--api-key", key],
+    env,
+    stderr: "pipe"
+  }));
+  return client;
+}
+describe("remote proxy", () => {
+  it("surfaces upstream auth failures as JSON-RPC errors", async () => {
+    const client = await proxyClient("wrong-key");
+    try {
+      await assert.rejects(() => client.listTools(), /401/);
+      await assert.rejects(() => client.listResources(), /401/);
+    } finally {
+      await client.close();
+    }
+  });
+  it("relays a remote JSON-RPC error", async () => {
+    const client = await proxyClient(GOOD_KEY);
+    try {
+      await assert.rejects(() => client.listResources(), /Method not found: resources\/list/);
+    } finally {
+      await client.close();
+    }
+  });
+  it("picks the SSE event answering its request id", async () => {
+    const client = await proxyClient(GOOD_KEY);
+    try {
+      const { tools } = await client.listTools();
+      assert.deepEqual(tools.map((t) => t.name), ["remote_tool"]);
+    } finally {
+      await client.close();
+    }
+  });
+});

package/dist/__tests__/server-cli-args.test.js

@@ -0,0 +1,146 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import {
+  BIN,
+  tmp,
+  makeWorkspace,
+  baseEnv,
+  spawnProc,
+  run,
+  getJson,
+  waitFor,
+  startFakeEmbedder
+} from "./_harness.js";
+let root;
+let ws;
+let embedder;
+let env;
+before(async () => {
+  root = tmp("cs-args-");
+  ws = makeWorkspace(root);
+  embedder = await startFakeEmbedder(47390);
+  env = baseEnv({ home: join(root, "home"), dataDir: join(root, "data"), embedderUrl: embedder.url });
+});
+after(async () => {
+  await embedder.close();
+  rmSync(root, { recursive: true, force: true });
+});
+async function printConfig(args, cwd, extra = {}) {
+  const r = await run(BIN.mcp, ["--print-config", ...args], { ...env, ...extra }, cwd);
+  assert.equal(r.code, 0, r.stderr);
+  return { cfg: JSON.parse(r.stdout), stderr: r.stderr };
+}
+describe("code-search-mcp argv", () => {
+  it("--print-config reports dotted flags and --port under server.port", async () => {
+    const { cfg } = await printConfig(["--serve", "--port", "47381", "--retrieval.max-chunks", "12"]);
+    assert.equal(cfg.server.port, 47381);
+    assert.equal(cfg.retrieval.maxChunks, 12);
+    assert.equal(cfg.port, void 0);
+  });
+  it("--print-config flags an invalid reindex interval as disabled", async () => {
+    const { cfg, stderr } = await printConfig([], void 0, { CODE_SEARCH_REINDEX_INTERVAL: "90s" });
+    assert.equal(cfg.indexing.reindexIntervalMs, 0);
+    assert.match(stderr, /invalid reindex interval "90s"/i);
+  });
+  it("--print-config applies the cwd .code-search.yaml layer", async () => {
+    const dir = tmp("cs-wsy-");
+    writeFileSync(join(dir, ".code-search.yaml"), "retrieval:\n  max_chunks: 17\n");
+    const { cfg } = await printConfig([], dir);
+    assert.equal(cfg.retrieval.maxChunks, 17);
+    const cli = await run(BIN.cli, ["--print-config"], env, dir);
+    assert.equal(JSON.parse(cli.stdout).retrieval.maxChunks, 17);
+  });
+  it("serve mode accepts dotted flags, --serve <path>, and any mode-flag order", async () => {
+    const variants = [
+      ["--serve", ws, "--port", "47381", "--retrieval.max-chunks", "12"],
+      ["--serve", "--local", ws, "--port", "47381"],
+      ["--local", ws, "--serve", "--port", "47381"]
+    ];
+    for (const args of variants) {
+      const p = spawnProc(BIN.mcp, args, env);
+      try {
+        await waitFor(async () => (await getJson("http://127.0.0.1:47381/health")).status === 200, 2e4, `health for ${args.join(" ")}
+${p.stderr()}`);
+        const status = await getJson("http://127.0.0.1:47381/status");
+        assert.equal(status.body.directoryPath, ws, args.join(" "));
+        assert.match(p.stderr(), /LLM: disabled/);
+      } finally {
+        p.kill();
+        await p.exited;
+      }
+    }
+  });
+  it("--transport sse fails clearly instead of starting another transport", async () => {
+    const r = await run(BIN.mcp, ["--serve", "--port", "47382", "--transport", "sse"], env);
+    assert.equal(r.code, 2);
+    assert.match(r.stderr, /SSE transport is not supported/);
+  });
+  it("unknown flags exit 2", async () => {
+    const r = await run(BIN.mcp, ["--serve", "--retrieval.max-chunkz", "3"], env);
+    assert.equal(r.code, 2);
+    assert.match(r.stderr, /unknown flag.*--retrieval\.max-chunkz/i);
+  });
+});
+describe("code-search subcommands", () => {
+  it("index --project p <dir> indexes <dir> as p and reports cross-repo edges", async () => {
+    const r = await run(BIN.cli, ["index", "--project", "wsx", ws], env);
+    assert.equal(r.code, 0, r.stderr);
+    const out = JSON.parse(r.stdout);
+    assert.equal(out.project, "wsx");
+    assert.equal(out.repos, 2);
+    assert.ok(out.crossRepoEdges >= 1, `crossRepoEdges=${out.crossRepoEdges}`);
+  });
+  it("query takes the positional text even after flags", async () => {
+    const r = await run(BIN.cli, ["query", "--project", "wsx", "--mode", "bm25", "--format", "json", "--no-daemon", "welcome email"], env);
+    assert.equal(r.code, 0, r.stderr);
+    assert.equal(JSON.parse(r.stdout).query, "welcome email");
+  });
+  it("rejects unknown flags and invalid --format / --top-k with exit 2", async () => {
+    for (const args of [
+      ["query", "--retrieval.max-chunkz", "3", "x"],
+      ["query", "--format", "xml", "x"],
+      ["query", "--top-k", "abc", "x"],
+      ["query", "--top-k", "0", "x"],
+      ["index", "--top-k", "3", ws],
+      ["status", "--bogus"]
+    ]) {
+      const r = await run(BIN.cli, args, env);
+      assert.equal(r.code, 2, `${args.join(" ")} \u2192 ${r.code}
+${r.stderr}`);
+    }
+  });
+  it("status reports where the KB lives and never creates dirs for unknown projects", async () => {
+    const r = await run(BIN.cli, ["status", "--project", "nope"], env);
+    assert.equal(r.code, 0, r.stderr);
+    const s = JSON.parse(r.stdout);
+    assert.equal(s.indexed, false);
+    assert.equal(s.daemonAlive, false);
+    assert.equal(existsSync(join(root, "data", "nope")), false);
+    const ok = JSON.parse((await run(BIN.cli, ["status", "--project", "wsx"], env)).stdout);
+    assert.equal(ok.indexed, true);
+    assert.equal(ok.kbPath, join(root, "data", "wsx"));
+  });
+  it("storage.dataDir from the CLI moves the KB", async () => {
+    const { CODE_SEARCH_DATA_DIR: _drop, ...noDataDir } = env;
+    const dd = join(root, "dd2");
+    const r = await run(BIN.cli, ["index", ws, "--project", "moved", "--storage.data-dir", dd], noDataDir);
+    assert.equal(r.code, 0, r.stderr);
+    assert.ok(existsSync(join(dd, "moved", "index_stats.json")), "KB written under --storage.data-dir");
+    assert.equal(existsSync(join(root, "home", ".anvil", "knowledge-base", "moved")), false);
+    const s = JSON.parse((await run(BIN.cli, ["status", "--project", "moved", "--storage.data-dir", dd], noDataDir)).stdout);
+    assert.equal(s.dataDir, dd);
+    assert.equal(s.indexed, true);
+  });
+  it("bare `code-search mcp` serves the cwd over stdio (as its help says)", async () => {
+    const p = spawnProc(BIN.cli, ["mcp", "--project", "wsx"], env, ws);
+    try {
+      await p.waitForStderr(/Server running for "wsx" \(stdio\)/);
+      assert.doesNotMatch(p.stderr(), /No remote server configured/);
+    } finally {
+      p.kill();
+      await p.exited;
+    }
+  });
+});

package/dist/__tests__/server-lifecycle.test.js

@@ -0,0 +1,108 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import {
+  BIN,
+  tmp,
+  makeWorkspace,
+  baseEnv,
+  spawnProc,
+  getJson,
+  waitFor,
+  exitWithin,
+  startFakeEmbedder
+} from "./_harness.js";
+const PKG_VERSION = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8")).version;
+let root;
+let ws;
+let slow;
+let fast;
+before(async () => {
+  root = tmp("cs-life-");
+  ws = makeWorkspace(root);
+  slow = await startFakeEmbedder(47391, { delayMs: 2500 });
+  fast = await startFakeEmbedder(47392);
+});
+after(async () => {
+  await slow.close();
+  await fast.close();
+  rmSync(root, { recursive: true, force: true });
+});
+describe("HTTP server lifecycle", () => {
+  it("answers /health and /ready during the startup index, then serves", async () => {
+    const env = baseEnv({ home: join(root, "home"), dataDir: join(root, "data1"), embedderUrl: slow.url });
+    const p = spawnProc(BIN.mcp, ["--local", ws, "--serve", "--port", "47383"], env);
+    const base = "http://127.0.0.1:47383";
+    try {
+      await waitFor(async () => (await getJson(`${base}/health`)).status === 200, 2e4, `health
+${p.stderr()}`);
+      const early = await getJson(`${base}/ready`);
+      assert.equal(early.status, 503, "not ready while the first index is still embedding");
+      assert.equal(early.body.ready, false);
+      await waitFor(async () => (await getJson(`${base}/ready`)).status === 200, 6e4, `ready
+${p.stderr()}`);
+      const version = await getJson(`${base}/version`);
+      assert.equal(version.body.version, PKG_VERSION);
+      const admin = await getJson(`${base}/admin/api/status`);
+      assert.equal(admin.body.version, PKG_VERSION);
+      const client = new Client({ name: "lifecycle-test", version: "1.0.0" });
+      await client.connect(new StreamableHTTPClientTransport(new URL(`${base}/mcp`)));
+      assert.equal(client.getServerVersion()?.version, PKG_VERSION);
+      const templates = (await client.listResourceTemplates()).resourceTemplates.map((t) => t.uriTemplate).sort();
+      assert.deepEqual(templates, ["code-search://repo/{name}/graph", "code-search://repo/{name}/profile"]);
+      await client.close();
+      const metrics = await (await fetch(`${base}/metrics`)).text();
+      const age = metrics.match(/^code_search_index_age_seconds\{project="default"\} (\d+)$/m);
+      assert.ok(age, `index_age missing:
+${metrics}`);
+      assert.ok(Number(age[1]) < 120, `index_age=${age[1]}`);
+      assert.doesNotMatch(metrics, /phase=/);
+      assert.match(metrics, /^code_search_index_chunks_total\{project="default",repo="orders"\} [1-9]\d*$/m);
+      p.child.kill("SIGTERM");
+      const exit = await exitWithin(p, 5e3);
+      assert.notEqual(exit, "timeout", "SIGTERM must terminate the HTTP server");
+    } finally {
+      p.kill();
+      await p.exited;
+    }
+  });
+  it("structured logs + reindex interval from the config file", async () => {
+    const env = baseEnv({
+      home: join(root, "home"),
+      dataDir: join(root, "data2"),
+      embedderUrl: fast.url,
+      extra: { CODE_SEARCH_STRUCTURED_LOGS: "1" }
+    });
+    const p = spawnProc(BIN.mcp, ["--serve", ws, "--port", "47384", "--indexing.reindex-interval-ms", "1h"], env);
+    try {
+      await waitFor(async () => (await getJson("http://127.0.0.1:47384/ready")).status === 200, 6e4, `ready
+${p.stderr()}`);
+      const lines = p.stderr().split("\n").filter(Boolean);
+      assert.ok(!lines.some((l) => l.startsWith("[code-search-mcp]")), `plain-text server lines:
+${p.stderr()}`);
+      const json = lines.filter((l) => l.startsWith("{")).map((l) => JSON.parse(l));
+      assert.ok(json.some((e) => e.component === "code-search-mcp" && e.msg === "Auto-reindex every 60m"), p.stderr());
+      assert.ok(json.some((e) => e.component === "auto-index" && e.level === "info"), "index progress goes through the logger");
+    } finally {
+      p.kill();
+      await p.exited;
+    }
+  });
+});
+describe("stdio server lifecycle", () => {
+  it("SIGTERM terminates --local stdio mode", async () => {
+    const env = baseEnv({ home: join(root, "home"), dataDir: join(root, "data3"), embedderUrl: fast.url });
+    const p = spawnProc(BIN.mcp, ["--local", ws], env);
+    try {
+      await p.waitForStderr(/Server running for "ws" \(stdio\)/, 6e4);
+      p.child.kill("SIGTERM");
+      const exit = await exitWithin(p, 5e3);
+      assert.notEqual(exit, "timeout", "SIGTERM must terminate the stdio server");
+    } finally {
+      p.kill();
+      await p.exited;
+    }
+  });
+});

package/dist/__tests__/tool-inputs.test.js

@@ -0,0 +1,178 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { VectorStore, invalidateRetriever, resetLlmConfig } from "@esankhan3/anvil-knowledge-core";
+import { handleGraphTool, registerGraphTools } from "../tools/graph.js";
+import { handleSearchTool, registerSearchTools } from "../tools/search.js";
+import { handleProfileTool } from "../tools/profile.js";
+import { resetServerConfig } from "../core/env-config.js";
+import { registry } from "../observability/metrics.js";
+const PROJECT = "inputs";
+let tmp = "";
+const ENV_KEYS = [
+  "CODE_SEARCH_DATA_DIR",
+  "CODE_SEARCH_EMBEDDING_PROVIDER",
+  "CODE_SEARCH_OLLAMA_HOST",
+  "CODE_SEARCH_EMBEDDING_DIMENSIONS",
+  "CODE_SEARCH_RERANKER_PROVIDER",
+  "ANVIL_LLM_MODE",
+  "CODE_SEARCH_LLM_MODE"
+];
+const stash = {};
+function ctx(indexReady = true) {
+  return {
+    projectName: PROJECT,
+    directoryPath: null,
+    indexReady,
+    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 ?? "";
+function chunk(id, entityName, content) {
+  return {
+    id,
+    filePath: `src/${id}.ts`,
+    repoName: "app",
+    project: PROJECT,
+    startLine: 1,
+    endLine: 3,
+    content,
+    contextPrefix: "",
+    contextualizedContent: content,
+    language: "typescript",
+    entityType: "function",
+    entityName,
+    tokens: 10,
+    imports: [],
+    exports: [],
+    embedding: [1, 0, 0, 0]
+  };
+}
+before(async () => {
+  for (const k of ENV_KEYS) stash[k] = process.env[k];
+  tmp = mkdtempSync(join(tmpdir(), "cs-inputs-"));
+  process.env.CODE_SEARCH_DATA_DIR = tmp;
+  process.env.CODE_SEARCH_EMBEDDING_PROVIDER = "ollama";
+  process.env.CODE_SEARCH_OLLAMA_HOST = "http://127.0.0.1:47361";
+  process.env.CODE_SEARCH_EMBEDDING_DIMENSIONS = "4";
+  process.env.CODE_SEARCH_RERANKER_PROVIDER = "none";
+  process.env.ANVIL_LLM_MODE = "none";
+  process.env.CODE_SEARCH_LLM_MODE = "none";
+  resetServerConfig();
+  resetLlmConfig();
+  mkdirSync(join(tmp, PROJECT), { recursive: true });
+  const store = new VectorStore(join(tmp, PROJECT, "lancedb"));
+  await store.init();
+  await store.upsertChunks([
+    chunk("a", "chargeCustomer", "export function chargeCustomer(amount: number) { return gateway.charge(amount); }"),
+    chunk("b", "refundCustomer", "export function refundCustomer(id: string) { return gateway.refund(id); }")
+  ]);
+  await store.ensureFtsIndex();
+});
+after(async () => {
+  await invalidateRetriever();
+  rmSync(tmp, { recursive: true, force: true });
+  for (const k of ENV_KEYS) {
+    if (stash[k] === void 0) delete process.env[k];
+    else process.env[k] = stash[k];
+  }
+  resetServerConfig();
+  resetLlmConfig();
+});
+describe("input validation", () => {
+  const cases = [
+    ["search", "search_code", {}, /query/],
+    ["search", "search_code", { query: "   " }, /query/],
+    ["search", "search_code", { query: 5 }, /query.*string/],
+    ["search", "search_code", { query: "x", maxResults: 0 }, /maxResults/],
+    ["search", "search_exact", { query: "x", repos: 5 }, /"repos" must be a non-empty array of strings or a non-empty string/],
+    ["search", "search_exact", { query: "x", repos: { app: true } }, /repos/],
+    ["search", "search_exact", { query: "x", repos: [] }, /repos/],
+    ["search", "search_exact", { query: "x", repos: "" }, /repos/],
+    ["search", "search_exact", { query: "x", repos: " , " }, /repos.*at least one/],
+    ["search", "get_code_snippet", {}, /id|repo/],
+    ["graph", "detect_changes", {}, /repo/],
+    ["graph", "trace_path", { from: "a", direction: "sideways" }, /direction.*callees, callers, both/],
+    ["graph", "trace_path", { from: "a", maxDepth: 0 }, /maxDepth/],
+    ["graph", "trace_path", { from: "a", maxDepth: 11 }, /maxDepth/],
+    ["graph", "find_callers", { function: "a", relations: ["friends"] }, /relations/],
+    ["graph", "impact_analysis", { repo: "app" }, /file/],
+    ["graph", "search_graph", { limit: "ten" }, /limit/],
+    ["graph", "find_dead_code", { repo: "app", limit: -1 }, /limit/]
+  ];
+  for (const [kind, name, args, re] of cases) {
+    it(`${name} ${JSON.stringify(args)} \u2192 isError`, async () => {
+      const r = kind === "search" ? await handleSearchTool(name, args, ctx()) : await handleGraphTool(name, args, ctx());
+      assert.equal(r?.isError, true, text(r));
+      assert.match(text(r), re);
+    });
+  }
+  it("get_repo_profile without repo \u2192 isError", async () => {
+    const r = await handleProfileTool("get_repo_profile", {}, ctx());
+    assert.equal(r?.isError, true);
+  });
+});
+describe("search_exact without an embedder", () => {
+  it("serves BM25 even while the index is not ready", async () => {
+    const r = await handleSearchTool("search_exact", { query: "refundCustomer" }, ctx(false));
+    assert.notEqual(r.isError, true, text(r));
+    assert.match(text(r), /refundCustomer/);
+  });
+  it("accepts repos as an array, one name, or a comma-separated list \u2014 and applies it", async () => {
+    for (const repos of [["app"], "app", "other, app"]) {
+      const r = await handleSearchTool("search_exact", { query: "refundCustomer", repos }, ctx());
+      assert.notEqual(r.isError, true, `${JSON.stringify(repos)}: ${text(r)}`);
+      assert.match(text(r), /refundCustomer/, JSON.stringify(repos));
+    }
+    assert.match(text(await handleSearchTool("search_exact", { query: "refundCustomer", repos: "other" }, ctx())), /No results/);
+  });
+  it("records the query metrics", async () => {
+    await handleSearchTool("search_exact", { query: "chargeCustomer" }, ctx());
+    const body = registry.render();
+    assert.match(body, /code_search_queries_total\{[^}]*mode="bm25"[^}]*\} \d+/);
+    assert.match(body, /code_search_query_duration_seconds_count\{mode="bm25"\} \d+/);
+  });
+  it("hybrid search reports an embedder failure as an error and counts it", async () => {
+    const r = await handleSearchTool("search_code", { query: "charge customer" }, ctx());
+    assert.equal(r.isError, true);
+    assert.match(registry.render(), /code_search_errors_total\{kind="search"\} \d+/);
+  });
+});
+describe("hints", () => {
+  it("index-not-ready does not point at a reindex tool", async () => {
+    const t = text(await handleSearchTool("search_semantic", { query: "x" }, ctx(false)));
+    assert.match(t, /not ready/i);
+    assert.doesNotMatch(t, /reindex tool/);
+  });
+  it("missing profile with LLM off says profiles need an LLM", async () => {
+    const t = text(await handleProfileTool("get_repo_profile", { repo: "app" }, ctx()));
+    assert.match(t, /LLM/);
+    assert.doesNotMatch(t, /Run reindex/);
+  });
+});
+describe("descriptors match behaviour", () => {
+  const search = Object.fromEntries(registerSearchTools().map((t) => [t.name, t]));
+  const graph = Object.fromEntries(registerGraphTools().map((t) => [t.name, t]));
+  it("search_semantic / search_exact advertise repos", () => {
+    assert.ok(search.search_semantic.inputSchema.properties.repos);
+    assert.ok(search.search_exact.inputSchema.properties.repos);
+  });
+  it("trace_path is not described as confidence-weighted; search_graph name is a regex", () => {
+    assert.doesNotMatch(graph.trace_path.description, /confidence-weighted/);
+    assert.match(graph.search_graph.inputSchema.properties.name.description, /regex/i);
+    assert.ok(graph.find_callers.inputSchema.properties.relations);
+  });
+});

package/dist/backends/in-process.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 import {
   getRetriever,
+  invalidateRetriever,
   indexFromPath,
   getKnowledgeBasePath,
   KnowledgeIndexer,
@@ -60,7 +61,7 @@ class InProcessBackend {
   }
   async status() {
     const indexer = new KnowledgeIndexer();
-    const stats = await indexer.getStats(this.project);
+    const stats = await indexer.getStats(this.project, this.knowledge);
     return {
       totalChunks: stats.totalChunks,
       repos: stats.repos,
@@ -79,6 +80,7 @@ class InProcessBackend {
       force: opts?.force,
       config: this.knowledge
     });
+    await invalidateRetriever(this.project);
     return this.status();
   }
   async invalidate(paths) {
@@ -91,10 +93,11 @@ class InProcessBackend {
     const stats = await store.getStats();
     if (!stats || stats.rowCount === 0) return;
     const indexer = new KnowledgeIndexer();
-    const summary = await indexer.getStats(this.project);
+    const summary = await indexer.getStats(this.project, this.knowledge);
     for (const r of summary.repos) {
       await store.deleteFileChunks(this.project, r.name, paths);
     }
+    await invalidateRetriever(this.project);
   }
   async close() {
   }

package/dist/backends/index.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { InProcessBackend } from "./in-process.js";
 import { DaemonBackend } from "./daemon-client.js";
+import { getComponentLogger } from "../observability/logger.js";
 export * from "./types.js";
 import { InProcessBackend as InProcessBackend2 } from "./in-process.js";
 import { DaemonBackend as DaemonBackend2 } from "./daemon-client.js";
@@ -16,8 +17,7 @@ async function pickBackend(cfg) {
   if (cfg.preferDaemon && socketPath && existsSync(socketPath)) {
     const daemon = new DaemonBackend({ ...cfg, socketPath });
     if (await daemon.ping()) return daemon;
-    process.stderr.write(`[code-search-mcp] daemon socket exists at ${socketPath} but ping failed; using in-process backend
-`);
+    getComponentLogger("code-search").warn(`daemon socket exists at ${socketPath} but ping failed; using in-process backend`);
   }
   return new InProcessBackend(cfg);
 }