@brainbank/mcp 0.2.0 → 0.3.1

package/dist/mcp-server.js

@@ -6,200 +6,258 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod/v3";
-import * as fs from "fs";
-import * as path from "path";
-import { BrainBank } from "brainbank";
-import { code } from "brainbank/code";
-import { git } from "brainbank/git";
-import { docs } from "brainbank/docs";
-var defaultRepoPath = process.env.BRAINBANK_REPO || void 0;
-async function createReranker() {
-  const rerankerEnv = process.env.BRAINBANK_RERANKER ?? "none";
-  if (rerankerEnv === "none") return void 0;
-  if (rerankerEnv === "qwen3") {
-    const { Qwen3Reranker } = await import("@brainbank/reranker");
-    return new Qwen3Reranker();
-  }
-  return void 0;
+import { existsSync as existsSync2 } from "fs";
+
+// src/workspace-pool.ts
+var DEFAULT_MAX_MEMORY_MB = 2048;
+var DEFAULT_TTL_MINUTES = 30;
+var EVICTION_INTERVAL_MS = 6e4;
+function formatAgo(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s ago`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m ago`;
+  return `${Math.round(ms / 36e5)}h ago`;
 }
-__name(createReranker, "createReranker");
-async function createEmbeddingProvider() {
-  const embeddingEnv = process.env.BRAINBANK_EMBEDDING ?? "local";
-  if (embeddingEnv === "openai") {
-    const { OpenAIEmbedding } = await import("brainbank");
-    return new OpenAIEmbedding();
+__name(formatAgo, "formatAgo");
+var WorkspacePool = class {
+  static {
+    __name(this, "WorkspacePool");
   }
-  if (embeddingEnv === "perplexity") {
-    const { PerplexityEmbedding } = await import("brainbank");
-    return new PerplexityEmbedding();
+  _pool = /* @__PURE__ */ new Map();
+  _timer = null;
+  _maxMemoryBytes;
+  _ttlMs;
+  _factory;
+  _onEvict;
+  _onError;
+  constructor(options) {
+    this._maxMemoryBytes = (options.maxMemoryMB ?? DEFAULT_MAX_MEMORY_MB) * 1024 * 1024;
+    this._ttlMs = (options.ttlMinutes ?? DEFAULT_TTL_MINUTES) * 60 * 1e3;
+    this._factory = options.factory;
+    this._onEvict = options.onEvict;
+    this._onError = options.onError;
+    this._timer = setInterval(() => this._evictStale(), EVICTION_INTERVAL_MS);
+    if (this._timer.unref) this._timer.unref();
   }
-  if (embeddingEnv === "perplexity-context") {
-    const { PerplexityContextEmbedding } = await import("brainbank");
-    return new PerplexityContextEmbedding();
+  /** Number of cached workspaces. */
+  get size() {
+    return this._pool.size;
   }
-  return void 0;
-}
-__name(createEmbeddingProvider, "createEmbeddingProvider");
-var MAX_POOL_SIZE = 10;
-var _pool = /* @__PURE__ */ new Map();
-var _sharedReranker = void 0;
-var _sharedEmbedding = void 0;
-var _sharedReady = false;
-async function ensureShared() {
-  if (_sharedReady) return;
-  _sharedReranker = await createReranker();
-  _sharedEmbedding = await createEmbeddingProvider();
-  _sharedReady = true;
-}
-__name(ensureShared, "ensureShared");
-async function getBrainBank(targetRepo) {
-  const rp = targetRepo ?? defaultRepoPath;
-  if (!rp) {
-    throw new Error(
-      "No repository specified. Pass the `repo` parameter with the workspace path, or set BRAINBANK_REPO environment variable."
-    );
+  /**
+   * Get a BrainBank for the given repo path.
+   * Returns a cached instance (with hot-reload) or creates a new one.
+   */
+  async get(repoPath) {
+    const key = repoPath.replace(/\/+$/, "");
+    const existing = this._pool.get(key);
+    if (existing) {
+      existing.lastAccess = Date.now();
+      try {
+        await existing.brain.ensureFresh();
+      } catch {
+      }
+      return existing.brain;
+    }
+    this._evictByMemoryPressure();
+    const brain = await this._factory(key);
+    this._pool.set(key, {
+      brain,
+      repoPath: key,
+      lastAccess: Date.now(),
+      createdAt: Date.now(),
+      activeOps: 0
+    });
+    return brain;
   }
-  const resolved = rp.replace(/\/+$/, "");
-  if (_pool.has(resolved)) {
-    const entry = _pool.get(resolved);
+  /**
+   * Execute an operation with active-op tracking.
+   * Prevents the workspace from being evicted while the operation runs.
+   */
+  async withBrain(repoPath, fn) {
+    const brain = await this.get(repoPath);
+    const key = repoPath.replace(/\/+$/, "");
+    const entry = this._pool.get(key);
+    if (entry) entry.activeOps++;
     try {
-      const codeStats = entry.brain.indexer("code")?.stats?.();
-      if (codeStats && codeStats.hnswSize === 0) {
-        const dbPath = path.join(resolved, ".brainbank", "brainbank.db");
-        const dbSize = fs.existsSync(dbPath) ? fs.statSync(dbPath).size : 0;
-        if (dbSize > 1e5) {
-          evictPool(resolved);
-        } else {
-          entry.lastAccess = Date.now();
-          return entry.brain;
-        }
-      } else {
+      return await fn(brain);
+    } finally {
+      if (entry) {
+        entry.activeOps--;
         entry.lastAccess = Date.now();
-        return entry.brain;
       }
-    } catch {
-      entry.lastAccess = Date.now();
-      return entry.brain;
     }
   }
-  await ensureShared();
-  if (_pool.size >= MAX_POOL_SIZE) {
-    let oldest;
-    let oldestTime = Infinity;
-    for (const [key, entry] of _pool) {
-      if (entry.lastAccess < oldestTime) {
-        oldestTime = entry.lastAccess;
-        oldest = key;
-      }
+  /** Manually evict a specific workspace. */
+  evict(repoPath) {
+    const key = repoPath.replace(/\/+$/, "");
+    this._evictEntry(key);
+  }
+  /** Get pool statistics. */
+  stats() {
+    const now = Date.now();
+    let totalMemory = 0;
+    const entries = [];
+    for (const entry of this._pool.values()) {
+      const memBytes = entry.brain.memoryHint();
+      const memMB = Math.round(memBytes / 1024 / 1024 * 100) / 100;
+      totalMemory += memBytes;
+      entries.push({
+        repoPath: entry.repoPath,
+        lastAccessAgo: formatAgo(now - entry.lastAccess),
+        memoryMB: memMB,
+        activeOps: entry.activeOps
+      });
     }
-    if (oldest) evictPool(oldest);
+    return {
+      size: this._pool.size,
+      totalMemoryMB: Math.round(totalMemory / 1024 / 1024 * 100) / 100,
+      entries
+    };
   }
-  const brain = await _createBrain(resolved);
-  _pool.set(resolved, { brain, lastAccess: Date.now() });
-  return brain;
-}
-__name(getBrainBank, "getBrainBank");
-async function _createBrain(resolved) {
-  const opts = { repoPath: resolved, reranker: _sharedReranker };
-  if (_sharedEmbedding) {
-    opts.embeddingProvider = _sharedEmbedding;
-    opts.embeddingDims = _sharedEmbedding.dims;
+  /** Close all entries and stop the eviction timer. */
+  close() {
+    if (this._timer) {
+      clearInterval(this._timer);
+      this._timer = null;
+    }
+    for (const key of [...this._pool.keys()]) {
+      this._evictEntry(key);
+    }
   }
-  const brain = new BrainBank(opts).use(code({ repoPath: resolved })).use(git({ repoPath: resolved })).use(docs());
-  try {
-    await brain.initialize();
-  } catch (err) {
-    if (err?.message?.includes("Invalid the given array length")) {
-      const dbPath = path.join(resolved, ".brainbank", "brainbank.db");
-      try {
-        fs.unlinkSync(dbPath);
-      } catch {
-      }
-      try {
-        fs.unlinkSync(dbPath + "-wal");
-      } catch {
-      }
-      try {
-        fs.unlinkSync(dbPath + "-shm");
-      } catch {
+  /** Evict workspaces that haven't been accessed within the TTL. */
+  _evictStale() {
+    const cutoff = Date.now() - this._ttlMs;
+    for (const [key, entry] of this._pool) {
+      if (entry.lastAccess < cutoff && entry.activeOps === 0) {
+        this._evictEntry(key);
       }
-      const fresh = new BrainBank(opts).use(code({ repoPath: resolved })).use(git({ repoPath: resolved })).use(docs());
-      await fresh.initialize();
-      return fresh;
     }
-    throw err;
   }
-  return brain;
-}
-__name(_createBrain, "_createBrain");
-function evictPool(resolved) {
-  const entry = _pool.get(resolved);
-  if (entry) {
+  /** Evict oldest idle entries until total memory is under the limit. */
+  _evictByMemoryPressure() {
+    let totalMemory = 0;
+    for (const entry of this._pool.values()) {
+      totalMemory += entry.brain.memoryHint();
+    }
+    if (totalMemory < this._maxMemoryBytes) return;
+    const candidates = [...this._pool.entries()].filter(([, e]) => e.activeOps === 0).sort(([, a], [, b]) => a.lastAccess - b.lastAccess);
+    for (const [key, entry] of candidates) {
+      if (totalMemory < this._maxMemoryBytes) break;
+      totalMemory -= entry.brain.memoryHint();
+      this._evictEntry(key);
+    }
+  }
+  /** Evict a single entry by key. */
+  _evictEntry(key) {
+    const entry = this._pool.get(key);
+    if (!entry) return;
     try {
       entry.brain.close();
-    } catch {
+    } catch (err) {
+      this._onError?.(key, err);
     }
-    _pool.delete(resolved);
+    this._pool.delete(key);
+    this._onEvict?.(key);
+  }
+};
+
+// src/workspace-factory.ts
+import * as fs from "fs";
+import * as path from "path";
+function findRepoRoot(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
   }
+  return path.resolve(startDir);
 }
-__name(evictPool, "evictPool");
+__name(findRepoRoot, "findRepoRoot");
+function resolveRepoPath(targetRepo) {
+  const rp = targetRepo ?? process.env.BRAINBANK_REPO ?? findRepoRoot(process.cwd());
+  return rp.replace(/\/+$/, "");
+}
+__name(resolveRepoPath, "resolveRepoPath");
+async function createWorkspaceBrain(repoPath) {
+  const { createBrain, resetFactoryCache } = await import("brainbank");
+  resetFactoryCache();
+  const context = {
+    repoPath,
+    env: process.env
+  };
+  const origLog = console.log;
+  console.log = (...args) => console.error(...args);
+  try {
+    const brain = await createBrain(context);
+    await brain.initialize();
+    return brain;
+  } finally {
+    console.log = origLog;
+  }
+}
+__name(createWorkspaceBrain, "createWorkspaceBrain");
+
+// src/mcp-server.ts
+var pool = new WorkspacePool({
+  factory: createWorkspaceBrain,
+  maxMemoryMB: parseInt(process.env.BRAINBANK_MAX_MEMORY_MB ?? "2048", 10),
+  ttlMinutes: parseInt(process.env.BRAINBANK_TTL_MINUTES ?? "30", 10),
+  onError: /* @__PURE__ */ __name((repo, err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`BrainBank pool error [${repo}]: ${msg}`);
+  }, "onError")
+});
+async function getBrainBank(targetRepo) {
+  return pool.get(resolveRepoPath(targetRepo));
+}
+__name(getBrainBank, "getBrainBank");
 var server = new McpServer({
   name: "brainbank",
-  version: "0.2.0"
+  version: "0.4.0"
 });
-server.registerTool(
-  "brainbank_search",
-  {
-    title: "BrainBank Search",
-    description: "Search indexed code and git commits. Supports three modes:\n- hybrid (default): vector + BM25 fused with RRF \u2014 best quality\n- vector: semantic similarity only\n- keyword: instant BM25 for exact terms, function names, error messages",
-    inputSchema: z.object({
-      query: z.string().describe("Search query \u2014 works with both keywords and natural language"),
-      mode: z.enum(["hybrid", "vector", "keyword"]).optional().default("hybrid").describe("Search strategy"),
-      codeK: z.number().optional().default(8).describe("Max code results"),
-      gitK: z.number().optional().default(5).describe("Max git results"),
-      minScore: z.number().optional().default(0.25).describe("Minimum similarity score (0-1), only for vector mode"),
-      collections: z.record(z.string(), z.number()).optional().describe(
-        'Max results per source. Reserved: "code", "git", "docs". Any other key = KV collection.'
-      ),
-      repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)")
-    })
-  },
-  async ({ query, mode, codeK, gitK, minScore, collections, repo }) => {
-    const brainbank = await getBrainBank(repo);
-    let results;
-    if (mode === "keyword") {
-      results = await brainbank.searchBM25(query, { codeK, gitK });
-    } else if (mode === "vector") {
-      results = await brainbank.search(query, { codeK, gitK, minScore });
-    } else {
-      results = await brainbank.hybridSearch(query, { codeK, gitK, collections });
-    }
-    if (results.length === 0) {
-      return { content: [{ type: "text", text: "No results found." }] };
-    }
-    const modeLabel = mode === "keyword" ? "Keyword (BM25)" : mode === "vector" ? "Vector" : "Hybrid (Vector + BM25 \u2192 RRF)";
-    return { content: [{ type: "text", text: formatResults(results, modeLabel) }] };
-  }
-);
 server.registerTool(
   "brainbank_context",
   {
     title: "BrainBank Context",
-    description: "Get a formatted knowledge context block for a task. Returns relevant code, git history, and co-edit patterns as markdown.",
+    description: "Get a formatted knowledge context block for a task. Returns a Workflow Trace: search hits + full call tree with `called by` annotations, topologically ordered. All source code included \u2014 no trimming, no truncation.",
     inputSchema: z.object({
       task: z.string().describe("Description of the task you need context for"),
       affectedFiles: z.array(z.string()).optional().default([]).describe("Files you plan to modify (improves co-edit suggestions)"),
-      codeResults: z.number().optional().default(6).describe("Max code results"),
+      codeResults: z.number().optional().default(20).describe("Max code results"),
       gitResults: z.number().optional().default(5).describe("Max git commit results"),
-      repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)")
+      docsResults: z.number().optional().describe("Max document results (omit to skip docs)"),
+      sources: z.record(z.number()).optional().describe("Per-source result limits, overrides codeResults/gitResults/docsResults (e.g. { code: 10, git: 0, docs: 5 })"),
+      path: z.string().optional().describe("Filter results to files under this path prefix (e.g. src/services/)"),
+      repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)"),
+      // BrainBankQL context fields
+      lines: z.boolean().optional().describe("Prefix each code line with its source line number (e.g. 127| code)"),
+      symbols: z.boolean().optional().describe("Append symbol index (all functions, classes, interfaces) for matched files"),
+      compact: z.boolean().optional().describe("Show only function/class signatures, skip bodies"),
+      callTree: z.union([z.boolean(), z.object({ depth: z.number() })]).optional().describe("Include call tree expansion. Pass { depth: N } to control depth"),
+      imports: z.boolean().optional().describe("Include dependency/import summary section"),
+      expander: z.boolean().optional().describe("Enable LLM-powered context expansion to discover related chunks not found by search")
     })
   },
-  async ({ task, affectedFiles, codeResults, gitResults, repo }) => {
+  async ({ task, affectedFiles, codeResults, gitResults, docsResults, sources, path: path2, repo, lines, symbols, compact, callTree, imports, expander }) => {
+    const repoPath = resolveRepoPath(repo);
     const brainbank = await getBrainBank(repo);
+    const base = { code: codeResults, git: gitResults };
+    if (docsResults !== void 0) base.docs = docsResults;
+    const resolvedSources = sources ? { ...base, ...sources } : base;
+    const fields = {};
+    if (lines !== void 0) fields.lines = lines;
+    if (symbols !== void 0) fields.symbols = symbols;
+    if (compact !== void 0) fields.compact = compact;
+    if (callTree !== void 0) fields.callTree = callTree;
+    if (imports !== void 0) fields.imports = imports;
+    if (expander !== void 0) fields.expander = expander;
     const context = await brainbank.getContext(task, {
       affectedFiles,
-      codeResults,
-      gitResults
+      sources: resolvedSources,
+      pathPrefix: path2,
+      source: "mcp",
+      fields: Object.keys(fields).length > 0 ? fields : void 0
     });
     return { content: [{ type: "text", text: context }] };
   }
@@ -208,195 +266,123 @@ server.registerTool(
   "brainbank_index",
   {
     title: "BrainBank Index",
-    description: "Index (or re-index) code, git history, and docs. Incremental \u2014 only changed files are processed.",
+    description: "Re-index code, git history, and docs. Requires .brainbank/config.json to exist. Incremental \u2014 only changed files are processed.",
     inputSchema: z.object({
-      modules: z.array(z.enum(["code", "git", "docs"])).optional().describe("Which modules to index (default: all)"),
-      docsPath: z.string().optional().describe("Path to a docs folder to register and index"),
       forceReindex: z.boolean().optional().default(false).describe("Force re-index of all files"),
-      gitDepth: z.number().optional().default(500).describe("Number of git commits to index"),
       repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)")
     })
   },
-  async ({ modules, docsPath, forceReindex, gitDepth, repo }) => {
-    const brainbank = await getBrainBank(repo);
-    if (docsPath) {
-      const absPath = path.resolve(docsPath);
-      const collName = path.basename(absPath);
-      try {
-        brainbank.addCollection({
-          name: collName,
-          path: absPath,
-          pattern: "**/*.md",
-          ignore: ["deprecated/**", "node_modules/**"]
-        });
-      } catch {
-      }
+  async ({ forceReindex, repo }) => {
+    const repoPath = resolveRepoPath(repo);
+    if (!existsSync2(`${repoPath}/.brainbank/config.json`)) {
+      return {
+        content: [{
+          type: "text",
+          text: `BrainBank: No .brainbank/config.json found at ${repoPath}.
+
+## How to set up
+
+Create \`${repoPath}/.brainbank/config.json\` with:
+
+\`\`\`json
+{
+  "plugins": ["code"],
+  "code": {
+    "embedding": "perplexity-context",
+    "ignore": [
+      "node_modules/**", "dist/**", "build/**",
+      ".next/**", "coverage/**", "__pycache__/**",
+      "**/*.min.js", "**/*.min.css",
+      "tests/**", "test/**",
+      "**/test_*.py", "**/*_test.py",
+      "**/*.test.ts", "**/*.spec.ts"
+    ]
+  },
+  "embedding": "perplexity-context"
+}
+\`\`\`
+
+**Embedding options:** \`local\` (free, offline), \`openai\`, \`perplexity\`, \`perplexity-context\` (best quality)
+**Plugins available:** \`code\`, \`git\`, \`docs\`
+
+Then run:
+\`\`\`bash
+brainbank index . --force --yes
+\`\`\``
+        }]
+      };
     }
-    const result = await brainbank.index({ modules, forceReindex, gitDepth });
-    const lines = [
-      "## Indexing Complete",
-      "",
-      `**Code**: ${result.code?.indexed ?? 0} files indexed, ${result.code?.skipped ?? 0} skipped, ${result.code?.chunks ?? 0} chunks`,
-      `**Git**: ${result.git?.indexed ?? 0} commits indexed, ${result.git?.skipped ?? 0} skipped`
-    ];
-    if (result.docs) {
-      for (const [name, stat] of Object.entries(result.docs)) {
+    const brainbank = await getBrainBank(repo);
+    const result = await brainbank.index({ forceReindex });
+    const lines = ["## Indexing Complete", ""];
+    const codeResult = result.code;
+    const gitResult = result.git;
+    lines.push(`**Code**: ${codeResult?.indexed ?? 0} files indexed, ${codeResult?.skipped ?? 0} skipped, ${codeResult?.chunks ?? 0} chunks`);
+    lines.push(`**Git**: ${gitResult?.indexed ?? 0} commits indexed, ${gitResult?.skipped ?? 0} skipped`);
+    const docsResult = result.docs;
+    if (docsResult) {
+      for (const [name, stat] of Object.entries(docsResult)) {
         lines.push(`**Docs [${name}]**: ${stat.indexed} indexed, ${stat.skipped} skipped, ${stat.chunks} chunks`);
       }
     }
     const stats = brainbank.stats();
+    const codeStats = stats.code;
+    const gitStats = stats.git;
+    const docStats = stats.documents;
     lines.push("");
-    lines.push(`**Totals**: ${stats.code?.chunks ?? 0} code chunks, ${stats.git?.commits ?? 0} commits, ${stats.documents?.documents ?? 0} docs`);
-    return { content: [{ type: "text", text: lines.join("\n") }] };
-  }
-);
-server.registerTool(
-  "brainbank_stats",
-  {
-    title: "BrainBank Stats",
-    description: "Get index statistics: file count, code chunks, git commits, HNSW sizes, KV collections.",
-    inputSchema: z.object({
-      repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)")
-    })
-  },
-  async ({ repo }) => {
-    const brainbank = await getBrainBank(repo);
-    const s = brainbank.stats();
-    const lines = ["## BrainBank Stats", ""];
-    if (s.code) {
-      lines.push(`**Code**: ${s.code.files} files, ${s.code.chunks} chunks, ${s.code.hnswSize} vectors`);
-    }
-    if (s.git) {
-      lines.push(`**Git**: ${s.git.commits} commits, ${s.git.filesTracked} files, ${s.git.coEdits} co-edit pairs`);
-    }
-    if (s.documents) {
-      lines.push(`**Docs**: ${s.documents.collections} collections, ${s.documents.documents} documents`);
-    }
-    const kvNames = brainbank.listCollectionNames();
-    if (kvNames.length > 0) {
-      lines.push("");
-      lines.push("**KV Collections**:");
-      for (const name of kvNames) {
-        const coll = brainbank.collection(name);
-        lines.push(`- ${name}: ${coll.count()} items`);
-      }
-    }
+    lines.push(`**Totals**: ${codeStats?.chunks ?? 0} code chunks, ${gitStats?.commits ?? 0} commits, ${docStats?.documents ?? 0} docs`);
     return { content: [{ type: "text", text: lines.join("\n") }] };
   }
 );
 server.registerTool(
-  "brainbank_history",
+  "brainbank_files",
   {
-    title: "BrainBank File History",
-    description: "Get git commit history for a file. Shows changes, authors, and line counts.",
+    title: "BrainBank Files",
+    description: 'Fetch full file contents from the index. Use AFTER brainbank_context to view complete files identified by search. No semantic search runs \u2014 this is a direct file viewer.\n\nSupports:\n- Exact paths: "src/auth/login.ts"\n- Directories: "src/graph/" (trailing / = all files under path)\n- Glob patterns: "src/**/*.service.ts"\n- Fuzzy basename: "plugin.ts" (matches src/plugin.ts when exact fails)',
     inputSchema: z.object({
-      filePath: z.string().describe('File path (relative or partial, e.g. "auth.ts")'),
-      limit: z.number().optional().default(20).describe("Max commits to return"),
-      repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)")
-    })
-  },
-  async ({ filePath, limit, repo }) => {
-    const brainbank = await getBrainBank(repo);
-    const history = await brainbank.fileHistory(filePath, limit);
-    if (history.length === 0) {
-      return { content: [{ type: "text", text: `No git history found for "${filePath}"` }] };
-    }
-    const lines = [`## Git History: ${filePath}`, ""];
-    for (const h of history) {
-      lines.push(`**[${h.short_hash}]** ${h.message} *(${h.author}, +${h.additions}/-${h.deletions})*`);
-    }
-    return { content: [{ type: "text", text: lines.join("\n") }] };
-  }
-);
-server.registerTool(
-  "brainbank_collection",
-  {
-    title: "BrainBank Collection",
-    description: "Operate on KV collections (auto-created). Actions:\n- add: store content with optional metadata\n- search: hybrid vector + keyword search\n- trim: keep only N most recent items",
-    inputSchema: z.object({
-      action: z.enum(["add", "search", "trim"]).describe("Operation to perform"),
-      collection: z.string().describe('Collection name (e.g. "errors", "decisions")'),
-      content: z.string().optional().describe("Content to store (required for add)"),
-      query: z.string().optional().describe("Search query (required for search)"),
-      metadata: z.record(z.any()).optional().default({}).describe("Metadata for add"),
-      k: z.number().optional().default(5).describe("Max results for search"),
-      keep: z.number().optional().describe("Items to keep for trim"),
-      repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)")
+      files: z.array(z.string()).describe(
+        "File paths to fetch. Exact paths, directories (trailing /), glob patterns (e.g. src/**/*.ts), or fuzzy basenames."
+      ),
+      repo: z.string().optional().describe("Repository path (default: BRAINBANK_REPO)"),
+      lines: z.boolean().optional().describe("Prefix each line with source line number")
     })
   },
-  async ({ action, collection, content, query, metadata, k, keep, repo }) => {
+  async ({ files, repo, lines }) => {
     const brainbank = await getBrainBank(repo);
-    const coll = brainbank.collection(collection);
-    if (action === "add") {
-      if (!content) throw new Error("BrainBank: content is required for add action.");
-      const id = await coll.add(content, metadata);
-      return {
-        content: [{ type: "text", text: `\u2713 Item #${id} added to '${collection}' (${coll.count()} total)` }]
-      };
+    const results = brainbank.resolveFiles(files);
+    if (results.length === 0) {
+      return { content: [{ type: "text", text: "No matching files found in the index." }] };
     }
-    if (action === "search") {
-      if (!query) throw new Error("BrainBank: query is required for search action.");
-      const results = await coll.search(query, { k });
-      if (results.length === 0) {
-        return { content: [{ type: "text", text: `No results in '${collection}' for "${query}"` }] };
-      }
-      const lines = [`## Collection: ${collection}`, ""];
-      for (const r of results) {
-        const score = Math.round((r.score ?? 0) * 100);
-        lines.push(`[${score}%] ${r.content}`);
-        if (Object.keys(r.metadata).length > 0) {
-          lines.push(`  ${JSON.stringify(r.metadata)}`);
-        }
-        lines.push("");
+    const parts = [];
+    for (const r of results) {
+      const meta = r.metadata;
+      const lang = meta.language ?? "";
+      const startLine = meta.startLine ?? 1;
+      parts.push(`## ${r.filePath}
+`);
+      parts.push("```" + lang);
+      if (lines) {
+        const codeLines = r.content.split("\n");
+        const pad = String(startLine + codeLines.length - 1).length;
+        parts.push(codeLines.map(
+          (l, i) => `${String(startLine + i).padStart(pad)}| ${l}`
+        ).join("\n"));
+      } else {
+        parts.push(r.content);
       }
-      return { content: [{ type: "text", text: lines.join("\n") }] };
-    }
-    if (action === "trim") {
-      if (keep == null) throw new Error("BrainBank: keep is required for trim action.");
-      const result = await coll.trim({ keep });
-      return {
-        content: [{ type: "text", text: `\u2713 Trimmed ${result.removed} items from '${collection}' (kept ${keep})` }]
-      };
+      parts.push("```\n");
     }
-    throw new Error(`BrainBank: Unknown action "${action}".`);
+    return { content: [{ type: "text", text: parts.join("\n") }] };
   }
 );
-function formatResults(results, mode) {
-  const lines = [`## ${mode}`, ""];
-  for (const r of results) {
-    const score = Math.round(r.score * 100);
-    if (r.type === "code") {
-      const m = r.metadata;
-      lines.push(`[CODE ${score}%] ${r.filePath} \u2014 ${m.name || m.chunkType} (L${m.startLine}-${m.endLine})`);
-      lines.push(r.content);
-      lines.push("");
-    } else if (r.type === "commit") {
-      const m = r.metadata;
-      lines.push(`[COMMIT ${score}%] ${m.shortHash} \u2014 ${r.content} (${m.author})`);
-      if (m.files?.length) lines.push(`  Files: ${m.files.join(", ")}`);
-      lines.push("");
-    } else if (r.type === "document") {
-      const ctx = r.context ? ` \u2014 ${r.context}` : "";
-      lines.push(`[DOC ${score}%] ${r.filePath} [${r.metadata.collection}]${ctx}`);
-      lines.push(r.content);
-      lines.push("");
-    } else if (r.type === "collection") {
-      const col = r.metadata?.collection ?? "unknown";
-      lines.push(`[COLLECTION ${score}%] [${col}]`);
-      lines.push(r.content);
-      lines.push("");
-    }
-  }
-  return lines.join("\n");
-}
-__name(formatResults, "formatResults");
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
 __name(main, "main");
 main().catch((err) => {
-  console.error(`BrainBank MCP Server Error: ${err.message}`);
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`BrainBank MCP Server Error: ${message}`);
   process.exit(1);
 });
 //# sourceMappingURL=mcp-server.js.map