@esankhan3/code-search-mcp 0.0.2 → 0.2.0

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);
+});

package/dist/daemon/rpc-server.js

@@ -0,0 +1,99 @@
+import { createServer } from "node:net";
+import { existsSync, unlinkSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { EventEmitter } from "node:events";
+class RpcServer extends EventEmitter {
+  socketPath;
+  handlers;
+  server = null;
+  clients = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    super();
+    this.socketPath = opts.socketPath;
+    this.handlers = opts.handlers;
+  }
+  async start() {
+    if (process.platform !== "win32" && existsSync(this.socketPath)) {
+      try {
+        unlinkSync(this.socketPath);
+      } catch {
+      }
+    }
+    mkdirSync(dirname(this.socketPath), { recursive: true });
+    await new Promise((resolveP, rejectP) => {
+      this.server = createServer((sock) => this.handleClient(sock));
+      this.server.on("error", (err) => {
+        this.emit("error", err);
+        rejectP(err);
+      });
+      this.server.listen(this.socketPath, () => {
+        this.emit("listening", this.socketPath);
+        resolveP();
+      });
+    });
+  }
+  async stop() {
+    for (const c of this.clients) {
+      try {
+        c.destroy();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    if (this.server) {
+      await new Promise((r) => this.server.close(() => r()));
+      this.server = null;
+    }
+    if (process.platform !== "win32" && existsSync(this.socketPath)) {
+      try {
+        unlinkSync(this.socketPath);
+      } catch {
+      }
+    }
+  }
+  handleClient(sock) {
+    this.clients.add(sock);
+    let buf = "";
+    sock.setNoDelay(true);
+    sock.on("end", () => this.clients.delete(sock));
+    sock.on("error", () => this.clients.delete(sock));
+    sock.on("data", async (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);
+        await this.handleLine(sock, line);
+        idx = buf.indexOf("\n");
+      }
+    });
+  }
+  async handleLine(sock, line) {
+    if (!line.trim()) return;
+    let req;
+    try {
+      req = JSON.parse(line);
+    } catch (err) {
+      sock.write(this.errorEnvelope(null, -32700, err instanceof Error ? err.message : String(err)));
+      return;
+    }
+    const handler = this.handlers[req.method];
+    if (!handler) {
+      sock.write(this.errorEnvelope(req.id ?? null, -32601, `Method not found: ${req.method}`));
+      return;
+    }
+    try {
+      const result = await handler(req.params);
+      sock.write(JSON.stringify({ jsonrpc: "2.0", id: req.id ?? null, result }) + "\n");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      sock.write(this.errorEnvelope(req.id ?? null, -32e3, msg));
+    }
+  }
+  errorEnvelope(id, code, message) {
+    return JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n";
+  }
+}
+export {
+  RpcServer
+};

package/dist/daemon/watcher.js

@@ -0,0 +1,105 @@
+import { watch, statSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+import { EventEmitter } from "node:events";
+const HAS_RECURSIVE = process.platform === "darwin" || process.platform === "win32";
+class Watcher extends EventEmitter {
+  workspaceDir;
+  ignore;
+  debounceMs;
+  watchers = [];
+  pending = /* @__PURE__ */ new Set();
+  timer = null;
+  started = false;
+  constructor(opts) {
+    super();
+    this.workspaceDir = opts.workspaceDir;
+    this.ignore = opts.ignorePatterns;
+    this.debounceMs = Math.max(50, opts.debounceMs);
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    if (HAS_RECURSIVE) {
+      const w = watch(this.workspaceDir, { recursive: true }, (_event, filename) => {
+        if (!filename) return;
+        this.queue(filename.toString());
+      });
+      w.on("error", (err) => this.emit("error", err));
+      this.watchers.push(w);
+    } else {
+      this.walkAndWatch(this.workspaceDir);
+    }
+  }
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    for (const w of this.watchers) {
+      try {
+        w.close();
+      } catch {
+      }
+    }
+    this.watchers = [];
+    this.pending.clear();
+  }
+  onBatch(listener) {
+    return this.on("batch", listener);
+  }
+  walkAndWatch(dir) {
+    if (this.shouldIgnore(dir)) return;
+    try {
+      const w = watch(dir, (_event, filename) => {
+        if (!filename) return;
+        const full = join(dir, filename.toString());
+        this.queue(relative(this.workspaceDir, full));
+        try {
+          if (statSync(full).isDirectory()) this.walkAndWatch(full);
+        } catch {
+        }
+      });
+      w.on("error", (err) => this.emit("error", err));
+      this.watchers.push(w);
+      for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        try {
+          if (statSync(full).isDirectory()) this.walkAndWatch(full);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  queue(rel) {
+    if (this.shouldIgnore(rel)) return;
+    this.pending.add(join(this.workspaceDir, rel));
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.flush(), this.debounceMs);
+  }
+  flush() {
+    const batch = { changed: new Set(this.pending), removed: /* @__PURE__ */ new Set() };
+    this.pending.clear();
+    this.timer = null;
+    for (const p of batch.changed) {
+      try {
+        statSync(p);
+      } catch {
+        batch.removed.add(p);
+      }
+    }
+    for (const r of batch.removed) batch.changed.delete(r);
+    this.emit("batch", batch);
+  }
+  shouldIgnore(path) {
+    for (const pat of this.ignore) {
+      if (path.includes(`/${pat}/`) || path.endsWith(`/${pat}`) || path.startsWith(`${pat}/`) || path === pat) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+export {
+  Watcher
+};

package/dist/index.js

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
 import { resolve } from "node:path";
 import { existsSync } from "node:fs";
+import { printConfig, resolveCodeSearchConfig, parseCliFlags } from "./core/config.js";
 const args = process.argv.slice(2);
+if (args.includes("--print-config")) {
+  const { patch } = parseCliFlags(args.filter((a) => a !== "--print-config"));
+  const cfg = resolveCodeSearchConfig({ cli: patch });
+  process.stdout.write(printConfig(cfg) + "\n");
+  process.exit(0);
+}
 let mode = "remote";
 let remoteUrl = null;
 let apiKey;

package/dist/observability/logger.js

@@ -0,0 +1,66 @@
+const LEVEL_RANK = { debug: 10, info: 20, warn: 30, error: 40 };
+class Logger {
+  opts;
+  constructor(opts) {
+    this.opts = {
+      structured: opts.structured,
+      level: opts.level ?? "info",
+      write: opts.write ?? ((line) => process.stderr.write(line + "\n"))
+    };
+  }
+  debug(msg, fields) {
+    this.emit("debug", msg, fields);
+  }
+  info(msg, fields) {
+    this.emit("info", msg, fields);
+  }
+  warn(msg, fields) {
+    this.emit("warn", msg, fields);
+  }
+  error(msg, fields) {
+    this.emit("error", msg, fields);
+  }
+  /** Bind a component name so every line carries it. */
+  child(component) {
+    return new Logger({
+      structured: this.opts.structured,
+      level: this.opts.level,
+      write: (line) => this.opts.write(line)
+    }).withComponent(component);
+  }
+  /** Internal — return a logger that prefixes the component field. */
+  withComponent(component) {
+    const self = this;
+    return new Proxy(self, {
+      get(target, prop) {
+        if (prop === "emit") {
+          return (level, msg, fields) => self.emit(level, msg, { component, ...fields });
+        }
+        return target[prop];
+      }
+    });
+  }
+  emit(level, msg, fields) {
+    if (LEVEL_RANK[level] < LEVEL_RANK[this.opts.level]) return;
+    if (this.opts.structured) {
+      const entry = { level, msg, ts: (/* @__PURE__ */ new Date()).toISOString(), ...fields };
+      this.opts.write(JSON.stringify(entry));
+    } else {
+      const comp = fields?.component ? `[${fields.component}]` : "";
+      this.opts.write(`${level.toUpperCase()} ${comp} ${msg}`);
+    }
+  }
+}
+let _default = null;
+function getLogger() {
+  if (!_default) _default = new Logger({ structured: false });
+  return _default;
+}
+function configureLogger(opts) {
+  _default = new Logger(opts);
+}
+export {
+  Logger,
+  configureLogger,
+  getLogger
+};

package/dist/observability/metrics.js

@@ -0,0 +1,138 @@
+function formatLabels(labels) {
+  if (!labels) return "";
+  const parts = [];
+  for (const [k, v] of Object.entries(labels)) {
+    parts.push(`${k}="${String(v).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`);
+  }
+  return parts.length ? `{${parts.join(",")}}` : "";
+}
+function labelKey(labels) {
+  if (!labels) return "";
+  const keys = Object.keys(labels).sort();
+  return keys.map((k) => `${k}=${labels[k]}`).join("|");
+}
+class Counter {
+  name;
+  help;
+  buckets = /* @__PURE__ */ new Map();
+  constructor(name, help) {
+    this.name = name;
+    this.help = help;
+  }
+  inc(labels, value = 1) {
+    const key = labelKey(labels);
+    const existing = this.buckets.get(key);
+    if (existing) existing.value += value;
+    else this.buckets.set(key, { labels, value });
+  }
+  render() {
+    const lines = [];
+    lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} counter`);
+    for (const { labels, value } of this.buckets.values()) {
+      lines.push(`${this.name}${formatLabels(labels)} ${value}`);
+    }
+    return lines.join("\n");
+  }
+}
+class Gauge {
+  name;
+  help;
+  buckets = /* @__PURE__ */ new Map();
+  constructor(name, help) {
+    this.name = name;
+    this.help = help;
+  }
+  set(value, labels) {
+    this.buckets.set(labelKey(labels), { labels, value });
+  }
+  render() {
+    const lines = [];
+    lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} gauge`);
+    for (const { labels, value } of this.buckets.values()) {
+      lines.push(`${this.name}${formatLabels(labels)} ${value}`);
+    }
+    return lines.join("\n");
+  }
+}
+const DEFAULT_BUCKETS = [5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10];
+class Histogram {
+  name;
+  help;
+  bucketBounds;
+  buckets = /* @__PURE__ */ new Map();
+  constructor(name, help, bucketBounds = DEFAULT_BUCKETS) {
+    this.name = name;
+    this.help = help;
+    this.bucketBounds = bucketBounds;
+  }
+  observe(value, labels) {
+    const key = labelKey(labels);
+    let entry = this.buckets.get(key);
+    if (!entry) {
+      entry = {
+        labels,
+        counts: new Array(this.bucketBounds.length).fill(0),
+        sum: 0,
+        total: 0
+      };
+      this.buckets.set(key, entry);
+    }
+    for (let i = 0; i < this.bucketBounds.length; i++) {
+      if (value <= this.bucketBounds[i]) entry.counts[i]++;
+    }
+    entry.sum += value;
+    entry.total++;
+  }
+  render() {
+    const lines = [];
+    lines.push(`# HELP ${this.name} ${this.help}`);
+    lines.push(`# TYPE ${this.name} histogram`);
+    for (const entry of this.buckets.values()) {
+      let cumulative = 0;
+      for (let i = 0; i < this.bucketBounds.length; i++) {
+        cumulative = entry.counts[i];
+        const labels = { ...entry.labels, le: this.bucketBounds[i] };
+        lines.push(`${this.name}_bucket${formatLabels(labels)} ${cumulative}`);
+      }
+      lines.push(`${this.name}_bucket${formatLabels({ ...entry.labels, le: "+Inf" })} ${entry.total}`);
+      lines.push(`${this.name}_sum${formatLabels(entry.labels)} ${entry.sum}`);
+      lines.push(`${this.name}_count${formatLabels(entry.labels)} ${entry.total}`);
+    }
+    return lines.join("\n");
+  }
+}
+class Registry {
+  collectors = /* @__PURE__ */ new Map();
+  register(metric) {
+    if (!this.collectors.has(metric.name)) this.collectors.set(metric.name, metric);
+    return this.collectors.get(metric.name);
+  }
+  render() {
+    const parts = [];
+    for (const c of this.collectors.values()) parts.push(c.render());
+    return parts.join("\n") + "\n";
+  }
+  reset() {
+    this.collectors.clear();
+  }
+}
+const registry = new Registry();
+const metrics = {
+  queriesTotal: registry.register(new Counter("code_search_queries_total", "Total search queries by mode + repo.")),
+  queryDuration: registry.register(new Histogram("code_search_query_duration_seconds", "Query latency by mode.")),
+  indexChunks: registry.register(new Gauge("code_search_index_chunks_total", "Indexed chunks by repo.")),
+  indexAge: registry.register(new Gauge("code_search_index_age_seconds", "Seconds since last index by repo.")),
+  embeddingCalls: registry.register(new Counter("code_search_embeddings_calls_total", "Embedding API calls by provider.")),
+  llmCalls: registry.register(new Counter("code_search_llm_calls_total", "LLM API calls by phase.")),
+  errors: registry.register(new Counter("code_search_errors_total", "Errors by kind.")),
+  rerankerCacheHits: registry.register(new Counter("code_search_reranker_cache_hits_total", "Rerank cache lookups by outcome."))
+};
+export {
+  Counter,
+  Gauge,
+  Histogram,
+  metrics,
+  registry
+};