@esankhan3/code-search-mcp 0.1.0 → 0.2.0

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

package/dist/projects/registry.js

@@ -0,0 +1,146 @@
+import { readdirSync, existsSync, statSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  resolveCodeSearchConfig
+} from "../core/config.js";
+const DEFAULT_QUOTAS = {
+  maxQueriesPerMinute: 100,
+  maxEmbeddingCostUsd: 0,
+  maxLlmCostUsd: 0
+};
+function parseSimpleYaml(src) {
+  const obj = {};
+  const lines = src.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].replace(/#.*$/, "").replace(/\s+$/, "");
+    if (!line.trim()) {
+      i++;
+      continue;
+    }
+    const top = /^(\w+):\s*(.*)$/.exec(line);
+    if (!top) {
+      i++;
+      continue;
+    }
+    const key = top[1];
+    const valRaw = top[2];
+    if (!valRaw) {
+      const sub = {};
+      i++;
+      while (i < lines.length) {
+        const sline = lines[i].replace(/#.*$/, "").replace(/\s+$/, "");
+        if (!sline) {
+          i++;
+          continue;
+        }
+        const indent = sline.length - sline.trimStart().length;
+        if (indent < 2) break;
+        const m = /^\s*(\w+):\s*(.*)$/.exec(sline);
+        if (!m) {
+          i++;
+          continue;
+        }
+        sub[m[1]] = coerce(m[2]);
+        i++;
+      }
+      obj[key] = sub;
+    } else {
+      obj[key] = coerce(valRaw);
+      i++;
+    }
+  }
+  return obj;
+}
+function coerce(raw) {
+  let v = raw.trim();
+  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 (/^-?\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()));
+  return v;
+}
+function readProjectYaml(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return parseSimpleYaml(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+class ProjectRegistry {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+  }
+  projects = /* @__PURE__ */ new Map();
+  /** Re-read the projects/ directory. */
+  reload() {
+    this.projects.clear();
+    const projectsDir = join(this.dataDir, "projects");
+    if (!existsSync(projectsDir)) return [];
+    for (const name of readdirSync(projectsDir)) {
+      const dir = join(projectsDir, name);
+      try {
+        if (!statSync(dir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const yamlPath = join(dir, "project.yaml");
+      const meta = readProjectYaml(yamlPath);
+      if (!meta.workspace) continue;
+      const workspaceDir = String(meta.workspace);
+      const quotas = {
+        maxQueriesPerMinute: meta.quotas?.max_queries_per_minute ?? meta.quotas?.maxQueriesPerMinute ?? DEFAULT_QUOTAS.maxQueriesPerMinute,
+        maxEmbeddingCostUsd: meta.quotas?.max_embedding_cost_usd ?? meta.quotas?.maxEmbeddingCostUsd ?? DEFAULT_QUOTAS.maxEmbeddingCostUsd,
+        maxLlmCostUsd: meta.quotas?.max_llm_cost_usd ?? meta.quotas?.maxLlmCostUsd ?? DEFAULT_QUOTAS.maxLlmCostUsd
+      };
+      const config = resolveCodeSearchConfig({ workspaceDir });
+      this.projects.set(name, {
+        name,
+        workspaceDir,
+        repos: Array.isArray(meta.repos) ? meta.repos : [],
+        scopes: Array.isArray(meta.scopes) ? meta.scopes : [],
+        config,
+        quotas
+      });
+    }
+    return [...this.projects.values()];
+  }
+  list() {
+    return [...this.projects.values()];
+  }
+  get(name) {
+    return this.projects.get(name);
+  }
+}
+function projectAccessAllowed(project, identityScopes) {
+  if (project.scopes.length === 0) return true;
+  if (identityScopes.includes("*")) return true;
+  for (const s of identityScopes) {
+    if (project.scopes.includes(s)) return true;
+  }
+  return false;
+}
+const projectRateBuckets = /* @__PURE__ */ new Map();
+function checkProjectQuota(project, identity) {
+  if (project.quotas.maxQueriesPerMinute <= 0) return { ok: true };
+  const key = `${identity}|${project.name}`;
+  const now = Date.now();
+  const bucket = projectRateBuckets.get(key);
+  if (!bucket || now > bucket.resetAt) {
+    projectRateBuckets.set(key, { count: 1, resetAt: now + 6e4 });
+    return { ok: true };
+  }
+  if (bucket.count >= project.quotas.maxQueriesPerMinute) {
+    return { ok: false, reason: `quota exceeded for project="${project.name}": ${project.quotas.maxQueriesPerMinute}/min` };
+  }
+  bucket.count++;
+  return { ok: true };
+}
+export {
+  ProjectRegistry,
+  checkProjectQuota,
+  projectAccessAllowed
+};

package/dist/server.js

@@ -16,6 +16,7 @@ import { registerResources, handleResource } from "./resources/resources.js";
 import { getKnowledgeBasePath } from "@esankhan3/anvil-knowledge-core";
 import { indexFromPath } from "@esankhan3/anvil-knowledge-core";
 import { loadServerConfig } from "./core/env-config.js";
+import { toKnowledgeConfig } from "./core/config.js";
 import { startHttpTransport } from "./transports/http-transport.js";
 function createMcpServerInstance(ctx) {
   const server = new Server(
@@ -185,9 +186,12 @@ async function trackedIndex(ctx, project, dirPath, opts) {
   ctx.indexing.startedAt = Date.now();
   ctx.indexing.error = null;
   pushHistory(ctx, "start", `${label}: started for "${project}" at ${dirPath}`);
+  const unified = loadServerConfig().__unified;
+  const knowledgeConfig = toKnowledgeConfig(unified);
   try {
     const stats = await indexFromPath(project, dirPath, {
       force: opts?.force,
+      config: knowledgeConfig,
       onProgress: (m) => {
         ctx.indexing.message = m;
         console.error(`[${label}] ${m}`);

package/dist/transports/http-transport.js

@@ -2,9 +2,11 @@ import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createAuthMiddleware } from "../middleware/auth.js";
+import { registry, metrics } from "../observability/metrics.js";
 async function startHttpTransport(opts) {
   const { config, createMcpServer, onReady, getHealth } = opts;
   const authenticate = createAuthMiddleware(config);
+  const startedAt = Date.now();
   const sessions = /* @__PURE__ */ new Map();
   const SESSION_TTL_MS = 30 * 60 * 1e3;
   const MAX_SESSIONS = 100;
@@ -37,6 +39,42 @@ async function startHttpTransport(opts) {
       res.end(JSON.stringify(status, null, 2));
       return;
     }
+    if (path === "/version" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        name: "code-search-mcp",
+        version: "0.1.0",
+        node: process.version,
+        platform: process.platform
+      }));
+      return;
+    }
+    if (path === "/ready" && req.method === "GET") {
+      const health = getHealth?.() ?? {};
+      const ready = health.indexReady === true;
+      res.writeHead(ready ? 200 : 503, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ready, ...health }));
+      return;
+    }
+    if (path === "/metrics" && req.method === "GET") {
+      const status = opts.getStatus?.() ?? {};
+      const indexing = status.indexing;
+      metrics.indexAge.set(0, { phase: indexing?.phase ?? "idle" });
+      res.writeHead(200, { "Content-Type": "text/plain; version=0.0.4" });
+      res.end(registry.render());
+      return;
+    }
+    if (path === "/admin/api/status" && req.method === "GET") {
+      const status = opts.getStatus?.() ?? {};
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        version: "0.1.0",
+        uptime: Math.floor((Date.now() - startedAt) / 1e3),
+        sessions: sessions.size,
+        ...status
+      }, null, 2));
+      return;
+    }
     if (path === "/index" && req.method === "POST") {
       if (config.authEnabled) {
         const identity = authenticate(req, res);

package/package.json

@@ -1,27 +1,39 @@
 {
   "name": "@esankhan3/code-search-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "MCP server for multi-repo code search — GitHub org or local path, zero config",
   "type": "module",
   "license": "MIT",
   "bin": {
-    "code-search-mcp": "./dist/index.js"
+    "code-search-mcp": "./dist/index.js",
+    "code-search": "./dist/cli/index.js",
+    "code-search-daemon": "./dist/daemon/index.js"
   },
   "exports": {
     ".": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "scripts/smoke"
   ],
   "scripts": {
     "build": "node build.mjs",
-    "dev": "tsc -b --watch"
+    "dev": "tsc -b --watch",
+    "test": "node --test dist/__tests__/*.test.js",
+    "smoke": "bash scripts/smoke/run-smoke.sh"
   },
   "dependencies": {
-    "@esankhan3/anvil-agent-core": "^0.1.0",
-    "@esankhan3/anvil-knowledge-core": "^0.1.0",
+    "@esankhan3/anvil-agent-core": "^0.2.0",
+    "@esankhan3/anvil-knowledge-core": "^0.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
+  "optionalDependencies": {
+    "@lancedb/lancedb-darwin-arm64": "0.27.2",
+    "@lancedb/lancedb-darwin-x64": "0.27.2",
+    "@lancedb/lancedb-linux-x64-gnu": "0.27.2",
+    "@lancedb/lancedb-linux-arm64-gnu": "0.27.2",
+    "@lancedb/lancedb-win32-x64-msvc": "0.27.2"
+  },
   "devDependencies": {
     "@types/node": "^22.15.2"
   },