@maxgfr/codeindex 2.15.0 → 2.17.0

package/src/ast/grammars-pull.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { gunzipSync } from "node:zlib";
 import { ENGINE_VERSION } from "../types.js";
@@ -176,3 +176,97 @@ export function extractGrammarsTarball(bytes: Uint8Array, destDir: string): stri
   const raw = b.length >= 2 && b[0] === 0x1f && b[1] === 0x8b ? gunzipSync(b) : b;
   return extractTarInto(raw, destDir);
 }
+
+// What a pull did. `status` distinguishes the three terminal states so a caller
+// can react without parsing prose: nothing to do, wasms installed, or failed
+// (and on failure NOTHING was written — the cache is exactly as it was).
+export interface GrammarsPullResult {
+  ok: boolean;
+  status: "up-to-date" | "pulled" | "failed";
+  cacheDir: string;
+  /** One human-readable line; the CLI writes it to stderr, a library caller may log or drop it. */
+  message: string;
+}
+
+// The whole `grammars pull` mechanic — resolve target, fetch the sha256 sidecar,
+// skip when the cache already holds that exact digest, download, then install
+// ATOMICALLY (extract into a tmp sibling, verify the runtime wasm landed, swap
+// by rename). Extracted from the CLI so `warmGrammars` and `codeindex grammars
+// pull` share ONE implementation: the CLI maps the result onto stderr +
+// process.exitCode, the warm path folds it into its own report.
+//
+// NEVER throws: every failure becomes `{ ok: false, status: "failed" }` with a
+// message, because both callers must survive an offline machine — the engine
+// simply stays on the regex tier. `onNote` receives progress lines (checksum
+// degradation, download start) that are not the terminal message.
+export async function pullGrammars(
+  cacheDir: string,
+  opts: { onNote?: (msg: string) => void } = {},
+): Promise<GrammarsPullResult> {
+  const note = opts.onNote ?? (() => {});
+  const target = resolveGrammarsPullTarget();
+  let expected: string | undefined;
+  if (target.sha256Url) {
+    try {
+      expected = await fetchExpectedSha256(target.sha256Url);
+    } catch (e) {
+      note(`codeindex: could not fetch checksum (${e instanceof Error ? e.message : String(e)}) — proceeding unverified\n`);
+    }
+  }
+  // Idempotent: the marker sibling records the digest of the tarball that
+  // populated cacheDir. Runtime wasm present AND marker === freshly-fetched
+  // digest ⇒ already up to date, skip the ~22 MB download.
+  const runtime = join(cacheDir, "web-tree-sitter.wasm");
+  const markerPath = join(dirname(cacheDir), `${ENGINE_VERSION}.sha256`);
+  if (existsSync(runtime) && expected && existsSync(markerPath)) {
+    let marker = "";
+    try {
+      marker = readFileSync(markerPath, "utf8").trim();
+    } catch {
+      // unreadable marker → fall through and re-pull
+    }
+    if (marker === expected) {
+      return { ok: true, status: "up-to-date", cacheDir, message: `codeindex: grammars already present at ${cacheDir} (up to date)\n` };
+    }
+  }
+  note(`codeindex: fetching grammars from ${target.url} → ${cacheDir}\n`);
+  let bytes: Uint8Array;
+  try {
+    bytes = await fetchGrammarsTarball(target.url, expected);
+  } catch (e) {
+    return {
+      ok: false,
+      status: "failed",
+      cacheDir,
+      message: `codeindex: pull failed — ${e instanceof Error ? e.message : String(e)} (nothing written)\n`,
+    };
+  }
+  let tmp: string | undefined;
+  try {
+    mkdirSync(dirname(cacheDir), { recursive: true });
+    tmp = mkdtempSync(join(dirname(cacheDir), ".grammars-tmp-"));
+    extractGrammarsTarball(bytes, tmp);
+    if (!existsSync(join(tmp, "web-tree-sitter.wasm"))) {
+      throw new Error("archive is missing web-tree-sitter.wasm");
+    }
+    if (existsSync(cacheDir)) rmSync(cacheDir, { recursive: true, force: true });
+    renameSync(tmp, cacheDir);
+    tmp = undefined;
+    if (expected) writeFileSync(markerPath, expected + "\n");
+  } catch (e) {
+    if (tmp) {
+      try {
+        rmSync(tmp, { recursive: true, force: true });
+      } catch {
+        // best-effort cleanup
+      }
+    }
+    return {
+      ok: false,
+      status: "failed",
+      cacheDir,
+      message: `codeindex: pull failed — ${e instanceof Error ? e.message : String(e)} (nothing written)\n`,
+    };
+  }
+  return { ok: true, status: "pulled", cacheDir, message: `codeindex: grammars extracted → ${cacheDir}\n` };
+}

package/src/ast/warm.ts

@@ -0,0 +1,74 @@
+import { allGrammarKeys, ensureGrammars, grammarReady, resolveGrammarsTier, sharedGrammarsCacheDir } from "./loader.js";
+import type { GrammarsTierName } from "./loader.js";
+import { pullGrammars } from "./grammars-pull.js";
+
+// The one-call AST warm-up every consumer needs, and which every consumer but
+// ultraindex was missing.
+//
+// WHY THIS EXISTS. Extraction is AST-preferred with a regex fallback
+// (src/extract/code.ts), but `extractAst` returns undefined unless
+// `grammarReady(key)` — and that is only true after an `await ensureGrammars()`.
+// `scanRepo` is deliberately synchronous, so it CANNOT warm anything itself.
+// A consumer that never awaits the warm-up therefore runs on the regex tier
+// forever, on every machine, no matter what the grammar cache holds — silently,
+// since the fallback is by design invisible. That is a capability quietly left
+// on the table, not a crash, which is exactly why it survived unnoticed.
+//
+// So: call this ONCE at your CLI entry, before the synchronous pipeline. It is
+// idempotent, offline-safe, and never throws.
+export interface WarmGrammarsResult {
+  /** Tier AFTER the warm-up (a successful pull moves "none" → "cache"). */
+  tier: GrammarsTierName;
+  /** True when at least one requested grammar is loaded ⇒ the AST tier is live. */
+  ready: boolean;
+  /** True when this call populated the shared cache over the network. */
+  pulled: boolean;
+  /** Everything written to `onNote`, in order — so a caller can persist the trail in its run artifacts. */
+  notes: string[];
+}
+
+export interface WarmGrammarsOptions {
+  /** Grammars to load. Default: every shipped grammar. Narrow it with `grammarKeysForExts` when the repo's languages are known. */
+  keys?: Iterable<string>;
+  /** Fetch the wasms into the shared cache when nothing is resolvable. Default true; `CODEINDEX_NO_GRAMMARS_PULL=1` forces false. */
+  pull?: boolean;
+  /** Prefix for the diagnostics ("ultrasec: …"). Default "codeindex". */
+  label?: string;
+  /** Where diagnostics go. Default: process.stderr. Pass a sink to keep stdout/stderr clean. */
+  onNote?: (msg: string) => void;
+}
+
+export async function warmGrammars(opts: WarmGrammarsOptions = {}): Promise<WarmGrammarsResult> {
+  const label = opts.label ?? "codeindex";
+  const notes: string[] = [];
+  const note = (msg: string): void => {
+    notes.push(msg);
+    if (opts.onNote) opts.onNote(msg);
+    else process.stderr.write(msg);
+  };
+  const noPull = process.env.CODEINDEX_NO_GRAMMARS_PULL;
+  const mayPull = (opts.pull ?? true) && !(noPull && noPull.trim() && noPull !== "0");
+  const keys = [...(opts.keys ?? allGrammarKeys())];
+
+  let pulled = false;
+  if (resolveGrammarsTier().tier === "none" && mayPull) {
+    note(`${label}: tree-sitter grammars not found locally — pulling them into the shared cache (once per machine)…\n`);
+    const res = await pullGrammars(sharedGrammarsCacheDir(), { onNote: note });
+    note(res.message);
+    pulled = res.ok && res.status === "pulled";
+  }
+
+  await ensureGrammars(keys);
+
+  const tier = resolveGrammarsTier().tier;
+  const ready = keys.some((k) => grammarReady(k));
+  if (!ready) {
+    // Never silent: a degraded run must say so, and stay a SUCCESSFUL run —
+    // the regex tier still produces a complete, searchable result.
+    note(
+      `${label}: no tree-sitter grammars available (offline?) — extracting with the regex tier, so symbols and call sites are less precise. ` +
+        "Run `codeindex grammars pull` once online to enable AST precision.\n",
+    );
+  }
+  return { tier, ready, pulled, notes };
+}

package/src/engine-cli.ts

@@ -3,12 +3,7 @@ import { dirname, join, resolve } from "node:path";
 import { SCHEMA_VERSION, EXTRACTOR_VERSION, type FileRecord } from "./types.js";
 import { ENGINE_VERSION } from "./types.js";
 import { ensureGrammars, grammarKeysForExts, resolveGrammarsTier, sharedGrammarsCacheDir } from "./ast/loader.js";
-import {
-  resolveGrammarsPullTarget,
-  fetchGrammarsTarball,
-  fetchExpectedSha256,
-  extractGrammarsTarball,
-} from "./ast/grammars-pull.js";
+import { resolveGrammarsPullTarget, pullGrammars } from "./ast/grammars-pull.js";
 import { buildIndexArtifacts, buildArtifactsFromScan, type BuildIndexOptions } from "./pipeline.js";
 import { sha1 } from "./hash.js";
 import { renderGraphJson } from "./render/graph-json.js";
@@ -82,8 +77,27 @@ Commands:
   repomap     Token-budgeted map of the highest-PageRank files (--budget-tokens)
   hotspots    Churn × size ranking of the files where work concentrates (JSON)
   coupling    Change coupling: files that change together (JSON; --since <ref>)
-  mcp         Run as an MCP server over stdio (tools: scan_summary, graph,
-              symbols, callers, workspaces, churn, grep)
+  deadcode    Dead-code candidates in two labeled tiers: 'unreferenced' (no
+              call site binds AND nothing references the name) and 'uncalled'
+              (referenced — re-export, type position — but never called)
+  complexity  Cyclomatic-complexity estimates, most-complex first. Pass a file
+              positional for one file; omit for the repo-wide top
+  risk        Complexity × git-churn ranking (JSON; --since <ref> to bound)
+  mermaid     Mermaid diagram of the module graph; pass a module positional to
+              focus on one neighborhood
+  rewrite     Map an expensive tree-wide search onto its indexed equivalent:
+              cli.mjs rewrite '<command line>'. Prints the replacement command
+              and exits 0, or exits 1 when it has no opinion (run the original).
+              Deliberately conservative — any shell metacharacter or unknown
+              flag refuses the rewrite
+  mcp         Run as an MCP server over stdio (26 tools: scan_summary, graph,
+              symbols, callers, workspaces, churn, symbols_overview,
+              find_symbol, find_references, repo_map, hotspots, coupling,
+              dead_code, complexity, mermaid, grep, search, embed_status,
+              check_rules, the memory quartet and the three symbolic-edit
+              writes). Flags: --repo <dir> pins ONE repository so the per-tool
+              repo argument becomes optional (an explicit per-call repo still
+              wins); --server-name <name> overrides the announced serverInfo
   version     Print the engine version
 
 Flags:
@@ -113,6 +127,8 @@ Flags:
   --recall            \`callers\`: recall-oriented binding (issue #7) — relaxes
                       the JS/TS import gate to unique repo-wide names and labels
                       each site corroborated|unique-name
+  --ignore-case       \`grep\`: case-insensitive matching
+  --max-hits <n>      \`grep\`: cap returned hits (default 200)
 `;
 
 interface CliFlags {
@@ -217,6 +233,31 @@ function scanOptions(flags: CliFlags, precomputedWalk?: WalkResult): BuildIndexO
 // version/help/mcp return before we get there.
 const SCANLESS_COMMANDS = new Set(["grep", "churn", "coupling", "workspaces", "grammars"]);
 
+// Flags for `codeindex mcp`. Kept separate from parseFlags on purpose (see the
+// dispatch site). `--repo` is resolved to an absolute path and must exist: a
+// server pinned to a typo'd directory would otherwise answer every tool call
+// with the same confusing per-call error instead of failing at startup.
+export function parseMcpFlags(argv: string[]): { defaultRepo?: string; serverInfo?: { name?: string } } {
+  let defaultRepo: string | undefined;
+  let name: string | undefined;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--repo") {
+      const v = argv[++i];
+      if (!v) throw new Error("--repo requires a directory");
+      defaultRepo = resolve(v);
+    } else if (a === "--server-name") {
+      const v = argv[++i];
+      if (!v) throw new Error("--server-name requires a value");
+      name = v;
+    } else {
+      throw new Error(`unknown flag for \`mcp\`: ${a}`);
+    }
+  }
+  if (defaultRepo && !existsSync(defaultRepo)) throw new Error(`--repo path does not exist: ${defaultRepo}`);
+  return { defaultRepo, serverInfo: name ? { name } : undefined };
+}
+
 export async function runCli(argv: string[]): Promise<void> {
   const [cmd, ...rest] = argv;
   if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
@@ -227,9 +268,28 @@ export async function runCli(argv: string[]): Promise<void> {
     process.stdout.write(ENGINE_VERSION + "\n");
     return;
   }
+  if (cmd === "rewrite") {
+    // Host contract (iterion's `rewriters` kind, rtk's generalization): stdin
+    // is nothing, argv is ONE full command line, stdout is the command to run
+    // instead, and the exit code says whether to use it. Exit 1 = "no opinion,
+    // run the original" — the overwhelmingly common, deliberately cheap case.
+    const { rewriteCommand } = await import("./rewrite.js");
+    const rewritten = rewriteCommand(rest.join(" "));
+    if (!rewritten) {
+      process.exitCode = 1;
+      return;
+    }
+    process.stdout.write(rewritten + "\n");
+    return;
+  }
   if (cmd === "mcp") {
+    // `mcp` takes a deliberately tiny, self-contained flag set rather than
+    // going through parseFlags: the shared parser owns positional/scope
+    // semantics that mean nothing to a long-lived server, and every unknown
+    // flag there is fatal. Pinning is OPT-IN — a bare `codeindex mcp` keeps
+    // the historical contract where each tool call carries its own `repo`.
     const { runMcpServer } = await import("./mcp.js");
-    await runMcpServer();
+    await runMcpServer(parseMcpFlags(rest));
     return;
   }
 
@@ -593,81 +653,14 @@ export async function runCli(argv: string[]): Promise<void> {
       };
       emit(JSON.stringify(status, null, 2) + "\n", flags.out);
     } else if (sub === "pull") {
-      // Default: the official per-release asset + its `.sha256` sidecar. A
-      // user-set CODEINDEX_GRAMMARS_URL overrides both (mirror/custom, no
-      // verification). Fetch the expected digest from the sidecar first; a
-      // missing sidecar degrades to an unverified pull with a note (never fatal).
-      const target = resolveGrammarsPullTarget();
-      let expected: string | undefined;
-      if (target.sha256Url) {
-        try {
-          expected = await fetchExpectedSha256(target.sha256Url);
-        } catch (e) {
-          process.stderr.write(
-            `codeindex: could not fetch checksum (${e instanceof Error ? e.message : String(e)}) — proceeding unverified\n`,
-          );
-        }
-      }
-      // Idempotent: the marker sibling records the digest of the tarball that
-      // populated cacheDir. If the runtime wasm is present AND the marker matches
-      // the freshly-fetched digest, the cache is already up to date — skip the
-      // ~22 MB download entirely. (Keeps cacheDir itself byte-identical to the
-      // tarball; the marker lives next to it, never inside it.)
-      const runtime = join(cacheDir, "web-tree-sitter.wasm");
-      const markerPath = join(dirname(cacheDir), `${ENGINE_VERSION}.sha256`);
-      if (existsSync(runtime) && expected && existsSync(markerPath)) {
-        let marker = "";
-        try {
-          marker = readFileSync(markerPath, "utf8").trim();
-        } catch {
-          // unreadable marker → fall through and re-pull
-        }
-        if (marker === expected) {
-          process.stderr.write(`codeindex: grammars already present at ${cacheDir} (up to date)\n`);
-          return;
-        }
-      }
-      process.stderr.write(`codeindex: fetching grammars from ${target.url} → ${cacheDir}\n`);
-      let bytes: Uint8Array;
-      try {
-        // Follows redirects (GitHub → CDN) and verifies sha256 when known.
-        bytes = await fetchGrammarsTarball(target.url, expected);
-      } catch (e) {
-        process.stderr.write(`codeindex: pull failed — ${e instanceof Error ? e.message : String(e)} (nothing written)\n`);
-        process.exitCode = 1;
-        return;
-      }
-      // Atomic install: extract into a tmp dir SIBLING to cacheDir (same
-      // filesystem → rename is atomic), sanity-check the runtime wasm landed,
-      // then swap it into place. A failure at any step discards the tmp dir and
-      // leaves any existing cache untouched — a half-populated cache never shows.
-      let tmp: string | undefined;
-      try {
-        mkdirSync(dirname(cacheDir), { recursive: true });
-        tmp = mkdtempSync(join(dirname(cacheDir), ".grammars-tmp-"));
-        extractGrammarsTarball(bytes, tmp);
-        if (!existsSync(join(tmp, "web-tree-sitter.wasm"))) {
-          throw new Error("archive is missing web-tree-sitter.wasm");
-        }
-        if (existsSync(cacheDir)) rmSync(cacheDir, { recursive: true, force: true });
-        renameSync(tmp, cacheDir);
-        tmp = undefined;
-        if (expected) writeFileSync(markerPath, expected + "\n");
-      } catch (e) {
-        if (tmp) {
-          try {
-            rmSync(tmp, { recursive: true, force: true });
-          } catch {
-            // best-effort cleanup
-          }
-        }
-        process.stderr.write(
-          `codeindex: pull failed — ${e instanceof Error ? e.message : String(e)} (nothing written)\n`,
-        );
-        process.exitCode = 1;
-        return;
-      }
-      process.stderr.write(`codeindex: grammars extracted → ${cacheDir}\n`);
+      // The mechanic itself (sidecar checksum, idempotent skip, atomic install)
+      // lives in pullGrammars — shared verbatim with warmGrammars, so the CLI
+      // and the library warm-up can never drift apart. Here we only map its
+      // result onto the CLI contract: progress notes and the terminal message to
+      // stderr, non-zero exit on failure (which wrote nothing).
+      const res = await pullGrammars(cacheDir, { onNote: (m) => process.stderr.write(m) });
+      process.stderr.write(res.message);
+      if (!res.ok) process.exitCode = 1;
     } else {
       throw new Error("grammars needs a subcommand: status | pull");
     }
@@ -718,7 +711,12 @@ export async function runCli(argv: string[]): Promise<void> {
     emit(renderMermaid(graph, { module: flags.positional }), flags.out);
   } else if (cmd === "grep") {
     if (!flags.positional) throw new Error("grep needs a pattern: cli.mjs grep <pattern> --repo <dir>");
-    const globs = [...flags.include, ...flags.exclude.map((g) => `!${g}`)];
+    // `--scope <dir>` is documented as global sugar for `--include '<dir>/**'`;
+    // every other command gets it via scanOptions, but grep bypasses the scan
+    // and builds its own glob list — so it has to fold the sugar in itself, or
+    // the flag would be silently ignored here alone.
+    const scopeGlobs = flags.scope ? [`${flags.scope.replace(/\/+$/, "")}/**`] : [];
+    const globs = [...scopeGlobs, ...flags.include, ...flags.exclude.map((g) => `!${g}`)];
     const hits = grepRepo(flags.repo, flags.positional, {
       globs: globs.length ? globs : undefined,
       ignoreCase: flags.ignoreCase,

package/src/engine.ts

@@ -60,8 +60,14 @@ export {
   fetchExpectedSha256,
   extractTarInto,
   extractGrammarsTarball,
+  pullGrammars,
 } from "./ast/grammars-pull.js";
-export type { GrammarsPullTarget } from "./ast/grammars-pull.js";
+export type { GrammarsPullTarget, GrammarsPullResult } from "./ast/grammars-pull.js";
+// The one-call AST warm-up for consumers. `scanRepo` is synchronous and cannot
+// warm the grammars itself, so a consumer that never awaits this stays on the
+// regex tier forever — silently. Call it once at the CLI entry.
+export { warmGrammars } from "./ast/warm.js";
+export type { WarmGrammarsResult, WarmGrammarsOptions } from "./ast/warm.js";
 
 // Resolution + modules + graph tier.
 export { buildResolveContext, resolveImport, resolveDocLink } from "./resolve.js";
@@ -179,6 +185,13 @@ export type { RepoMapOptions } from "./repomap.js";
 export { runMcpServer } from "./mcp.js";
 export type { McpServerOptions } from "./mcp.js";
 
+// Command rewriting: an expensive tree-wide search → its indexed equivalent.
+// Exported so a host can decide for itself rather than shelling out to
+// `engine.mjs rewrite` (same conservative refusal semantics either way).
+// Only the decision function is public — the tokenizer/quoter are internal
+// details, and `tokenize` is already taken here by the wordpiece tokenizer.
+export { rewriteCommand } from "./rewrite.js";
+
 // General-purpose helpers shared by consumers (deterministic, dependency-free).
 export { sha1, shortHash } from "./hash.js";
 export { byStr, byKey } from "./sort.js";

package/src/mcp.ts

@@ -667,8 +667,11 @@ const SCANLESS_TOOLS = new Set([
   "embed_status",
 ]);
 
-async function callTool(name: string, args: Record<string, unknown>): Promise<string> {
-  const repo = str(args.repo);
+async function callTool(name: string, args: Record<string, unknown>, defaultRepo?: string): Promise<string> {
+  // An explicit per-call `repo` always wins; `defaultRepo` is the server-level
+  // pin (`codeindex mcp --repo <dir>`) that lets a host bind one server process
+  // to one workspace, so agents need not know — or restate — the absolute path.
+  const repo = str(args.repo) ?? defaultRepo;
   if (!repo) throw new Error("`repo` is required (absolute path to the repository root)");
   const scanOpts = { scope: str(args.scope), include: strArray(args.include), exclude: strArray(args.exclude) };
   // Scan-needing tools warm the present-language grammars (re-derived per call)
@@ -886,11 +889,36 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<st
   throw new Error(`unknown tool: ${name}`);
 }
 
+// The advertised tool list. Without a server-level repo pin this is TOOLS
+// verbatim (byte-compat for existing consumers). With one, every tool drops
+// `repo` from its `required` set and documents the default — so a client that
+// omits it is spec-correct rather than relying on the server being lenient.
+// The pin is reflected in the schema, not just honoured at call time.
+function toolsFor(defaultRepo?: string): readonly unknown[] {
+  if (!defaultRepo) return TOOLS;
+  return TOOLS.map((t) => ({
+    ...t,
+    inputSchema: {
+      ...t.inputSchema,
+      properties: {
+        ...t.inputSchema.properties,
+        repo: { type: "string", description: `Absolute path to the repository root (optional — defaults to ${defaultRepo})` },
+      },
+      required: (t.inputSchema.required as readonly string[]).filter((r) => r !== "repo"),
+    },
+  }));
+}
+
 export interface McpServerOptions {
   // Override the serverInfo announced in the initialize response — for
   // downstream consumers embedding this server under their own identity.
   // Omitted fields keep the defaults (name "codeindex", ENGINE_VERSION).
   serverInfo?: { name?: string; version?: string };
+  // Bind the server to ONE repository, so `repo` becomes optional on every
+  // tool (an explicit per-call `repo` still wins). This is what lets a host
+  // spawn one server per workspace — `codeindex mcp --repo <dir>` — instead of
+  // requiring the agent to thread an absolute path through every single call.
+  defaultRepo?: string;
 }
 
 export async function runMcpServer(opts: McpServerOptions = {}): Promise<void> {
@@ -898,6 +926,8 @@ export async function runMcpServer(opts: McpServerOptions = {}): Promise<void> {
     name: opts.serverInfo?.name ?? "codeindex",
     version: opts.serverInfo?.version ?? ENGINE_VERSION,
   };
+  // Derived ONCE: the pin cannot change mid-session, so neither can the list.
+  const tools = toolsFor(opts.defaultRepo);
   // No startup warm: each scan-needing tool warms the present-language grammars
   // for its repo before it runs (warmGrammarsForRepo re-derives them per call),
   // so a session that never scans — or only touches one language — loads no
@@ -940,13 +970,13 @@ export async function runMcpServer(opts: McpServerOptions = {}): Promise<void> {
       } else if (req.method === "ping") {
         send({ id: req.id, result: {} });
       } else if (req.method === "tools/list") {
-        send({ id: req.id, result: { tools: TOOLS } });
+        send({ id: req.id, result: { tools } });
       } else if (req.method === "tools/call") {
         const params = req.params ?? {};
         const name = str(params.name) ?? "";
         const args = (params.arguments ?? {}) as Record<string, unknown>;
         try {
-          const text = await callTool(name, args);
+          const text = await callTool(name, args, opts.defaultRepo);
           send({ id: req.id, result: { content: [{ type: "text", text }] } });
         } catch (e) {
           send({