@esankhan3/code-search-mcp 0.1.0 → 0.2.0

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

package/dist/cli/index.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { existsSync, rmSync } from "node:fs";
+import { join, resolve as resolvePath } from "node:path";
+import {
+  resolveCodeSearchConfig,
+  parseCliFlags,
+  printConfig,
+  toKnowledgeConfig
+} from "../core/config.js";
+import {
+  indexFromPath,
+  KnowledgeIndexer,
+  getKnowledgeBasePath,
+  loadProfile
+} from "@esankhan3/anvil-knowledge-core";
+import { pickBackend, daemonSocketPath } from "../backends/index.js";
+const HELP_TEXT = `code-search \u2014 multi-repo code intelligence
+
+USAGE:
+  code-search <command> [options]
+  code-search --print-config       print resolved configuration (secrets redacted)
+
+COMMANDS:
+  index [path]                     index a directory (default: cwd)
+  query <text>                     hybrid search; print top-K
+  status                           show index + daemon health
+  reset [--project <name>]         drop the project's index
+  daemon --workspace <path>        spawn the long-running daemon
+  serve [--port N] [--auth mode]   HTTP MCP server
+  mcp                              stdio MCP server (Claude Desktop)
+
+QUERY OPTIONS:
+  --mode hybrid|vector|bm25        retrieval mode (default: hybrid)
+  --top-k N                        max results (default: 10)
+  --repo <name>                    restrict to a repo (repeatable)
+  --format text|json|jsonl         output format (default: text)
+  --project <name>                 project namespace (default: cwd basename)
+
+CONFIG:
+  Every leaf in CodeSearchConfig is settable via --<dotted-path>.
+  Examples:
+    --embedding.provider codestral
+    --retrieval.max-chunks 20
+    --no-indexing.auto-index
+`;
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(HELP_TEXT);
+    process.exit(0);
+  }
+  if (argv[0] === "--print-config") {
+    const { patch } = parseCliFlags(argv.slice(1));
+    const cfg = resolveCodeSearchConfig({ cli: patch });
+    process.stdout.write(printConfig(cfg) + "\n");
+    process.exit(0);
+  }
+  const sub = argv[0];
+  const rest = argv.slice(1);
+  switch (sub) {
+    case "index":
+      return await cmdIndex(rest);
+    case "query":
+      return await cmdQuery(rest);
+    case "status":
+      return await cmdStatus(rest);
+    case "reset":
+      return await cmdReset(rest);
+    case "daemon":
+      return await cmdDaemon(rest);
+    case "serve":
+      return await cmdServe(rest);
+    case "mcp":
+      return await cmdMcp(rest);
+    default:
+      process.stderr.write(`unknown subcommand: ${sub}
+${HELP_TEXT}`);
+      process.exit(2);
+  }
+}
+function takeFlag(rest, name) {
+  const idx = rest.indexOf(name);
+  if (idx < 0) return void 0;
+  return rest[idx + 1];
+}
+function projectFromPath(p) {
+  return resolvePath(p).split("/").filter(Boolean).pop() || "project";
+}
+async function cmdIndex(rest) {
+  const { patch, rest: positional } = parseCliFlags(rest);
+  const path = positional.find((a) => !a.startsWith("--")) ?? process.cwd();
+  const cfg = resolveCodeSearchConfig({ cli: patch, workspaceDir: path });
+  const project = takeFlag(positional, "--project") ?? projectFromPath(path);
+  const force = positional.includes("--force");
+  process.stderr.write(`[code-search] indexing ${path} as project "${project}"...
+`);
+  const stats = await indexFromPath(project, resolvePath(path), {
+    force,
+    config: toKnowledgeConfig(cfg),
+    onProgress: (m) => process.stderr.write(`[code-search] ${m}
+`)
+  });
+  process.stdout.write(JSON.stringify({
+    project,
+    chunks: stats.totalChunks,
+    repos: stats.repos.length,
+    crossRepoEdges: stats.crossRepoEdges,
+    durationMs: stats.indexDurationMs
+  }, null, 2) + "\n");
+}
+const VALID_MODES = /* @__PURE__ */ new Set(["hybrid", "vector", "bm25"]);
+async function cmdQuery(rest) {
+  const { patch, rest: positional } = parseCliFlags(rest);
+  const queryText = positional.find((a) => !a.startsWith("--") && !a.startsWith("-"));
+  if (!queryText) {
+    process.stderr.write("code-search query: missing <text>\n");
+    process.exit(2);
+  }
+  const rawMode = takeFlag(positional, "--mode") ?? "hybrid";
+  if (!VALID_MODES.has(rawMode)) {
+    process.stderr.write(
+      `code-search query: invalid --mode "${rawMode}". Valid modes: ${[...VALID_MODES].join(", ")}.
+`
+    );
+    process.exit(2);
+  }
+  const mode = rawMode;
+  const topK = parseInt(takeFlag(positional, "--top-k") ?? "10", 10);
+  const repos = positional.reduce((acc, a, i) => {
+    if (a === "--repo" && positional[i + 1]) acc.push(positional[i + 1]);
+    return acc;
+  }, []);
+  const format = takeFlag(positional, "--format") ?? "text";
+  const project = takeFlag(positional, "--project") ?? projectFromPath(process.cwd());
+  const cfg = resolveCodeSearchConfig({ cli: patch });
+  const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
+  const backend = await pickBackend({
+    project,
+    workspaceDir: process.cwd(),
+    knowledge: toKnowledgeConfig(cfg),
+    preferDaemon: !cfg.daemon.disabled,
+    socketPath
+  });
+  const result = await backend.search(queryText, {
+    mode,
+    maxResults: topK,
+    repos: repos.length ? repos : void 0
+  });
+  await backend.close();
+  printSearchResult(result, format);
+}
+function printSearchResult(result, format) {
+  if (format === "json") {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+    return;
+  }
+  if (format === "jsonl") {
+    for (const c of result.chunks) process.stdout.write(JSON.stringify(c) + "\n");
+    return;
+  }
+  if (result.chunks.length === 0) {
+    process.stdout.write(`No results for "${result.query}"
+`);
+    return;
+  }
+  let i = 0;
+  for (const c of result.chunks) {
+    i++;
+    process.stdout.write(
+      `### ${i}. ${c.repoName}/${c.filePath}:${c.startLine}-${c.endLine} (score: ${c.score.toFixed(3)}, source: ${c.source})
+\`\`\`` + c.language + "\n" + c.content + "\n```\n\n"
+    );
+  }
+}
+async function cmdStatus(rest) {
+  const { patch } = parseCliFlags(rest);
+  const cfg = resolveCodeSearchConfig({ cli: patch });
+  const project = takeFlag(rest, "--project") ?? projectFromPath(process.cwd());
+  const indexer = new KnowledgeIndexer();
+  const stats = await indexer.getStats(project);
+  const socketPath = daemonSocketPath(cfg.storage.dataDir, project);
+  process.stdout.write(JSON.stringify({
+    project,
+    dataDir: cfg.storage.dataDir,
+    daemonSocket: socketPath,
+    daemonAlive: existsSync(socketPath),
+    totalChunks: stats.totalChunks,
+    embeddingProvider: stats.embeddingProvider,
+    lastIndexedAt: stats.lastIndexed || null,
+    repos: stats.repos,
+    profilesAvailable: stats.repos.map((r) => ({
+      name: r.name,
+      hasProfile: !!loadProfile(project, r.name)
+    }))
+  }, null, 2) + "\n");
+}
+async function cmdReset(rest) {
+  const project = takeFlag(rest, "--project") ?? projectFromPath(process.cwd());
+  const basePath = getKnowledgeBasePath(project);
+  if (existsSync(basePath)) {
+    rmSync(basePath, { recursive: true, force: true });
+    process.stderr.write(`[code-search] removed ${basePath}
+`);
+  } else {
+    process.stderr.write(`[code-search] nothing to remove at ${basePath}
+`);
+  }
+}
+async function cmdDaemon(rest) {
+  const here = new URL(import.meta.url);
+  const daemonEntry = join(new URL("..", here).pathname, "daemon", "index.js");
+  const child = spawn(process.execPath, [daemonEntry, ...rest], {
+    stdio: "inherit",
+    detached: false
+  });
+  child.on("exit", (code) => process.exit(code ?? 0));
+}
+async function cmdServe(rest) {
+  process.argv = [process.argv[0], process.argv[1], "--serve", ...rest];
+  await import("../index.js");
+}
+async function cmdMcp(rest) {
+  process.argv = [process.argv[0], process.argv[1], ...rest];
+  await import("../index.js");
+}
+main().catch((err) => {
+  process.stderr.write(`code-search fatal: ${err instanceof Error ? err.stack : err}
+`);
+  process.exit(1);
+});