@esankhan3/code-search-mcp 0.1.0 → 0.2.0

package/dist/core/config.js

@@ -0,0 +1,372 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+function defaultDataDir() {
+  return process.env.CODE_SEARCH_DATA_DIR ?? join(homedir(), ".code-search", "index");
+}
+const DEFAULTS = {
+  server: {
+    transport: "stdio",
+    port: 3100,
+    host: "127.0.0.1"
+  },
+  auth: {
+    mode: "none",
+    apiKeys: [],
+    jwtSecret: void 0,
+    jwtIssuer: "code-search-mcp",
+    rateLimitPerMinute: 100
+  },
+  storage: {
+    dataDir: defaultDataDir()
+  },
+  embedding: {
+    provider: "auto",
+    dimensions: 1024
+  },
+  reranker: {
+    provider: "ollama"
+  },
+  retrieval: {
+    maxChunks: 8,
+    maxTokens: 12e3,
+    hybridWeights: { vector: 0.5, bm25: 0.3, graph: 0.2 }
+  },
+  indexing: {
+    autoIndex: true,
+    reindexIntervalMs: 0,
+    chunking: { maxTokens: 500, contextEnrichment: "structural" },
+    respectGitignore: true,
+    debounceMs: 500,
+    ignorePatterns: ["node_modules", ".git", "dist", "build", ".next", "__pycache__", ".venv", "vendor", "target"]
+  },
+  llm: {
+    mode: "none",
+    provider: "anthropic",
+    model: "sonnet",
+    apiKey: void 0,
+    baseUrl: void 0,
+    claudeBin: "claude"
+  },
+  github: {
+    token: void 0
+  },
+  telemetry: {
+    otelEndpoint: void 0,
+    otelHeaders: void 0,
+    metricsEnabled: false,
+    structuredLogs: false,
+    recordQueries: false
+  },
+  daemon: {
+    autoSpawn: false,
+    disabled: false
+  }
+};
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(base, ...patches) {
+  const out = { ...base };
+  for (const p of patches) {
+    if (!p) continue;
+    for (const [k, v] of Object.entries(p)) {
+      if (v === void 0) continue;
+      if (isPlainObject(v) && isPlainObject(out[k])) {
+        out[k] = deepMerge(out[k], v);
+      } else {
+        out[k] = v;
+      }
+    }
+  }
+  return out;
+}
+function parseYaml(src) {
+  const lines = src.split(/\r?\n/);
+  const root = {};
+  const stack = [{ obj: root, indent: -1 }];
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/#.*$/, "").replace(/\s+$/, "");
+    if (!line.trim()) continue;
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+    const colon = trimmed.indexOf(":");
+    if (colon < 0) continue;
+    const key = trimmed.slice(0, colon).trim();
+    const valRaw = trimmed.slice(colon + 1).trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) stack.pop();
+    const parent = stack[stack.length - 1].obj;
+    if (!valRaw) {
+      const child = {};
+      parent[key] = child;
+      stack.push({ obj: child, indent });
+      continue;
+    }
+    parent[key] = coerce(valRaw);
+  }
+  return root;
+}
+function coerce(raw) {
+  let v = raw;
+  if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+    return v.slice(1, -1);
+  }
+  if (v === "true") return true;
+  if (v === "false") return false;
+  if (v === "null" || v === "~") return null;
+  if (/^-?\d+$/.test(v)) return parseInt(v, 10);
+  if (/^-?\d+\.\d+$/.test(v)) return parseFloat(v);
+  if (v.startsWith("[") && v.endsWith("]")) {
+    return v.slice(1, -1).split(",").map((s) => coerce(s.trim()));
+  }
+  if (v.startsWith("{") && v.endsWith("}")) {
+    const o = {};
+    for (const part of v.slice(1, -1).split(",")) {
+      const [k, x] = part.split(":");
+      if (k && x !== void 0) o[k.trim()] = coerce(x.trim());
+    }
+    return o;
+  }
+  if (v.startsWith("~")) return v.replace(/^~/, homedir());
+  return v;
+}
+function snakeToCamel(obj) {
+  if (Array.isArray(obj)) return obj.map(snakeToCamel);
+  if (!isPlainObject(obj)) return obj;
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    const camel = k.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+    out[camel] = snakeToCamel(v);
+  }
+  return out;
+}
+function loadYamlFile(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const src = readFileSync(path, "utf-8");
+    const raw = parseYaml(src);
+    return snakeToCamel(raw);
+  } catch {
+    return null;
+  }
+}
+function parseHeaders(s) {
+  if (!s) return void 0;
+  const out = {};
+  for (const pair of s.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq > 0) out[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function parseReindexMs(raw) {
+  if (!raw || raw === "0" || raw === "none") return 0;
+  const m = raw.match(/^(\d+)(m|h)$/);
+  if (!m) {
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) ? n : 0;
+  }
+  return m[2] === "h" ? parseInt(m[1], 10) * 60 * 6e4 : parseInt(m[1], 10) * 6e4;
+}
+function envLayer() {
+  const env = (k) => process.env[`CODE_SEARCH_${k}`];
+  const authMode = env("AUTH_MODE");
+  const transport = env("TRANSPORT");
+  const port = env("PORT");
+  const rateLimit = env("RATE_LIMIT_PER_MINUTE");
+  const maxChunks = env("RETRIEVAL_MAX_CHUNKS");
+  const maxTokens = env("RETRIEVAL_MAX_TOKENS");
+  const chunkMaxTokens = env("CHUNKING_MAX_TOKENS");
+  const debounce = env("INDEXING_DEBOUNCE_MS");
+  const embedDims = env("EMBEDDING_DIMENSIONS");
+  return {
+    server: {
+      transport,
+      port: port ? parseInt(port, 10) : void 0,
+      host: env("HOST") ?? (authMode === "none" || !authMode ? void 0 : "0.0.0.0")
+    },
+    auth: {
+      mode: authMode,
+      apiKeys: env("AUTH_API_KEYS")?.split(",").map((s) => s.trim()).filter(Boolean),
+      jwtSecret: env("AUTH_JWT_SECRET"),
+      jwtIssuer: env("AUTH_JWT_ISSUER"),
+      rateLimitPerMinute: rateLimit ? parseInt(rateLimit, 10) : void 0
+    },
+    storage: {
+      dataDir: env("DATA_DIR")
+    },
+    embedding: {
+      provider: env("EMBEDDING_PROVIDER"),
+      model: env("EMBEDDING_MODEL"),
+      dimensions: embedDims ? parseInt(embedDims, 10) : void 0,
+      apiKey: env("EMBEDDING_API_KEY"),
+      baseUrl: env("EMBEDDING_BASE_URL"),
+      ollamaHost: env("OLLAMA_HOST") ?? process.env.OLLAMA_HOST
+    },
+    reranker: {
+      provider: env("RERANKER_PROVIDER"),
+      model: env("RERANKER_MODEL"),
+      apiKey: env("RERANKER_API_KEY"),
+      baseUrl: env("RERANKER_BASE_URL")
+    },
+    retrieval: {
+      maxChunks: maxChunks ? parseInt(maxChunks, 10) : void 0,
+      maxTokens: maxTokens ? parseInt(maxTokens, 10) : void 0
+    },
+    indexing: {
+      autoIndex: env("AUTO_INDEX") !== void 0 ? env("AUTO_INDEX") !== "false" && env("AUTO_INDEX") !== "0" : void 0,
+      reindexIntervalMs: env("REINDEX_INTERVAL") !== void 0 ? parseReindexMs(env("REINDEX_INTERVAL")) : void 0,
+      chunking: {
+        maxTokens: chunkMaxTokens ? parseInt(chunkMaxTokens, 10) : void 0
+      },
+      debounceMs: debounce ? parseInt(debounce, 10) : void 0
+    },
+    llm: {
+      mode: env("LLM_MODE"),
+      provider: env("LLM_PROVIDER"),
+      model: env("LLM_MODEL"),
+      apiKey: env("LLM_API_KEY") ?? process.env.ANTHROPIC_API_KEY ?? process.env.OPENAI_API_KEY,
+      baseUrl: env("LLM_BASE_URL"),
+      claudeBin: env("CLAUDE_BIN") ?? process.env.CLAUDE_BIN
+    },
+    github: {
+      token: env("GITHUB_TOKEN") ?? process.env.GITHUB_TOKEN
+    },
+    telemetry: {
+      otelEndpoint: env("OTEL_ENDPOINT") ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+      otelHeaders: parseHeaders(env("OTEL_HEADERS") ?? process.env.OTEL_EXPORTER_OTLP_HEADERS),
+      metricsEnabled: env("METRICS_ENABLED") === "1" || env("METRICS_ENABLED") === "true" ? true : void 0,
+      structuredLogs: env("STRUCTURED_LOGS") === "1" || env("STRUCTURED_LOGS") === "true" ? true : void 0,
+      recordQueries: env("TELEMETRY_RECORD_QUERIES") === "1" || env("TELEMETRY_RECORD_QUERIES") === "true" ? true : void 0
+    },
+    daemon: {
+      autoSpawn: env("DAEMON_AUTO_SPAWN") === "1" || env("DAEMON_AUTO_SPAWN") === "true" ? true : void 0,
+      disabled: env("DAEMON_DISABLED") === "1" || env("DAEMON_DISABLED") === "true" ? true : void 0
+    }
+  };
+}
+const RESERVED_FLAGS = /* @__PURE__ */ new Set([
+  "--local",
+  "--remote",
+  "--serve",
+  "--help",
+  "-h",
+  "--print-config",
+  "--api-key",
+  "--project",
+  "--token",
+  "--force",
+  "--workspace",
+  "--no-daemon",
+  "--auto-spawn-daemon",
+  "--config",
+  "--format",
+  "--top-k",
+  "--mode",
+  "--repo",
+  "--language"
+]);
+function parseCliFlags(argv) {
+  const patch = {};
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--") || RESERVED_FLAGS.has(arg)) {
+      rest.push(arg);
+      continue;
+    }
+    let key = arg.slice(2);
+    let negate = false;
+    if (key.startsWith("no-")) {
+      negate = true;
+      key = key.slice(3);
+    }
+    const path = key.split(".").map((seg) => seg.replace(/-([a-z])/g, (_, c) => c.toUpperCase()));
+    let val;
+    if (negate) {
+      val = false;
+    } else if (argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) {
+      val = coerce(argv[++i]);
+    } else {
+      val = true;
+    }
+    setDeep(patch, path, val);
+  }
+  return { patch, rest };
+}
+function setDeep(obj, path, value) {
+  let cur = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    const k = path[i];
+    if (!isPlainObject(cur[k])) cur[k] = {};
+    cur = cur[k];
+  }
+  cur[path[path.length - 1]] = value;
+}
+function resolveCodeSearchConfig(opts = {}) {
+  const globalConfigPath = opts.configPath ?? join(homedir(), ".code-search", "config.yaml");
+  const yaml1 = loadYamlFile(globalConfigPath) ?? {};
+  const yaml2 = opts.workspaceDir ? loadYamlFile(join(opts.workspaceDir, ".code-search.yaml")) ?? {} : {};
+  const env = envLayer();
+  const cli = opts.cli ?? {};
+  const cfg = deepMerge(DEFAULTS, yaml1, yaml2, env, cli);
+  bridgeLegacyEnvVars(cfg);
+  return cfg;
+}
+function bridgeLegacyEnvVars(cfg) {
+  process.env.ANVIL_LLM_MODE ??= process.env.CODE_SEARCH_LLM_MODE ?? cfg.llm.mode;
+  process.env.ANVIL_LLM_PROVIDER ??= process.env.CODE_SEARCH_LLM_PROVIDER ?? cfg.llm.provider;
+  process.env.ANVIL_LLM_MODEL ??= process.env.CODE_SEARCH_LLM_MODEL ?? cfg.llm.model;
+  if (cfg.llm.apiKey) process.env.ANVIL_LLM_API_KEY ??= cfg.llm.apiKey;
+  if (cfg.llm.baseUrl) process.env.ANVIL_LLM_BASE_URL ??= cfg.llm.baseUrl;
+  if (cfg.llm.claudeBin) process.env.ANVIL_CLAUDE_BIN ??= cfg.llm.claudeBin;
+}
+function toKnowledgeConfig(c) {
+  return {
+    embedding: { ...c.embedding },
+    chunking: { ...c.indexing.chunking },
+    retrieval: {
+      maxChunks: c.retrieval.maxChunks,
+      maxTokens: c.retrieval.maxTokens,
+      hybridWeights: { ...c.retrieval.hybridWeights },
+      reranker: { ...c.reranker }
+    },
+    autoIndex: c.indexing.autoIndex
+  };
+}
+const SECRET_KEYS = /* @__PURE__ */ new Set([
+  "apiKey",
+  "jwtSecret",
+  "token",
+  "githubToken"
+]);
+function redactSecrets(value, parentKey = "") {
+  if (Array.isArray(value)) {
+    return value.map((v) => redactSecrets(v, parentKey));
+  }
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (SECRET_KEYS.has(k) && typeof v === "string" && v.length > 0) {
+        out[k] = `***redacted (${v.length} chars)`;
+      } else if (k === "apiKeys" && Array.isArray(v)) {
+        out[k] = v.map((s) => `***redacted (${s.length} chars)`);
+      } else {
+        out[k] = redactSecrets(v, k);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function printConfig(c) {
+  return JSON.stringify(redactSecrets(c), null, 2);
+}
+export {
+  DEFAULTS,
+  parseCliFlags,
+  printConfig,
+  redactSecrets,
+  resolveCodeSearchConfig,
+  toKnowledgeConfig
+};

package/dist/core/env-config.js

@@ -1,20 +1,23 @@
 import { execSync as _execSync } from "node:child_process";
+import {
+  resolveCodeSearchConfig,
+  parseCliFlags
+} from "./config.js";
+import { normalizeRerankerConfig } from "@esankhan3/anvil-knowledge-core";
 let _config = null;
-function resolveLlmMode(explicit, apiKey) {
-  if (explicit) {
-    const mode = explicit;
-    if (mode === "api" && !apiKey) {
+function resolveLlmMode(explicit, apiKey, claudeBin) {
+  if (explicit && explicit !== "none") {
+    if (explicit === "api" && !apiKey) {
       console.error(
         `[code-search-mcp] WARNING: LLM_MODE=api but no API key found. Set CODE_SEARCH_LLM_API_KEY or ANTHROPIC_API_KEY. Falling back to LLM_MODE=none.`
       );
       return "none";
     }
-    return mode;
+    return explicit;
   }
   if (apiKey) return "api";
   try {
-    const bin = process.env.ANVIL_AGENT_CMD ?? process.env.FF_AGENT_CMD ?? process.env.CLAUDE_BIN ?? "claude";
-    _execSync(`which ${bin}`, { stdio: "pipe", timeout: 3e3 });
+    _execSync(`which ${claudeBin}`, { stdio: "pipe", timeout: 3e3 });
     return "cli";
   } catch {
   }
@@ -23,38 +26,41 @@ function resolveLlmMode(explicit, apiKey) {
   );
   return "none";
 }
-function loadServerConfig() {
+function loadServerConfig(opts) {
   if (_config) return _config;
-  const env = (key) => process.env[`CODE_SEARCH_${key}`];
-  const authMode = env("AUTH_MODE") ?? "none";
+  const cli = opts?.argv ? parseCliFlags(opts.argv).patch : void 0;
+  const c = resolveCodeSearchConfig({ cli, workspaceDir: opts?.workspaceDir });
+  const rerankerStruct = normalizeRerankerConfig(c.reranker);
+  const llmMode = resolveLlmMode(c.llm.mode, c.llm.apiKey, c.llm.claudeBin);
   _config = {
-    port: parseInt(env("PORT") ?? "3100", 10),
-    host: env("HOST") ?? (authMode === "none" ? "127.0.0.1" : "0.0.0.0"),
-    transport: env("TRANSPORT") ?? "stdio",
-    dataDir: env("DATA_DIR") ?? "",
-    embeddingProvider: env("EMBEDDING_PROVIDER") ?? "auto",
-    embeddingModel: env("EMBEDDING_MODEL"),
-    embeddingDimensions: parseInt(env("EMBEDDING_DIMENSIONS") ?? "1024", 10),
-    embeddingApiKey: env("EMBEDDING_API_KEY"),
-    embeddingBaseUrl: env("EMBEDDING_BASE_URL"),
-    ollamaHost: env("OLLAMA_HOST") ?? process.env.OLLAMA_HOST ?? "http://localhost:11434",
-    rerankerProvider: env("RERANKER_PROVIDER") ?? "ollama",
-    rerankerModel: env("RERANKER_MODEL"),
-    rerankerApiKey: env("RERANKER_API_KEY"),
-    rerankerBaseUrl: env("RERANKER_BASE_URL"),
-    githubToken: env("GITHUB_TOKEN") ?? process.env.GITHUB_TOKEN,
-    authEnabled: authMode !== "none",
-    authMode,
-    authApiKeys: (env("AUTH_API_KEYS") ?? "").split(",").map((k) => k.trim()).filter(Boolean),
-    authJwtSecret: env("AUTH_JWT_SECRET"),
-    authJwtIssuer: env("AUTH_JWT_ISSUER") ?? "code-search-mcp",
-    rateLimitPerMinute: parseInt(env("RATE_LIMIT_PER_MINUTE") ?? "100", 10),
-    llmMode: resolveLlmMode(env("LLM_MODE"), env("LLM_API_KEY") ?? process.env.ANTHROPIC_API_KEY),
-    llmProvider: env("LLM_PROVIDER") ?? "anthropic",
-    llmModel: env("LLM_MODEL") ?? "sonnet",
-    llmApiKey: env("LLM_API_KEY") ?? process.env.ANTHROPIC_API_KEY,
-    llmBaseUrl: env("LLM_BASE_URL"),
-    claudeBin: env("CLAUDE_BIN") ?? process.env.CLAUDE_BIN ?? "claude"
+    port: c.server.port,
+    host: c.server.host,
+    transport: c.server.transport,
+    dataDir: c.storage.dataDir,
+    embeddingProvider: c.embedding.provider,
+    embeddingModel: c.embedding.model,
+    embeddingDimensions: c.embedding.dimensions ?? 1024,
+    embeddingApiKey: c.embedding.apiKey,
+    embeddingBaseUrl: c.embedding.baseUrl,
+    ollamaHost: c.embedding.ollamaHost ?? "http://localhost:11434",
+    rerankerProvider: rerankerStruct.provider,
+    rerankerModel: rerankerStruct.model,
+    rerankerApiKey: rerankerStruct.apiKey,
+    rerankerBaseUrl: rerankerStruct.baseUrl,
+    githubToken: c.github.token,
+    authEnabled: c.auth.mode !== "none",
+    authMode: c.auth.mode,
+    authApiKeys: c.auth.apiKeys,
+    authJwtSecret: c.auth.jwtSecret,
+    authJwtIssuer: c.auth.jwtIssuer,
+    rateLimitPerMinute: c.auth.rateLimitPerMinute,
+    llmMode,
+    llmProvider: c.llm.provider,
+    llmModel: c.llm.model,
+    llmApiKey: c.llm.apiKey,
+    llmBaseUrl: c.llm.baseUrl,
+    claudeBin: c.llm.claudeBin,
+    __unified: c
   };
   if (_config.embeddingApiKey) {
     const provider = _config.embeddingProvider;
@@ -67,12 +73,8 @@ function loadServerConfig() {
     }
   }
   if (_config.rerankerApiKey) {
-    const reranker = _config.rerankerProvider;
-    if (reranker === "cohere") {
-      process.env.COHERE_API_KEY ??= _config.rerankerApiKey;
-    } else if (reranker === "voyage") {
-      process.env.VOYAGE_API_KEY ??= _config.rerankerApiKey;
-    }
+    if (_config.rerankerProvider === "cohere") process.env.COHERE_API_KEY ??= _config.rerankerApiKey;
+    if (_config.rerankerProvider === "voyage") process.env.VOYAGE_API_KEY ??= _config.rerankerApiKey;
   }
   process.env.OLLAMA_HOST ??= _config.ollamaHost;
   return _config;

package/dist/daemon/index.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveCodeSearchConfig, parseCliFlags, toKnowledgeConfig } from "../core/config.js";
+import { InProcessBackend } from "../backends/in-process.js";
+import { daemonSocketPath } from "../backends/index.js";
+import { RpcServer } from "./rpc-server.js";
+import { Watcher } from "./watcher.js";
+async function main() {
+  const argv = process.argv.slice(2);
+  const { patch, rest } = parseCliFlags(argv);
+  let workspaceDir = null;
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === "--workspace" && rest[i + 1]) workspaceDir = rest[++i];
+  }
+  if (!workspaceDir) {
+    process.stderr.write("code-search-daemon: missing --workspace <path>\n");
+    process.exit(2);
+  }
+  if (!existsSync(workspaceDir)) {
+    process.stderr.write(`code-search-daemon: workspace does not exist: ${workspaceDir}
+`);
+    process.exit(2);
+  }
+  const cfg = resolveCodeSearchConfig({ cli: patch, workspaceDir });
+  const project = workspaceDir.split("/").filter(Boolean).pop() || "project";
+  const knowledge = toKnowledgeConfig(cfg);
+  const backend = new InProcessBackend({
+    project,
+    workspaceDir,
+    knowledge,
+    preferDaemon: false
+  });
+  process.stderr.write(`[code-search-daemon] starting for project="${project}", workspace=${workspaceDir}
+`);
+  process.stderr.write("[code-search-daemon] building initial index...\n");
+  await backend.forceIndex();
+  process.stderr.write("[code-search-daemon] initial index ready.\n");
+  const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
+  const pidFile = join(cfg.storage.dataDir, "daemon", `${project}.pid`);
+  let queueDepth = 0;
+  let indexing = false;
+  const triggerReindex = async () => {
+    if (indexing) {
+      queueDepth++;
+      return;
+    }
+    indexing = true;
+    try {
+      while (queueDepth >= 0) {
+        await backend.forceIndex();
+        if (queueDepth === 0) break;
+        queueDepth--;
+      }
+    } catch (err) {
+      process.stderr.write(`[code-search-daemon] reindex failed: ${err instanceof Error ? err.message : err}
+`);
+    } finally {
+      indexing = false;
+    }
+  };
+  const watcher = new Watcher({
+    workspaceDir,
+    ignorePatterns: cfg.indexing.ignorePatterns,
+    debounceMs: cfg.indexing.debounceMs
+  });
+  watcher.on("error", (err) => {
+    process.stderr.write(`[code-search-daemon] watcher error: ${err instanceof Error ? err.message : err}
+`);
+  });
+  watcher.onBatch((batch) => {
+    process.stderr.write(`[code-search-daemon] reindex queued (${batch.changed.size} changed, ${batch.removed.size} removed)
+`);
+    queueDepth++;
+    void triggerReindex();
+  });
+  watcher.start();
+  const startedAt = Date.now();
+  const rpc = new RpcServer({
+    socketPath,
+    handlers: {
+      "search.code": (p) => backend.search(p.query, { mode: p.mode ?? "hybrid", maxResults: p.maxResults, repos: p.repos }),
+      "index.status": async () => {
+        const s = await backend.status();
+        return { ...s, watching: true, queueDepth };
+      },
+      "index.force": async (p) => {
+        await backend.forceIndex({ force: p?.force });
+        return backend.status();
+      },
+      "index.invalidate": async (p) => {
+        await backend.invalidate(p.paths ?? []);
+        return { ok: true };
+      },
+      "health": () => ({ ok: true, uptime: Math.floor((Date.now() - startedAt) / 1e3) })
+    }
+  });
+  await rpc.start();
+  process.stderr.write(`[code-search-daemon] RPC listening on ${socketPath}
+`);
+  try {
+    writeFileSync(pidFile, String(process.pid), "utf-8");
+  } catch {
+  }
+  const shutdown = async (signal) => {
+    process.stderr.write(`[code-search-daemon] ${signal} \u2014 draining...
+`);
+    watcher.stop();
+    await rpc.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
+main().catch((err) => {
+  process.stderr.write(`code-search-daemon fatal: ${err instanceof Error ? err.stack : err}
+`);
+  process.exit(1);
+});