brainbank 0.1.0

package/dist/cli.js

@@ -0,0 +1,731 @@
+#!/usr/bin/env node
+import {
+  BrainBank
+} from "./chunk-YGSEUWLV.js";
+import {
+  code
+} from "./chunk-EDKSKLX4.js";
+import {
+  git
+} from "./chunk-N6ZMBFDE.js";
+import {
+  docs
+} from "./chunk-GOUBW7UA.js";
+import "./chunk-4ZKBQ33J.js";
+import "./chunk-2P3EGY6S.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/integrations/cli.ts
+import * as path from "path";
+import * as fs from "fs";
+var c = {
+  green: /* @__PURE__ */ __name((s) => `\x1B[32m${s}\x1B[0m`, "green"),
+  red: /* @__PURE__ */ __name((s) => `\x1B[31m${s}\x1B[0m`, "red"),
+  yellow: /* @__PURE__ */ __name((s) => `\x1B[33m${s}\x1B[0m`, "yellow"),
+  cyan: /* @__PURE__ */ __name((s) => `\x1B[36m${s}\x1B[0m`, "cyan"),
+  dim: /* @__PURE__ */ __name((s) => `\x1B[2m${s}\x1B[0m`, "dim"),
+  bold: /* @__PURE__ */ __name((s) => `\x1B[1m${s}\x1B[0m`, "bold"),
+  magenta: /* @__PURE__ */ __name((s) => `\x1B[35m${s}\x1B[0m`, "magenta")
+};
+var args = process.argv.slice(2);
+var command = args[0];
+var subcommand = args[1];
+function getFlag(name) {
+  const idx = args.indexOf(`--${name}`);
+  return idx >= 0 ? args[idx + 1] : void 0;
+}
+__name(getFlag, "getFlag");
+function hasFlag(name) {
+  return args.includes(`--${name}`);
+}
+__name(hasFlag, "hasFlag");
+var CONFIG_NAMES = [
+  "config.ts",
+  "config.js",
+  "config.mjs"
+];
+var INDEXER_EXTENSIONS = [".ts", ".js", ".mjs"];
+var _configCache = void 0;
+var _folderIndexersCache = void 0;
+async function loadConfig() {
+  if (_configCache !== void 0) return _configCache;
+  const repoPath = getFlag("repo") ?? ".";
+  const brainbankDir = path.resolve(repoPath, ".brainbank");
+  for (const name of CONFIG_NAMES) {
+    const configPath = path.join(brainbankDir, name);
+    if (fs.existsSync(configPath)) {
+      try {
+        const mod = await import(configPath);
+        _configCache = mod.default ?? mod;
+        return _configCache;
+      } catch (err) {
+        console.error(c.red(`Error loading .brainbank/${name}: ${err.message}`));
+        process.exit(1);
+      }
+    }
+  }
+  _configCache = null;
+  return null;
+}
+__name(loadConfig, "loadConfig");
+async function discoverFolderIndexers() {
+  if (_folderIndexersCache !== void 0) return _folderIndexersCache;
+  const repoPath = getFlag("repo") ?? ".";
+  const indexersDir = path.resolve(repoPath, ".brainbank", "indexers");
+  if (!fs.existsSync(indexersDir)) {
+    _folderIndexersCache = [];
+    return [];
+  }
+  const files = fs.readdirSync(indexersDir).filter((f) => INDEXER_EXTENSIONS.some((ext) => f.endsWith(ext))).sort();
+  const indexers = [];
+  for (const file of files) {
+    const filePath = path.join(indexersDir, file);
+    try {
+      const mod = await import(filePath);
+      const indexer = mod.default ?? mod;
+      if (indexer && typeof indexer === "object" && indexer.name) {
+        indexers.push(indexer);
+      } else {
+        console.error(c.yellow(`\u26A0 ${file}: must export a default Indexer with a 'name' property, skipping`));
+      }
+    } catch (err) {
+      console.error(c.red(`Error loading indexer ${file}: ${err.message}`));
+    }
+  }
+  _folderIndexersCache = indexers;
+  return indexers;
+}
+__name(discoverFolderIndexers, "discoverFolderIndexers");
+async function createBrain(repoPath) {
+  const rp = repoPath ?? getFlag("repo") ?? ".";
+  const config = await loadConfig();
+  const folderIndexers = await discoverFolderIndexers();
+  const brainOpts = { repoPath: rp, ...config?.brainbank ?? {} };
+  const rerankerFlag = getFlag("reranker");
+  if (rerankerFlag === "qwen3") {
+    const { Qwen3Reranker } = await import("@brainbank/reranker");
+    brainOpts.reranker = new Qwen3Reranker();
+  }
+  const embeddingEnv = process.env.BRAINBANK_EMBEDDING;
+  if (embeddingEnv === "openai") {
+    const { OpenAIEmbedding } = await import("./openai-PCTYLOWI.js");
+    const provider = new OpenAIEmbedding();
+    brainOpts.embeddingProvider = provider;
+    brainOpts.embeddingDims = provider.dims;
+  }
+  const brain = new BrainBank(brainOpts);
+  const builtins = config?.builtins ?? ["code", "git", "docs"];
+  const resolvedRp = path.resolve(rp);
+  const hasRootGit = fs.existsSync(path.join(resolvedRp, ".git"));
+  const gitSubdirs = !hasRootGit ? detectGitSubdirs(resolvedRp) : [];
+  if (gitSubdirs.length > 0 && (builtins.includes("code") || builtins.includes("git"))) {
+    console.log(c.cyan(`  Multi-repo: found ${gitSubdirs.length} git repos: ${gitSubdirs.map((d) => d.name).join(", ")}`));
+    for (const sub of gitSubdirs) {
+      if (builtins.includes("code")) {
+        brain.use(code({ repoPath: sub.path, name: `code:${sub.name}` }));
+      }
+      if (builtins.includes("git")) {
+        brain.use(git({ repoPath: sub.path, name: `git:${sub.name}` }));
+      }
+    }
+  } else {
+    if (builtins.includes("code")) brain.use(code({ repoPath: rp }));
+    if (builtins.includes("git")) brain.use(git());
+  }
+  if (builtins.includes("docs")) brain.use(docs());
+  for (const indexer of folderIndexers) {
+    brain.use(indexer);
+  }
+  if (config?.indexers) {
+    for (const indexer of config.indexers) {
+      brain.use(indexer);
+    }
+  }
+  return brain;
+}
+__name(createBrain, "createBrain");
+function detectGitSubdirs(parentPath) {
+  try {
+    const entries = fs.readdirSync(parentPath, { withFileTypes: true });
+    return entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("node_modules") && fs.existsSync(path.join(parentPath, e.name, ".git"))
+    ).map((e) => ({ name: e.name, path: path.join(parentPath, e.name) }));
+  } catch {
+    return [];
+  }
+}
+__name(detectGitSubdirs, "detectGitSubdirs");
+async function cmdIndex() {
+  const repoPath = args[1] || ".";
+  const force = hasFlag("force");
+  const depth = parseInt(getFlag("depth") || "500", 10);
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank Index \u2501\u2501\u2501"));
+  console.log(c.dim(`  Repo: ${repoPath}`));
+  console.log(c.dim(`  Force: ${force}`));
+  console.log(c.dim(`  Git depth: ${depth}`));
+  const brain = await createBrain(repoPath);
+  const result = await brain.index({
+    forceReindex: force,
+    gitDepth: depth,
+    onProgress: /* @__PURE__ */ __name((stage, msg) => {
+      process.stdout.write(`\r  ${c.cyan(stage.toUpperCase())} ${msg}                    `);
+    }, "onProgress")
+  });
+  console.log("\n");
+  if (result.code) {
+    console.log(`  ${c.green("Code")}: ${result.code.indexed} indexed, ${result.code.skipped} skipped, ${result.code.chunks ?? 0} chunks`);
+  }
+  if (result.git) {
+    console.log(`  ${c.green("Git")}:  ${result.git.indexed} indexed, ${result.git.skipped} skipped`);
+  }
+  const stats = brain.stats();
+  console.log(`
+  ${c.bold("Totals")}:`);
+  if (stats.code) console.log(`    Code chunks:  ${stats.code.chunks}`);
+  if (stats.git) console.log(`    Git commits:  ${stats.git.commits}`);
+  if (stats.git) console.log(`    Co-edit pairs: ${stats.git.coEdits}`);
+  brain.close();
+}
+__name(cmdIndex, "cmdIndex");
+async function cmdCollection() {
+  const sub = args[1];
+  if (sub === "add") {
+    const path2 = args[2];
+    const name = getFlag("name");
+    const pattern = getFlag("pattern") ?? "**/*.md";
+    const context = getFlag("context");
+    const ignoreRaw = getFlag("ignore");
+    if (!path2 || !name) {
+      console.log(c.red('Usage: brainbank collection add <path> --name <name> [--pattern "**/*.md"] [--ignore "glob"] [--context "description"]'));
+      process.exit(1);
+    }
+    const brain = await createBrain();
+    await brain.addCollection({
+      name,
+      path: path2,
+      pattern,
+      ignore: ignoreRaw ? ignoreRaw.split(",") : [],
+      context: context ?? void 0
+    });
+    console.log(c.green(`\u2713 Collection '${name}' added: ${path2} (${pattern})`));
+    if (context) console.log(c.dim(`  Context: ${context}`));
+    brain.close();
+    return;
+  }
+  if (sub === "list") {
+    const brain = await createBrain();
+    await brain.initialize();
+    const collections = brain.listCollections();
+    if (collections.length === 0) {
+      console.log(c.yellow("  No collections registered."));
+    } else {
+      console.log(c.bold("\n\u2501\u2501\u2501 Collections \u2501\u2501\u2501\n"));
+      for (const col of collections) {
+        console.log(`  ${c.cyan(col.name)} ${c.dim("\u2192")} ${col.path}`);
+        console.log(`    Pattern: ${col.pattern ?? "**/*.md"}`);
+        if (col.context) console.log(`    Context: ${c.dim(col.context)}`);
+      }
+    }
+    brain.close();
+    return;
+  }
+  if (sub === "remove") {
+    const name = args[2];
+    if (!name) {
+      console.log(c.red("Usage: brainbank collection remove <name>"));
+      process.exit(1);
+    }
+    const brain = await createBrain();
+    await brain.removeCollection(name);
+    console.log(c.green(`\u2713 Collection '${name}' removed.`));
+    brain.close();
+    return;
+  }
+  console.log(c.red("Usage: brainbank collection <add|list|remove>"));
+  process.exit(1);
+}
+__name(cmdCollection, "cmdCollection");
+async function cmdKv() {
+  const sub = args[1];
+  if (sub === "add") {
+    const collName = args[2];
+    const content = args.slice(3).filter((a) => !a.startsWith("--")).join(" ");
+    const metaRaw = getFlag("meta");
+    if (!collName || !content) {
+      console.log(c.red(`Usage: brainbank kv add <collection> <content> [--meta '{"key":"val"}']`));
+      process.exit(1);
+    }
+    const brain = await createBrain();
+    await brain.initialize();
+    const coll = brain.collection(collName);
+    const meta = metaRaw ? JSON.parse(metaRaw) : {};
+    const id = await coll.add(content, meta);
+    console.log(c.green(`\u2713 Added item #${id} to '${collName}'`));
+    brain.close();
+    return;
+  }
+  if (sub === "search") {
+    const collName = args[2];
+    const query = args.slice(3).filter((a) => !a.startsWith("--")).join(" ");
+    const k = parseInt(getFlag("k") || "5", 10);
+    const mode = getFlag("mode") || "hybrid";
+    if (!collName || !query) {
+      console.log(c.red("Usage: brainbank kv search <collection> <query> [--k 5] [--mode hybrid|keyword|vector]"));
+      process.exit(1);
+    }
+    const brain = await createBrain();
+    await brain.initialize();
+    const coll = brain.collection(collName);
+    const results = await coll.search(query, { k, mode });
+    if (results.length === 0) {
+      console.log(c.yellow("  No results found."));
+    } else {
+      console.log(c.bold(`
+\u2501\u2501\u2501 ${collName}: "${query}" \u2501\u2501\u2501
+`));
+      for (const r of results) {
+        const score = Math.round((r.score ?? 0) * 100);
+        console.log(`  ${c.cyan(`[${score}%]`)} ${r.content}`);
+        if (Object.keys(r.metadata).length > 0) {
+          console.log(`    ${c.dim(JSON.stringify(r.metadata))}`);
+        }
+      }
+    }
+    brain.close();
+    return;
+  }
+  if (sub === "list") {
+    const collName = args[2];
+    const limit = parseInt(getFlag("limit") || "20", 10);
+    if (!collName) {
+      const brain2 = await createBrain();
+      await brain2.initialize();
+      const names = brain2.listCollectionNames();
+      if (names.length === 0) {
+        console.log(c.yellow("  No KV collections found."));
+      } else {
+        console.log(c.bold("\n\u2501\u2501\u2501 KV Collections \u2501\u2501\u2501\n"));
+        for (const n of names) {
+          const coll2 = brain2.collection(n);
+          console.log(`  ${c.cyan(n)} \u2014 ${coll2.count()} items`);
+        }
+      }
+      brain2.close();
+      return;
+    }
+    const brain = await createBrain();
+    await brain.initialize();
+    const coll = brain.collection(collName);
+    const items = coll.list({ limit });
+    if (items.length === 0) {
+      console.log(c.yellow(`  Collection '${collName}' is empty.`));
+    } else {
+      console.log(c.bold(`
+\u2501\u2501\u2501 ${collName} (${coll.count()} items) \u2501\u2501\u2501
+`));
+      for (const item of items) {
+        const age = Math.round((Date.now() / 1e3 - item.createdAt) / 60);
+        console.log(`  #${item.id} ${c.dim(`(${age}m ago)`)} ${item.content.slice(0, 80)}`);
+      }
+    }
+    brain.close();
+    return;
+  }
+  if (sub === "trim") {
+    const collName = args[2];
+    const keep = parseInt(getFlag("keep") || "0", 10);
+    if (!collName || keep <= 0) {
+      console.log(c.red("Usage: brainbank kv trim <collection> --keep <n>"));
+      process.exit(1);
+    }
+    const brain = await createBrain();
+    await brain.initialize();
+    const coll = brain.collection(collName);
+    const result = await coll.trim({ keep });
+    console.log(c.green(`\u2713 Trimmed ${result.removed} items from '${collName}' (kept ${keep})`));
+    brain.close();
+    return;
+  }
+  if (sub === "clear") {
+    const collName = args[2];
+    if (!collName) {
+      console.log(c.red("Usage: brainbank kv clear <collection>"));
+      process.exit(1);
+    }
+    const brain = await createBrain();
+    await brain.initialize();
+    const coll = brain.collection(collName);
+    const before = coll.count();
+    coll.clear();
+    console.log(c.green(`\u2713 Cleared ${before} items from '${collName}'`));
+    brain.close();
+    return;
+  }
+  console.log(c.red("Usage: brainbank kv <add|search|list|trim|clear>"));
+  process.exit(1);
+}
+__name(cmdKv, "cmdKv");
+async function cmdDocs() {
+  const collection = getFlag("collection");
+  const brain = await createBrain();
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank Docs Index \u2501\u2501\u2501\n"));
+  const opts = {};
+  if (collection) opts.collections = [collection];
+  opts.onProgress = (col, file, cur, total) => {
+    process.stdout.write(`\r  ${c.cyan(col)} [${cur}/${total}] ${file}                    `);
+  };
+  const results = await brain.indexDocs(opts);
+  console.log("\n");
+  for (const [name, stat] of Object.entries(results)) {
+    console.log(`  ${c.green(name)}: ${stat.indexed} indexed, ${stat.skipped} skipped, ${stat.chunks} chunks`);
+  }
+  brain.close();
+}
+__name(cmdDocs, "cmdDocs");
+async function cmdDocSearch() {
+  const query = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+  if (!query) {
+    console.log(c.red("Usage: brainbank dsearch <query>"));
+    process.exit(1);
+  }
+  const brain = await createBrain();
+  const collection = getFlag("collection");
+  const k = parseInt(getFlag("k") || "8", 10);
+  console.log(c.bold(`
+\u2501\u2501\u2501 BrainBank Doc Search: "${query}" \u2501\u2501\u2501
+`));
+  const results = await brain.searchDocs(query, { collection: collection ?? void 0, k });
+  if (results.length === 0) {
+    console.log(c.yellow("  No results found."));
+    brain.close();
+    return;
+  }
+  for (const r of results) {
+    const score = Math.round(r.score * 100);
+    const ctx = r.context ? ` \u2014 ${c.dim(r.context)}` : "";
+    console.log(`${c.magenta(`[DOC ${score}%]`)} ${c.bold(r.filePath)} [${r.metadata.collection}]${ctx}`);
+    const preview = r.content.split("\n").slice(0, 4).join("\n");
+    console.log(c.dim(preview));
+    console.log("");
+  }
+  brain.close();
+}
+__name(cmdDocSearch, "cmdDocSearch");
+async function cmdContext() {
+  const sub = args[1];
+  if (sub === "add") {
+    const collection = args[2];
+    const path2 = args[3];
+    const desc = args.slice(4).join(" ");
+    if (!collection || !path2 || !desc) {
+      console.log(c.red("Usage: brainbank context add <collection> <path> <description>"));
+      process.exit(1);
+    }
+    const brain2 = await createBrain();
+    await brain2.initialize();
+    brain2.addContext(collection, path2, desc);
+    console.log(c.green(`\u2713 Context added: ${collection}:${path2} \u2192 "${desc}"`));
+    brain2.close();
+    return;
+  }
+  if (sub === "list") {
+    const brain2 = await createBrain();
+    await brain2.initialize();
+    const contexts = brain2.listContexts();
+    if (contexts.length === 0) {
+      console.log(c.yellow("  No contexts configured."));
+    } else {
+      console.log(c.bold("\n\u2501\u2501\u2501 Contexts \u2501\u2501\u2501\n"));
+      for (const ctx of contexts) {
+        console.log(`  ${c.cyan(ctx.collection)}:${ctx.path} \u2192 ${c.dim(ctx.context)}`);
+      }
+    }
+    brain2.close();
+    return;
+  }
+  const task = args.slice(1).join(" ");
+  if (!task) {
+    console.log(c.red("Usage: brainbank context <task description>"));
+    console.log(c.dim("       brainbank context add <collection> <path> <description>"));
+    console.log(c.dim("       brainbank context list"));
+    process.exit(1);
+  }
+  const brain = await createBrain();
+  const context = await brain.getContext(task);
+  console.log(context);
+  brain.close();
+}
+__name(cmdContext, "cmdContext");
+async function cmdSearch() {
+  const query = args.slice(1).join(" ");
+  if (!query) {
+    console.log(c.red("Usage: brainbank search <query>"));
+    process.exit(1);
+  }
+  const brain = await createBrain();
+  console.log(c.bold(`
+\u2501\u2501\u2501 BrainBank Search: "${query}" \u2501\u2501\u2501
+`));
+  const results = await brain.search(query);
+  printResults(results);
+  brain.close();
+}
+__name(cmdSearch, "cmdSearch");
+async function cmdHybridSearch() {
+  const query = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+  if (!query) {
+    console.log(c.red("Usage: brainbank hsearch <query>"));
+    process.exit(1);
+  }
+  const brain = await createBrain();
+  console.log(c.bold(`
+\u2501\u2501\u2501 BrainBank Hybrid Search: "${query}" \u2501\u2501\u2501`));
+  console.log(c.dim(`  Mode: vector + BM25 \u2192 Reciprocal Rank Fusion
+`));
+  const results = await brain.hybridSearch(query);
+  printResults(results);
+  brain.close();
+}
+__name(cmdHybridSearch, "cmdHybridSearch");
+async function cmdKeywordSearch() {
+  const query = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+  if (!query) {
+    console.log(c.red("Usage: brainbank ksearch <query>"));
+    process.exit(1);
+  }
+  const brain = await createBrain();
+  await brain.initialize();
+  console.log(c.bold(`
+\u2501\u2501\u2501 BrainBank Keyword Search: "${query}" \u2501\u2501\u2501`));
+  console.log(c.dim(`  Mode: BM25 full-text (instant)
+`));
+  const results = brain.searchBM25(query);
+  printResults(results);
+  brain.close();
+}
+__name(cmdKeywordSearch, "cmdKeywordSearch");
+function printResults(results) {
+  if (results.length === 0) {
+    console.log(c.yellow("  No results found."));
+    return;
+  }
+  for (const r of results) {
+    const score = Math.round(r.score * 100);
+    if (r.type === "code") {
+      const m = r.metadata;
+      console.log(`${c.green(`[CODE ${score}%]`)} ${c.bold(r.filePath)} \u2014 ${m.name || m.chunkType} ${c.dim(`L${m.startLine}-${m.endLine}`)}`);
+      const preview = r.content.split("\n").slice(0, 5).join("\n");
+      console.log(c.dim(preview));
+      console.log("");
+    } else if (r.type === "commit") {
+      const m = r.metadata;
+      console.log(`${c.cyan(`[COMMIT ${score}%]`)} ${c.bold(m.shortHash)} ${r.content} ${c.dim(`(${m.author})`)}`);
+      if (m.files?.length) console.log(c.dim(`  Files: ${m.files.slice(0, 4).join(", ")}`));
+      console.log("");
+    } else if (r.type === "document") {
+      const ctx = r.context ? ` \u2014 ${c.dim(r.context)}` : "";
+      console.log(`${c.magenta(`[DOC ${score}%]`)} ${c.bold(r.filePath)} [${r.metadata.collection}]${ctx}`);
+      const preview = r.content.split("\n").slice(0, 4).join("\n");
+      console.log(c.dim(preview));
+      console.log("");
+    }
+  }
+}
+__name(printResults, "printResults");
+async function cmdStats() {
+  const brain = await createBrain();
+  await brain.initialize();
+  const s = brain.stats();
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank Stats \u2501\u2501\u2501\n"));
+  console.log(`  ${c.cyan("Indexers")}: ${brain.indexers.join(", ")}
+`);
+  if (s.code) {
+    console.log(`  ${c.cyan("Code")}`);
+    console.log(`    Files indexed:  ${s.code.files}`);
+    console.log(`    Code chunks:    ${s.code.chunks}`);
+    console.log(`    HNSW vectors:   ${s.code.hnswSize}`);
+    console.log("");
+  }
+  if (s.git) {
+    console.log(`  ${c.cyan("Git History")}`);
+    console.log(`    Commits:        ${s.git.commits}`);
+    console.log(`    Files tracked:  ${s.git.filesTracked}`);
+    console.log(`    Co-edit pairs:  ${s.git.coEdits}`);
+    console.log(`    HNSW vectors:   ${s.git.hnswSize}`);
+    console.log("");
+  }
+  if (s.documents) {
+    console.log(`  ${c.cyan("Documents")}`);
+    console.log(`    Collections:    ${s.documents.collections}`);
+    console.log(`    Documents:      ${s.documents.documents}`);
+    console.log(`    Chunks:         ${s.documents.chunks}`);
+    console.log(`    HNSW vectors:   ${s.documents.hnswSize}`);
+    console.log("");
+  }
+  const kvNames = brain.listCollectionNames();
+  if (kvNames.length > 0) {
+    console.log(`  ${c.cyan("KV Collections")}`);
+    for (const name of kvNames) {
+      const coll = brain.collection(name);
+      console.log(`    ${name}: ${coll.count()} items`);
+    }
+    console.log("");
+  }
+  brain.close();
+}
+__name(cmdStats, "cmdStats");
+async function cmdReembed() {
+  const brain = await createBrain();
+  await brain.initialize();
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank Re-embed \u2501\u2501\u2501\n"));
+  console.log(c.dim("  Regenerating vectors with current embedding provider..."));
+  console.log(c.dim("  Text, FTS, and metadata remain unchanged.\n"));
+  const result = await brain.reembed({
+    onProgress: /* @__PURE__ */ __name((table, current, total) => {
+      process.stdout.write(`\r  ${c.cyan(table.padEnd(8))} ${current}/${total}`);
+    }, "onProgress")
+  });
+  console.log("\n");
+  if (result.code > 0) console.log(`  ${c.green("\u2713")} Code:    ${result.code} vectors`);
+  if (result.git > 0) console.log(`  ${c.green("\u2713")} Git:     ${result.git} vectors`);
+  if (result.docs > 0) console.log(`  ${c.green("\u2713")} Docs:    ${result.docs} vectors`);
+  if (result.kv > 0) console.log(`  ${c.green("\u2713")} KV:      ${result.kv} vectors`);
+  if (result.notes > 0) console.log(`  ${c.green("\u2713")} Notes:   ${result.notes} vectors`);
+  if (result.memory > 0) console.log(`  ${c.green("\u2713")} Memory:  ${result.memory} vectors`);
+  console.log(`
+  ${c.bold("Total")}: ${result.total} vectors regenerated
+`);
+  brain.close();
+}
+__name(cmdReembed, "cmdReembed");
+async function cmdWatch() {
+  const brain = await createBrain();
+  await brain.initialize();
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank Watch \u2501\u2501\u2501\n"));
+  console.log(c.dim(`  Watching ${brain.config.repoPath} for changes...`));
+  console.log(c.dim("  Press Ctrl+C to stop.\n"));
+  const watcher = brain.watch({
+    debounceMs: 2e3,
+    onIndex: /* @__PURE__ */ __name((file, indexer) => {
+      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`  ${c.dim(ts)} ${c.green("\u2713")} ${c.cyan(indexer)}: ${file}`);
+    }, "onIndex"),
+    onError: /* @__PURE__ */ __name((err) => {
+      console.error(`  ${c.red("\u2717")} ${err.message}`);
+    }, "onError")
+  });
+  process.on("SIGINT", () => {
+    console.log(c.dim("\n  Stopping watcher..."));
+    watcher.close();
+    brain.close();
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+__name(cmdWatch, "cmdWatch");
+async function cmdServe() {
+  await import("@brainbank/mcp");
+}
+__name(cmdServe, "cmdServe");
+function showHelp() {
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank \u2014 Semantic Knowledge Bank \u2501\u2501\u2501\n"));
+  console.log(c.bold("Indexing:"));
+  console.log(`  ${c.cyan("index")} [path]                      Index code + git history`);
+  console.log(`  ${c.cyan("collection add")} <path> --name      Add a document collection`);
+  console.log(`  ${c.cyan("collection list")}                    List collections`);
+  console.log(`  ${c.cyan("collection remove")} <name>           Remove a collection`);
+  console.log(`  ${c.cyan("docs")} [--collection <name>]         Index document collections`);
+  console.log("");
+  console.log(c.bold("Search:"));
+  console.log(`  ${c.cyan("search")} <query>                     Semantic search (vector)`);
+  console.log(`  ${c.cyan("hsearch")} <query>                    Hybrid search (${c.bold("best quality")})`);
+  console.log(`  ${c.cyan("ksearch")} <query>                    Keyword search (BM25, instant)`);
+  console.log(`  ${c.cyan("dsearch")} <query>                    Document search`);
+  console.log("");
+  console.log(c.bold("Context:"));
+  console.log(`  ${c.cyan("context")} <task>                     Get formatted context for a task`);
+  console.log(`  ${c.cyan("context add")} <col> <path> <desc>    Add context metadata`);
+  console.log(`  ${c.cyan("context list")}                       List all context metadata`);
+  console.log("");
+  console.log(c.bold("KV Store:"));
+  console.log(`  ${c.cyan("kv add")} <coll> <content>            Add item to a collection`);
+  console.log(`  ${c.cyan("kv search")} <coll> <query>           Search a collection`);
+  console.log(`  ${c.cyan("kv list")} [coll]                     List collections or items`);
+  console.log(`  ${c.cyan("kv trim")} <coll> --keep <n>          Keep only N most recent`);
+  console.log(`  ${c.cyan("kv clear")} <coll>                    Clear all items`);
+  console.log("");
+  console.log(c.bold("Utility:"));
+  console.log(`  ${c.cyan("stats")}                              Show index statistics`);
+  console.log(`  ${c.cyan("reembed")}                            Re-embed all vectors`);
+  console.log(`  ${c.cyan("watch")}                              Watch files, auto-re-index`);
+  console.log(`  ${c.cyan("serve")}                              Start MCP server (stdio)`);
+  console.log("");
+  console.log(c.bold("Options:"));
+  console.log(`  ${c.dim("--repo <path>")}           Repository path (default: .)`);
+  console.log(`  ${c.dim("--force")}                 Force re-index all files`);
+  console.log(`  ${c.dim("--depth <n>")}             Git history depth (default: 500)`);
+  console.log(`  ${c.dim("--collection <name>")}     Filter by collection`);
+  console.log(`  ${c.dim("--pattern <glob>")}        Collection glob (default: **/*.md)`);
+  console.log(`  ${c.dim("--context <desc>")}        Context description`);
+  console.log(`  ${c.dim("--reranker <name>")}       Reranker to use (qwen3)`);
+  console.log("");
+  console.log(c.bold("Examples:"));
+  console.log(c.dim("  brainbank index ."));
+  console.log(c.dim('  brainbank kv add errors "Fixed null pointer in api.ts"'));
+  console.log(c.dim('  brainbank kv search errors "null pointer"'));
+  console.log(c.dim("  brainbank kv list"));
+  console.log(c.dim('  brainbank hsearch "authentication middleware"'));
+  console.log(c.dim('  brainbank context "add rate limiting to the API"'));
+  console.log(c.dim("  brainbank serve"));
+}
+__name(showHelp, "showHelp");
+async function main() {
+  switch (command) {
+    case "index":
+      return cmdIndex();
+    case "collection":
+      return cmdCollection();
+    case "kv":
+      return cmdKv();
+    case "docs":
+      return cmdDocs();
+    case "dsearch":
+      return cmdDocSearch();
+    case "search":
+      return cmdSearch();
+    case "hsearch":
+      return cmdHybridSearch();
+    case "ksearch":
+      return cmdKeywordSearch();
+    case "context":
+      return cmdContext();
+    case "stats":
+      return cmdStats();
+    case "reembed":
+      return cmdReembed();
+    case "watch":
+      return cmdWatch();
+    case "serve":
+      return cmdServe();
+    case "help":
+    case "--help":
+    case "-h":
+      showHelp();
+      break;
+    default:
+      if (command) console.log(c.red(`Unknown command: ${command}
+`));
+      showHelp();
+      process.exit(command ? 1 : 0);
+  }
+}
+__name(main, "main");
+main().catch((err) => {
+  console.error(c.red(`Error: ${err.message}`));
+  if (process.env.BRAINBANK_DEBUG) console.error(err.stack);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map