@esankhan3/code-search-mcp 0.0.2 → 0.2.0

package/dist/__tests__/config-resolver.test.js

@@ -0,0 +1,153 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir, homedir } from "node:os";
+import {
+  resolveCodeSearchConfig,
+  parseCliFlags,
+  toKnowledgeConfig,
+  redactSecrets,
+  DEFAULTS
+} from "../core/config.js";
+const ENV_KEYS = [
+  "CODE_SEARCH_EMBEDDING_PROVIDER",
+  "CODE_SEARCH_EMBEDDING_MODEL",
+  "CODE_SEARCH_EMBEDDING_DIMENSIONS",
+  "CODE_SEARCH_EMBEDDING_API_KEY",
+  "CODE_SEARCH_RERANKER_PROVIDER",
+  "CODE_SEARCH_PORT",
+  "CODE_SEARCH_AUTH_MODE",
+  "CODE_SEARCH_AUTH_API_KEYS",
+  "CODE_SEARCH_DATA_DIR",
+  "CODE_SEARCH_REINDEX_INTERVAL"
+];
+let tmp = "";
+const STASH = {};
+beforeEach(() => {
+  for (const k of ENV_KEYS) {
+    STASH[k] = process.env[k];
+    delete process.env[k];
+  }
+  tmp = mkdtempSync(join(tmpdir(), "cs-cfg-"));
+});
+afterEach(() => {
+  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];
+  }
+});
+describe("resolveCodeSearchConfig precedence (P3)", () => {
+  it("returns DEFAULTS when no file / env / CLI is present", () => {
+    const cfg = resolveCodeSearchConfig({ configPath: join(tmp, "missing.yaml") });
+    assert.equal(cfg.embedding.provider, "auto");
+    assert.equal(cfg.server.port, 3100);
+    assert.equal(cfg.indexing.autoIndex, true);
+  });
+  it("env overrides defaults", () => {
+    process.env.CODE_SEARCH_EMBEDDING_PROVIDER = "codestral";
+    process.env.CODE_SEARCH_EMBEDDING_MODEL = "codestral-embed-2505";
+    process.env.CODE_SEARCH_EMBEDDING_API_KEY = "sk-abc";
+    process.env.CODE_SEARCH_PORT = "4242";
+    const cfg = resolveCodeSearchConfig({ configPath: join(tmp, "missing.yaml") });
+    assert.equal(cfg.embedding.provider, "codestral");
+    assert.equal(cfg.embedding.model, "codestral-embed-2505");
+    assert.equal(cfg.embedding.apiKey, "sk-abc");
+    assert.equal(cfg.server.port, 4242);
+  });
+  it("YAML config file overrides defaults", () => {
+    const configPath = join(tmp, "config.yaml");
+    writeFileSync(
+      configPath,
+      `server:
+  port: 5500
+embedding:
+  provider: voyage
+  model: voyage-code-3
+`,
+      "utf-8"
+    );
+    const cfg = resolveCodeSearchConfig({ configPath });
+    assert.equal(cfg.server.port, 5500);
+    assert.equal(cfg.embedding.provider, "voyage");
+    assert.equal(cfg.embedding.model, "voyage-code-3");
+  });
+  it("CLI flags override env vars", () => {
+    process.env.CODE_SEARCH_EMBEDDING_PROVIDER = "voyage";
+    const { patch } = parseCliFlags(["--embedding.provider", "codestral", "--server.port", "6000"]);
+    const cfg = resolveCodeSearchConfig({ configPath: join(tmp, "missing.yaml"), cli: patch });
+    assert.equal(cfg.embedding.provider, "codestral");
+    assert.equal(cfg.server.port, 6e3);
+  });
+  it("per-workspace .code-search.yaml overrides ~/.code-search/config.yaml", () => {
+    const globalPath = join(tmp, "global.yaml");
+    writeFileSync(globalPath, `embedding:
+  provider: voyage
+`, "utf-8");
+    const workspace = join(tmp, "workspace");
+    mkdirSync(workspace, { recursive: true });
+    writeFileSync(join(workspace, ".code-search.yaml"), `embedding:
+  provider: openai
+`, "utf-8");
+    const cfg = resolveCodeSearchConfig({ configPath: globalPath, workspaceDir: workspace });
+    assert.equal(cfg.embedding.provider, "openai");
+  });
+});
+describe("toKnowledgeConfig (P3 adapter)", () => {
+  it("maps unified config to KnowledgeConfig shape", () => {
+    const cfg = resolveCodeSearchConfig({ configPath: join(tmp, "missing.yaml") });
+    const k = toKnowledgeConfig(cfg);
+    assert.equal(k.embedding.provider, cfg.embedding.provider);
+    assert.equal(k.retrieval.maxChunks, cfg.retrieval.maxChunks);
+    assert.deepEqual(k.chunking, cfg.indexing.chunking);
+    const r = typeof k.retrieval.reranker === "string" ? { provider: k.retrieval.reranker } : k.retrieval.reranker;
+    assert.equal(r.provider, cfg.reranker.provider);
+  });
+});
+describe("redactSecrets (P3 --print-config)", () => {
+  it("redacts apiKey/jwtSecret/token fields, preserves shape", () => {
+    const input = {
+      embedding: { apiKey: "sk-super-secret", model: "x" },
+      auth: { apiKeys: ["key-1", "key-2"], jwtSecret: "jwt-super-secret" },
+      github: { token: "gh-token" },
+      server: { port: 3100 }
+    };
+    const out = redactSecrets(input);
+    assert.match(out.embedding.apiKey, /redacted/);
+    assert.equal(out.embedding.model, "x");
+    assert.match(out.auth.apiKeys[0], /redacted/);
+    assert.match(out.auth.jwtSecret, /redacted/);
+    assert.match(out.github.token, /redacted/);
+    assert.equal(out.server.port, 3100);
+  });
+  it("keeps DEFAULTS shape redaction-safe (no secrets exposed)", () => {
+    const redacted = redactSecrets(DEFAULTS);
+    const json = JSON.stringify(redacted);
+    assert.equal(/sk-[a-zA-Z0-9]+/.test(json), false);
+  });
+});
+describe("parseCliFlags", () => {
+  it("handles dotted paths and value coercion", () => {
+    const { patch } = parseCliFlags([
+      "--embedding.provider",
+      "voyage",
+      "--retrieval.max-chunks",
+      "20",
+      "--telemetry.metrics-enabled",
+      "true"
+    ]);
+    assert.equal(patch.embedding.provider, "voyage");
+    assert.equal(patch.retrieval.maxChunks, 20);
+    assert.equal(patch.telemetry.metricsEnabled, true);
+  });
+  it("treats reserved subcommand flags as rest", () => {
+    const { rest } = parseCliFlags(["--local", "/some/path", "--embedding.provider", "codestral"]);
+    assert.ok(rest.includes("--local"));
+  });
+  it("--no-x.y sets boolean false", () => {
+    const { patch } = parseCliFlags(["--no-indexing.auto-index"]);
+    assert.equal(patch.indexing.autoIndex, false);
+  });
+});
+void homedir;

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

@@ -0,0 +1,100 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { RpcServer } from "../daemon/rpc-server.js";
+import { DaemonBackend } from "../backends/daemon-client.js";
+const tmp = mkdtempSync(join(tmpdir(), "cs-rpc-"));
+const socketPath = join(tmp, "test.sock");
+let server;
+before(async () => {
+  server = new RpcServer({
+    socketPath,
+    handlers: {
+      "search.code": async (p) => ({ query: p.query, totalTokens: 0, chunks: [] }),
+      "index.status": async () => ({
+        totalChunks: 0,
+        repos: [],
+        embeddingProvider: "stub",
+        lastIndexedAt: null,
+        watching: true,
+        queueDepth: 0,
+        uptimeSec: 1
+      }),
+      "index.force": async () => ({
+        totalChunks: 0,
+        repos: [],
+        embeddingProvider: "stub",
+        lastIndexedAt: null,
+        watching: true,
+        queueDepth: 0,
+        uptimeSec: 1
+      }),
+      "index.invalidate": async () => ({ ok: true }),
+      "health": () => ({ ok: true, uptime: 1 })
+    }
+  });
+  await server.start();
+});
+after(async () => {
+  await server.stop();
+  rmSync(tmp, { recursive: true, force: true });
+});
+describe("daemon RPC roundtrip", { skip: process.platform === "win32" }, () => {
+  it("ping returns true for a live daemon", async () => {
+    const client = new DaemonBackend({
+      project: "test",
+      workspaceDir: null,
+      knowledge: {},
+      preferDaemon: true,
+      socketPath
+    });
+    assert.equal(await client.ping(), true);
+    await client.close();
+  });
+  it("search returns the typed payload", async () => {
+    const client = new DaemonBackend({
+      project: "test",
+      workspaceDir: null,
+      knowledge: {},
+      preferDaemon: true,
+      socketPath
+    });
+    const r = await client.search("hello", { mode: "hybrid", maxResults: 5 });
+    assert.equal(r.query, "hello");
+    assert.equal(Array.isArray(r.chunks), true);
+    await client.close();
+  });
+  it("status / invalidate / forceIndex roundtrip", async () => {
+    const client = new DaemonBackend({
+      project: "test",
+      workspaceDir: null,
+      knowledge: {},
+      preferDaemon: true,
+      socketPath
+    });
+    const s = await client.status();
+    assert.equal(s.embeddingProvider, "stub");
+    assert.equal(s.watching, true);
+    await client.invalidate(["/some/path.ts"]);
+    const after2 = await client.forceIndex({ force: true });
+    assert.equal(after2.embeddingProvider, "stub");
+    await client.close();
+  });
+  it("unknown method returns RPC error", async () => {
+    const client = new DaemonBackend({
+      project: "test",
+      workspaceDir: null,
+      knowledge: {},
+      preferDaemon: true,
+      socketPath
+    });
+    await assert.rejects(
+      // @ts-expect-error — calling a private method on purpose
+      () => client.rpc("notARealMethod", {}, 500),
+      /Method not found/
+    );
+    await client.close();
+  });
+});

package/dist/__tests__/observability.test.js

@@ -0,0 +1,69 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { Counter, Gauge, Histogram, registry, metrics } from "../observability/metrics.js";
+import { Logger } from "../observability/logger.js";
+describe("Prometheus collectors (P7)", () => {
+  it("Counter renders with labels", () => {
+    const c = new Counter("test_counter", "test counter");
+    c.inc({ kind: "a" });
+    c.inc({ kind: "a" });
+    c.inc({ kind: "b" });
+    const out = c.render();
+    assert.match(out, /# HELP test_counter test counter/);
+    assert.match(out, /# TYPE test_counter counter/);
+    assert.match(out, /test_counter\{kind="a"\} 2/);
+    assert.match(out, /test_counter\{kind="b"\} 1/);
+  });
+  it("Gauge updates last-write per label set", () => {
+    const g = new Gauge("test_gauge", "test gauge");
+    g.set(5, { repo: "a" });
+    g.set(7, { repo: "a" });
+    assert.match(g.render(), /test_gauge\{repo="a"\} 7/);
+  });
+  it("Histogram tracks buckets, sum, count", () => {
+    const h = new Histogram("test_hist", "test", [0.1, 0.5, 1]);
+    h.observe(0.05);
+    h.observe(0.3);
+    h.observe(0.9);
+    const out = h.render();
+    assert.match(out, /test_hist_count\{?\}? 3/);
+    assert.match(out, /test_hist_sum\{?\}? 1.25/);
+    assert.match(out, /test_hist_bucket\{le="0.1"\} 1/);
+    assert.match(out, /test_hist_bucket\{le="\+Inf"\} 3/);
+  });
+  it("registry renders the prelude for all pre-declared metrics", () => {
+    metrics.queriesTotal.inc({ mode: "hybrid" });
+    const out = registry.render();
+    assert.match(out, /code_search_queries_total/);
+    assert.match(out, /code_search_query_duration_seconds/);
+  });
+});
+describe("Logger (P7)", () => {
+  it("emits structured JSON when enabled", () => {
+    const lines = [];
+    const log = new Logger({ structured: true, write: (l) => lines.push(l) });
+    log.info("hello", { query: "auth" });
+    assert.equal(lines.length, 1);
+    const parsed = JSON.parse(lines[0]);
+    assert.equal(parsed.msg, "hello");
+    assert.equal(parsed.query, "auth");
+    assert.equal(parsed.level, "info");
+    assert.ok(parsed.ts);
+  });
+  it("respects level threshold", () => {
+    const lines = [];
+    const log = new Logger({ structured: true, level: "warn", write: (l) => lines.push(l) });
+    log.info("skipped");
+    log.warn("kept");
+    assert.equal(lines.length, 1);
+    assert.match(lines[0], /"kept"/);
+  });
+  it("falls back to text mode when structured=false", () => {
+    const lines = [];
+    const log = new Logger({ structured: false, write: (l) => lines.push(l) });
+    log.error("boom");
+    assert.equal(lines.length, 1);
+    assert.match(lines[0], /ERROR/);
+    assert.match(lines[0], /boom/);
+  });
+});

package/dist/__tests__/projects.test.js

@@ -0,0 +1,141 @@
+import { describe, it, beforeEach, afterEach } 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 {
+  ProjectRegistry,
+  projectAccessAllowed,
+  checkProjectQuota
+} from "../projects/registry.js";
+let dir = "";
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "cs-projects-"));
+});
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+function writeProject(name, body) {
+  const d = join(dir, "projects", name);
+  mkdirSync(d, { recursive: true });
+  writeFileSync(join(d, "project.yaml"), body, "utf-8");
+}
+describe("ProjectRegistry", () => {
+  it("reload() discovers all projects with project.yaml", () => {
+    writeProject("alpha", `workspace: /tmp/alpha
+repos: [a, b]
+scopes: [team-x]
+`);
+    writeProject("beta", `workspace: /tmp/beta
+`);
+    mkdirSync(join(dir, "projects", "ignored"), { recursive: true });
+    const reg = new ProjectRegistry(dir);
+    const list = reg.reload();
+    assert.equal(list.length, 2);
+    const names = new Set(list.map((p) => p.name));
+    assert.ok(names.has("alpha"));
+    assert.ok(names.has("beta"));
+    const alpha = reg.get("alpha");
+    assert.equal(alpha.workspaceDir, "/tmp/alpha");
+    assert.deepEqual(alpha.repos, ["a", "b"]);
+    assert.deepEqual(alpha.scopes, ["team-x"]);
+  });
+  it("reload() applies quotas defaults when omitted", () => {
+    writeProject("plain", `workspace: /tmp/plain
+`);
+    const reg = new ProjectRegistry(dir);
+    reg.reload();
+    const p = reg.get("plain");
+    assert.equal(p.quotas.maxQueriesPerMinute, 100);
+  });
+  it("reload() reads custom quotas", () => {
+    writeProject("tenant", `workspace: /tmp/tenant
+quotas:
+  max_queries_per_minute: 5
+  max_embedding_cost_usd: 1
+`);
+    const reg = new ProjectRegistry(dir);
+    reg.reload();
+    const p = reg.get("tenant");
+    assert.equal(p.quotas.maxQueriesPerMinute, 5);
+    assert.equal(p.quotas.maxEmbeddingCostUsd, 1);
+  });
+});
+describe("projectAccessAllowed", () => {
+  it("public projects allow any identity", () => {
+    const p = {
+      name: "public",
+      workspaceDir: "/p",
+      repos: [],
+      scopes: [],
+      config: {},
+      quotas: { maxQueriesPerMinute: 1, maxEmbeddingCostUsd: 0, maxLlmCostUsd: 0 }
+    };
+    assert.equal(projectAccessAllowed(p, []), true);
+    assert.equal(projectAccessAllowed(p, ["some-scope"]), true);
+  });
+  it("scoped projects deny unmatched identities", () => {
+    const p = {
+      name: "secret",
+      workspaceDir: "/p",
+      repos: [],
+      scopes: ["team-x"],
+      config: {},
+      quotas: { maxQueriesPerMinute: 1, maxEmbeddingCostUsd: 0, maxLlmCostUsd: 0 }
+    };
+    assert.equal(projectAccessAllowed(p, ["team-y"]), false);
+    assert.equal(projectAccessAllowed(p, ["team-x"]), true);
+  });
+  it("admin scope * grants access regardless of project scopes", () => {
+    const p = {
+      name: "secret",
+      workspaceDir: "/p",
+      repos: [],
+      scopes: ["team-x"],
+      config: {},
+      quotas: { maxQueriesPerMinute: 1, maxEmbeddingCostUsd: 0, maxLlmCostUsd: 0 }
+    };
+    assert.equal(projectAccessAllowed(p, ["*"]), true);
+  });
+});
+describe("checkProjectQuota", () => {
+  it("blocks once burst exceeds the per-minute cap", () => {
+    const p = {
+      name: "q",
+      workspaceDir: "/p",
+      repos: [],
+      scopes: [],
+      config: {},
+      quotas: { maxQueriesPerMinute: 2, maxEmbeddingCostUsd: 0, maxLlmCostUsd: 0 }
+    };
+    assert.equal(checkProjectQuota(p, "user-1").ok, true);
+    assert.equal(checkProjectQuota(p, "user-1").ok, true);
+    const denied = checkProjectQuota(p, "user-1");
+    assert.equal(denied.ok, false);
+    if (denied.ok === false) assert.match(denied.reason, /quota exceeded/);
+  });
+  it("separate identities have independent buckets", () => {
+    const p = {
+      name: "q2",
+      workspaceDir: "/p",
+      repos: [],
+      scopes: [],
+      config: {},
+      quotas: { maxQueriesPerMinute: 1, maxEmbeddingCostUsd: 0, maxLlmCostUsd: 0 }
+    };
+    assert.equal(checkProjectQuota(p, "a").ok, true);
+    assert.equal(checkProjectQuota(p, "b").ok, true);
+    assert.equal(checkProjectQuota(p, "a").ok, false);
+  });
+  it("maxQueriesPerMinute=0 disables enforcement", () => {
+    const p = {
+      name: "q3",
+      workspaceDir: "/p",
+      repos: [],
+      scopes: [],
+      config: {},
+      quotas: { maxQueriesPerMinute: 0, maxEmbeddingCostUsd: 0, maxLlmCostUsd: 0 }
+    };
+    for (let i = 0; i < 1e3; i++) assert.equal(checkProjectQuota(p, "user").ok, true);
+  });
+});

package/dist/backends/daemon-client.js

@@ -0,0 +1,87 @@
+import { createConnection } from "node:net";
+import { existsSync } from "node:fs";
+let nextRpcId = 1;
+class DaemonBackend {
+  kind = "daemon";
+  project;
+  socketPath;
+  startedAt = Date.now();
+  constructor(cfg) {
+    this.project = cfg.project;
+    this.socketPath = cfg.socketPath;
+  }
+  async search(query, opts) {
+    return this.rpc("search.code", { query, ...opts });
+  }
+  async status() {
+    return this.rpc("index.status", {});
+  }
+  async forceIndex(opts) {
+    return this.rpc("index.force", { force: opts?.force ?? false });
+  }
+  async invalidate(paths) {
+    await this.rpc("index.invalidate", { paths });
+  }
+  async close() {
+  }
+  /** Ping the daemon to check liveness. Returns true on success within ~100ms. */
+  async ping() {
+    try {
+      const r = await this.rpc("health", {}, 250);
+      return !!r.ok;
+    } catch {
+      return false;
+    }
+  }
+  rpc(method, params, timeoutMs = 3e4) {
+    return new Promise((resolveP, rejectP) => {
+      if (!existsSync(this.socketPath)) {
+        rejectP(new Error(`daemon socket not found at ${this.socketPath}`));
+        return;
+      }
+      const id = nextRpcId++;
+      let buf = "";
+      let settled = false;
+      const sock = createConnection(this.socketPath);
+      const finish = (err, value) => {
+        if (settled) return;
+        settled = true;
+        sock.destroy();
+        clearTimeout(timer);
+        if (err) rejectP(err);
+        else resolveP(value);
+      };
+      const timer = setTimeout(() => finish(new Error(`daemon RPC timeout: ${method}`)), timeoutMs);
+      sock.setNoDelay(true);
+      sock.on("error", (err) => finish(err));
+      sock.on("data", (chunk) => {
+        buf += chunk.toString("utf-8");
+        let idx = buf.indexOf("\n");
+        while (idx >= 0) {
+          const line = buf.slice(0, idx);
+          buf = buf.slice(idx + 1);
+          try {
+            const msg = JSON.parse(line);
+            if (msg.id !== id) {
+              idx = buf.indexOf("\n");
+              continue;
+            }
+            if (msg.error) finish(new Error(`daemon RPC error ${msg.error.code}: ${msg.error.message}`));
+            else finish(null, msg.result);
+            return;
+          } catch (err) {
+            finish(err instanceof Error ? err : new Error(String(err)));
+            return;
+          }
+        }
+      });
+      sock.on("connect", () => {
+        const req = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
+        sock.write(req);
+      });
+    });
+  }
+}
+export {
+  DaemonBackend
+};

package/dist/backends/in-process.js

@@ -0,0 +1,104 @@
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import {
+  getRetriever,
+  indexFromPath,
+  getKnowledgeBasePath,
+  KnowledgeIndexer,
+  VectorStore
+} from "@esankhan3/anvil-knowledge-core";
+import { metrics } from "../observability/metrics.js";
+class InProcessBackend {
+  kind = "in-process";
+  project;
+  workspaceDir;
+  knowledge;
+  startedAt = Date.now();
+  constructor(cfg) {
+    this.project = cfg.project;
+    this.workspaceDir = cfg.workspaceDir;
+    this.knowledge = cfg.knowledge;
+  }
+  async search(query, opts) {
+    const started = Date.now();
+    let outcome = "ok";
+    try {
+      const retriever = await getRetriever(this.project, this.knowledge);
+      const modeMap = {
+        hybrid: "vector+bm25+graph",
+        vector: "vector",
+        bm25: "bm25"
+      };
+      const result = await retriever.retrieve(query, {
+        maxChunks: opts.maxResults ?? this.knowledge.retrieval.maxChunks,
+        repoFilter: opts.repos,
+        mode: modeMap[opts.mode]
+      });
+      return {
+        query: result.query,
+        totalTokens: result.totalTokens,
+        chunks: result.chunks.map((sc) => ({
+          filePath: sc.chunk.filePath,
+          startLine: sc.chunk.startLine,
+          endLine: sc.chunk.endLine,
+          language: sc.chunk.language,
+          repoName: sc.chunk.repoName,
+          score: sc.score,
+          source: sc.source,
+          content: sc.chunk.content
+        }))
+      };
+    } catch (err) {
+      outcome = "error";
+      metrics.errors.inc({ kind: "search" });
+      throw err;
+    } finally {
+      const elapsed = (Date.now() - started) / 1e3;
+      metrics.queriesTotal.inc({ mode: opts.mode, outcome });
+      metrics.queryDuration.observe(elapsed, { mode: opts.mode });
+    }
+  }
+  async status() {
+    const indexer = new KnowledgeIndexer();
+    const stats = await indexer.getStats(this.project);
+    return {
+      totalChunks: stats.totalChunks,
+      repos: stats.repos,
+      embeddingProvider: stats.embeddingProvider,
+      lastIndexedAt: stats.lastIndexed || null,
+      watching: false,
+      queueDepth: 0,
+      uptimeSec: Math.floor((Date.now() - this.startedAt) / 1e3)
+    };
+  }
+  async forceIndex(opts) {
+    if (!this.workspaceDir) {
+      throw new Error("InProcessBackend.forceIndex requires a workspaceDir");
+    }
+    await indexFromPath(this.project, this.workspaceDir, {
+      force: opts?.force,
+      config: this.knowledge
+    });
+    return this.status();
+  }
+  async invalidate(paths) {
+    if (paths.length === 0) return;
+    const basePath = getKnowledgeBasePath(this.project);
+    const dbPath = join(basePath, "lancedb");
+    if (!existsSync(dbPath)) return;
+    const store = new VectorStore(dbPath);
+    await store.init();
+    const stats = await store.getStats();
+    if (!stats || stats.rowCount === 0) return;
+    const indexer = new KnowledgeIndexer();
+    const summary = await indexer.getStats(this.project);
+    for (const r of summary.repos) {
+      await store.deleteFileChunks(this.project, r.name, paths);
+    }
+  }
+  async close() {
+  }
+}
+export {
+  InProcessBackend
+};

package/dist/backends/index.js

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { InProcessBackend } from "./in-process.js";
+import { DaemonBackend } from "./daemon-client.js";
+export * from "./types.js";
+import { InProcessBackend as InProcessBackend2 } from "./in-process.js";
+import { DaemonBackend as DaemonBackend2 } from "./daemon-client.js";
+function daemonSocketPath(dataDir, project) {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\code-search-${project}`;
+  }
+  return join(dataDir, "daemon", `${project}.sock`);
+}
+async function pickBackend(cfg) {
+  const socketPath = cfg.socketPath ?? daemonSocketPath(cfg.knowledge ? "" : "", cfg.project);
+  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
+`);
+  }
+  return new InProcessBackend(cfg);
+}
+export {
+  DaemonBackend2 as DaemonBackend,
+  InProcessBackend2 as InProcessBackend,
+  daemonSocketPath,
+  pickBackend
+};