brainbank 0.1.0-beta.1

package/dist/cli.js

@@ -0,0 +1,3076 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_PORT,
+  isServerRunning,
+  removePid
+} from "./chunk-RDQYDLYZ.js";
+import {
+  SUPPORTED_EXTENSIONS,
+  VERSION,
+  args,
+  c,
+  contextFromCLI,
+  createBrain,
+  discoverExternalPlugins,
+  findDocsPlugin,
+  getConfig,
+  getFlag,
+  getFlagAll,
+  hasFlag,
+  isIgnoredDir,
+  isIgnoredFile,
+  loadConfig,
+  printResults,
+  registerConfigCollections,
+  stripFlags
+} from "./chunk-63GBCDS5.js";
+import "./chunk-M744PCJQ.js";
+import "./chunk-IMJJ2VEM.js";
+import {
+  __name,
+  __require
+} from "./chunk-WCQVDF3K.js";
+
+// src/cli/commands/index.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+
+// src/cli/commands/mcp-export.ts
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var TARGETS = {
+  antigravity: {
+    configPath: path.join(process.env.HOME ?? "~", ".gemini", "antigravity", "mcp_config.json"),
+    label: "Gemini Antigravity"
+  }
+};
+function buildBrainbankMcpBlock(config) {
+  const nodeBin = process.execPath;
+  const globalCliJs = path.join(path.dirname(nodeBin), "..", "lib", "node_modules", "brainbank", "dist", "cli.js");
+  const localCliJs = path.resolve(__dirname, "..", "..", "dist", "cli.js");
+  const resolvedCliJs = fs.existsSync(globalCliJs) ? globalCliJs : localCliJs;
+  const env = {};
+  const keys = config?.keys;
+  const perplexityKey = keys?.perplexity ?? process.env.PERPLEXITY_API_KEY;
+  const anthropicKey = keys?.anthropic ?? process.env.ANTHROPIC_API_KEY;
+  const openaiKey = keys?.openai ?? process.env.OPENAI_API_KEY;
+  if (perplexityKey) env.PERPLEXITY_API_KEY = perplexityKey;
+  if (anthropicKey) env.ANTHROPIC_API_KEY = anthropicKey;
+  if (openaiKey) env.OPENAI_API_KEY = openaiKey;
+  const block = {
+    command: nodeBin,
+    args: ["--disable-warning=ExperimentalWarning", resolvedCliJs, "mcp"]
+  };
+  if (Object.keys(env).length > 0) {
+    block.env = env;
+  }
+  return block;
+}
+__name(buildBrainbankMcpBlock, "buildBrainbankMcpBlock");
+function mergeAndWrite(targetPath, block) {
+  let existing = { mcpServers: {} };
+  const created = !fs.existsSync(targetPath);
+  if (!created) {
+    try {
+      const raw = fs.readFileSync(targetPath, "utf-8");
+      existing = JSON.parse(raw);
+      if (!existing.mcpServers) existing.mcpServers = {};
+    } catch {
+      existing = { mcpServers: {} };
+    }
+  }
+  existing.mcpServers.brainbank = block;
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.writeFileSync(targetPath, JSON.stringify(existing, null, 2) + "\n");
+  return { created };
+}
+__name(mergeAndWrite, "mergeAndWrite");
+function hasBrainbankMcpEntry(targetPath) {
+  if (!fs.existsSync(targetPath)) return false;
+  try {
+    const raw = fs.readFileSync(targetPath, "utf-8");
+    const config = JSON.parse(raw);
+    return !!config.mcpServers?.brainbank;
+  } catch {
+    return false;
+  }
+}
+__name(hasBrainbankMcpEntry, "hasBrainbankMcpEntry");
+async function autoExportMcp(repoPath) {
+  const target = TARGETS.antigravity;
+  if (!target) return;
+  const antigravityDir = path.dirname(target.configPath);
+  if (!fs.existsSync(antigravityDir)) return;
+  if (hasBrainbankMcpEntry(target.configPath)) return;
+  const config = await getConfig(repoPath);
+  const block = buildBrainbankMcpBlock(config);
+  mergeAndWrite(target.configPath, block);
+  console.log(`  ${c.green("\u2713")} Exported MCP config to ${c.dim(path.relative(process.env.HOME ?? "", target.configPath))}`);
+}
+__name(autoExportMcp, "autoExportMcp");
+var BRAINBANK_SECTION_MARKER = "<!-- brainbank:start -->";
+var BRAINBANK_SECTION_END = "<!-- brainbank:end -->";
+var GLOBAL_GEMINI = path.join(process.env.HOME ?? "~", ".gemini", "GEMINI.md");
+function buildGeminiSection() {
+  return `${BRAINBANK_SECTION_MARKER}
+
+## BrainBank \u2014 Code Intelligence
+
+**\`brainbank_context\`** \u2014 semantic code discovery. Use it **only** when you need to understand functionality that spans multiple files (e.g. "how does auth work", "notification pipeline"). \`repo\` is **required**.
+
+**Do NOT use it for:** finding a specific string, variable, function name, or exact match \u2014 use \`grep_search\` for that. BrainBank is for *understanding context*, not for *locating text*.
+
+**Params:** \`compact: false\`, \`sources: { code: 25, docs: 0, git: 0 }\`. Only add \`docs\` when the user explicitly asks about documentation.
+
+### Output handling \u2014 MANDATORY
+
+BrainBank may return results **inline** or save them to an **output file**:
+
+- **Inline:** read and proceed normally.
+- **File result** (saved to \`output.txt\`): you **MUST STOP IMMEDIATELY**. Show the path as a clickable link, ask the user to paste, then **DO NOT PROCEED**:
+
+  \u{1F4CB} Output: [output.txt](file:///path/to/output.txt) \u2014 _"Could you paste the context output here?"_
+
+  **NEVER** read the file yourself. **NEVER** continue working. Wait for the user to paste the content. This is not optional.
+
+${BRAINBANK_SECTION_END}
+`;
+}
+__name(buildGeminiSection, "buildGeminiSection");
+function hasGeminiSection(geminiPath) {
+  if (!fs.existsSync(geminiPath)) return false;
+  const content = fs.readFileSync(geminiPath, "utf-8");
+  return content.includes(BRAINBANK_SECTION_MARKER);
+}
+__name(hasGeminiSection, "hasGeminiSection");
+function appendGeminiSection(geminiPath) {
+  const section = buildGeminiSection();
+  if (fs.existsSync(geminiPath)) {
+    fs.appendFileSync(geminiPath, section);
+  } else {
+    fs.writeFileSync(geminiPath, `# GEMINI.md
+${section}`);
+  }
+}
+__name(appendGeminiSection, "appendGeminiSection");
+function replaceGeminiSection(geminiPath) {
+  const content = fs.readFileSync(geminiPath, "utf-8");
+  const startIdx = content.indexOf(BRAINBANK_SECTION_MARKER);
+  const endIdx = content.indexOf(BRAINBANK_SECTION_END);
+  if (startIdx === -1 || endIdx === -1) return;
+  const before = content.slice(0, startIdx);
+  const after = content.slice(endIdx + BRAINBANK_SECTION_END.length);
+  const section = buildGeminiSection();
+  fs.writeFileSync(geminiPath, before + section + after);
+}
+__name(replaceGeminiSection, "replaceGeminiSection");
+async function cmdMcpExport() {
+  const targetName = args[1] || getFlag("target") || "antigravity";
+  const repoPath = getFlag("repo") || ".";
+  const force = args.includes("--force") || args.includes("-f");
+  const target = TARGETS[targetName];
+  if (!target) {
+    console.error(c.red(`Unknown export target: ${targetName}`));
+    console.error(c.dim(`  Available: ${Object.keys(TARGETS).join(", ")}`));
+    process.exit(1);
+  }
+  const config = await getConfig(repoPath);
+  const block = buildBrainbankMcpBlock(config);
+  console.log(c.bold(`
+\u2501\u2501\u2501 MCP Export: ${target.label} \u2501\u2501\u2501
+`));
+  const mcpExists = hasBrainbankMcpEntry(target.configPath);
+  let writeMcp = true;
+  if (mcpExists && !force) {
+    console.log(`  ${c.yellow("\u25CF")} MCP config already has brainbank entry`);
+    const cliPath = block.args.find((a) => !a.startsWith("--")) ?? block.args[0];
+    console.log(`  ${c.dim("  New:")} ${block.command} ${cliPath}`);
+    const envKeys = block.env ? Object.keys(block.env) : [];
+    if (envKeys.length > 0) console.log(`  ${c.dim("  Keys:")} ${envKeys.join(", ")}`);
+    const { confirm } = await import("@inquirer/prompts");
+    writeMcp = await confirm({ message: "Override existing brainbank MCP entry?", default: true });
+  }
+  if (writeMcp) {
+    const { created } = mergeAndWrite(target.configPath, block);
+    console.log(`  ${c.green("\u2713")} ${created ? "Created" : "Updated"} ${c.dim(target.configPath)}`);
+  } else {
+    console.log(`  ${c.dim("MCP config \u2014 skipped")}`);
+  }
+  const geminiHasSection = hasGeminiSection(GLOBAL_GEMINI);
+  if (geminiHasSection) {
+    if (force) {
+      replaceGeminiSection(GLOBAL_GEMINI);
+      console.log(`  ${c.green("\u2713")} Replaced BrainBank section in ${c.dim("~/.gemini/GEMINI.md")}`);
+    } else {
+      console.log(`  ${c.yellow("\u25CF")} ~/.gemini/GEMINI.md already has BrainBank section`);
+      const { confirm } = await import("@inquirer/prompts");
+      const override = await confirm({ message: "Override existing BrainBank section?", default: false });
+      if (override) {
+        replaceGeminiSection(GLOBAL_GEMINI);
+        console.log(`  ${c.green("\u2713")} Replaced BrainBank section in ${c.dim("~/.gemini/GEMINI.md")}`);
+      } else {
+        console.log(`  ${c.dim("GEMINI.md \u2014 skipped")}`);
+      }
+    }
+  } else {
+    if (force) {
+      appendGeminiSection(GLOBAL_GEMINI);
+      console.log(`  ${c.green("\u2713")} Added BrainBank section to ${c.dim("~/.gemini/GEMINI.md")}`);
+    } else {
+      const { confirm } = await import("@inquirer/prompts");
+      const addGemini = await confirm({
+        message: "Add BrainBank instructions to ~/.gemini/GEMINI.md? (teaches AI tools how to use BrainBank)",
+        default: true
+      });
+      if (addGemini) {
+        appendGeminiSection(GLOBAL_GEMINI);
+        console.log(`  ${c.green("\u2713")} Added BrainBank section to ${c.dim("~/.gemini/GEMINI.md")}`);
+      }
+    }
+  }
+  console.log(`
+  ${c.dim("Restart your IDE to apply changes.")}
+`);
+}
+__name(cmdMcpExport, "cmdMcpExport");
+
+// src/cli/commands/scan.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { execSync } from "child_process";
+import picomatch from "picomatch";
+function scanRepo(repoPath) {
+  const resolved = path2.resolve(repoPath);
+  const config = scanConfig(resolved);
+  return {
+    repoPath: resolved,
+    modules: scanModules(resolved, config),
+    config,
+    db: scanDb(resolved)
+  };
+}
+__name(scanRepo, "scanRepo");
+function scanModules(repoPath, config) {
+  return [
+    scanCodeModule(repoPath, config.include, config.ignore),
+    scanGitModule(repoPath),
+    scanDocsModule(repoPath)
+  ];
+}
+__name(scanModules, "scanModules");
+function scanCodeModule(repoPath, include, ignore) {
+  const byLanguage = /* @__PURE__ */ new Map();
+  let total = 0;
+  let isIncluded = null;
+  let isIgnoredPat = null;
+  let includeBases = null;
+  if (include?.length) {
+    isIncluded = picomatch(include, { dot: true });
+    includeBases = include.map((p) => picomatch.scan(p).base).filter((b) => b && b !== ".");
+  }
+  if (ignore?.length) isIgnoredPat = picomatch(ignore, { dot: true });
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      const isDir = entry.isDirectory() || entry.isSymbolicLink() && (() => {
+        try {
+          return fs2.statSync(fullPath).isDirectory();
+        } catch {
+          return false;
+        }
+      })();
+      if (isDir) {
+        if (isIgnoredDir(entry.name)) continue;
+        if (includeBases && includeBases.length > 0) {
+          const relDir = path2.relative(repoPath, fullPath);
+          const canMatch = includeBases.some(
+            (base) => relDir.startsWith(base) || base.startsWith(relDir)
+          );
+          if (!canMatch) continue;
+        }
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        if (isIgnoredFile(entry.name)) continue;
+        const ext = path2.extname(entry.name).toLowerCase();
+        const lang = SUPPORTED_EXTENSIONS[ext];
+        if (!lang) continue;
+        const rel = path2.relative(repoPath, fullPath);
+        if (isIncluded && !isIncluded(rel)) continue;
+        if (isIgnoredPat && isIgnoredPat(rel)) continue;
+        byLanguage.set(lang, (byLanguage.get(lang) ?? 0) + 1);
+        total++;
+      }
+    }
+  }
+  __name(walk, "walk");
+  walk(repoPath);
+  if (total === 0) {
+    return { name: "code", available: false, summary: "no supported source files found", icon: "\u{1F4C1}", checked: false, disabled: "nothing to index" };
+  }
+  const langCount = byLanguage.size;
+  const sorted = [...byLanguage.entries()].sort((a, b) => b[1] - a[1]);
+  const maxShow = 7;
+  const shown = sorted.slice(0, maxShow);
+  const remaining = sorted.length - maxShow;
+  const details = [];
+  for (let i = 0; i < shown.length; i++) {
+    const [lang, count] = shown[i];
+    const isLast = i === shown.length - 1 && remaining <= 0;
+    const prefix = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+    details.push(`${prefix} ${lang.padEnd(14)} ${count} files`);
+  }
+  if (remaining > 0) {
+    details.push(`\u2514\u2500\u2500 ...and ${remaining} more`);
+  }
+  return {
+    name: "code",
+    available: true,
+    summary: `${total} files (${langCount} language${langCount > 1 ? "s" : ""})`,
+    icon: "\u{1F4C1}",
+    checked: true,
+    details
+  };
+}
+__name(scanCodeModule, "scanCodeModule");
+function scanGitModule(repoPath) {
+  const stats = scanGitStats(repoPath);
+  if (!stats) {
+    return { name: "git", available: false, summary: "no .git directory found", icon: "\u{1F4DC}", checked: false, disabled: "not a git repo" };
+  }
+  const details = [];
+  if (stats.lastMessage) {
+    details.push(`Last: ${stats.lastMessage} (${stats.lastDate})`);
+  }
+  return {
+    name: "git",
+    available: true,
+    summary: `${stats.commitCount.toLocaleString()} commits`,
+    icon: "\u{1F4DC}",
+    checked: true,
+    details
+  };
+}
+__name(scanGitModule, "scanGitModule");
+function scanDocsModule(repoPath) {
+  const collections = scanDocsCollections(repoPath);
+  if (collections.length === 0) {
+    return { name: "docs", available: false, summary: "no documents found", icon: "\u{1F4C4}", checked: false, disabled: "no .md/.mdx files" };
+  }
+  const totalFiles = collections.reduce((s, d) => s + d.fileCount, 0);
+  const details = collections.map((d, i) => {
+    const isLast = i === collections.length - 1;
+    const prefix = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+    return `${prefix} ${d.name.padEnd(10)} \u2192 ${d.path} (${d.fileCount} files)`;
+  });
+  return {
+    name: "docs",
+    available: true,
+    summary: `${collections.length} collection${collections.length > 1 ? "s" : ""} (${totalFiles} files)`,
+    icon: "\u{1F4C4}",
+    checked: true,
+    details
+  };
+}
+__name(scanDocsModule, "scanDocsModule");
+function scanGitStats(repoPath) {
+  if (!fs2.existsSync(path2.join(repoPath, ".git"))) return null;
+  return gitStats(repoPath);
+}
+__name(scanGitStats, "scanGitStats");
+function gitStats(dir) {
+  try {
+    const count = parseInt(execSync("git rev-list --count HEAD", { cwd: dir, encoding: "utf-8" }).trim(), 10);
+    const log = execSync('git log -1 --format="%s|%ar"', { cwd: dir, encoding: "utf-8" }).trim();
+    const [lastMessage, lastDate] = log.split("|");
+    return { commitCount: count, lastMessage: lastMessage ?? "", lastDate: lastDate ?? "" };
+  } catch {
+    return null;
+  }
+}
+__name(gitStats, "gitStats");
+function scanDocsCollections(repoPath) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const configPath = path2.join(repoPath, ".brainbank", "config.json");
+  try {
+    if (fs2.existsSync(configPath)) {
+      const config = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+      const docsCfg = config?.docs;
+      const collections = docsCfg?.collections;
+      if (collections) {
+        for (const coll of collections) {
+          const absPath = path2.resolve(repoPath, coll.path);
+          results.push({ name: coll.name, path: coll.path, fileCount: countDocs(absPath) });
+          seen.add(absPath);
+        }
+      }
+    }
+  } catch {
+  }
+  const rootDocs = countDocsShallow(repoPath);
+  if (rootDocs > 0) {
+    results.push({ name: "(root)", path: ".", fileCount: rootDocs });
+  }
+  try {
+    for (const entry of fs2.readdirSync(repoPath, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (isIgnoredDir(entry.name)) continue;
+      if (entry.name.startsWith(".")) continue;
+      const dirPath = path2.join(repoPath, entry.name);
+      if (seen.has(dirPath)) continue;
+      const count = countDocs(dirPath);
+      if (count > 0) {
+        results.push({ name: entry.name, path: `./${entry.name}`, fileCount: count });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+__name(scanDocsCollections, "scanDocsCollections");
+function countDocs(dir) {
+  let count = 0;
+  try {
+    for (const e of fs2.readdirSync(dir, { withFileTypes: true })) {
+      const ePath = path2.join(dir, e.name);
+      const isDir = e.isDirectory() || e.isSymbolicLink() && (() => {
+        try {
+          return fs2.statSync(ePath).isDirectory();
+        } catch {
+          return false;
+        }
+      })();
+      if (isDir) {
+        if (isIgnoredDir(e.name)) continue;
+        count += countDocs(ePath);
+      } else if ((e.isFile() || e.isSymbolicLink()) && /\.mdx?$/i.test(e.name)) {
+        count++;
+      }
+    }
+  } catch {
+  }
+  return count;
+}
+__name(countDocs, "countDocs");
+function countDocsShallow(dir) {
+  let count = 0;
+  try {
+    for (const e of fs2.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isFile() && /\.mdx?$/i.test(e.name)) count++;
+    }
+  } catch {
+  }
+  return count;
+}
+__name(countDocsShallow, "countDocsShallow");
+function scanConfig(repoPath) {
+  const configPath = path2.join(repoPath, ".brainbank", "config.json");
+  if (!fs2.existsSync(configPath)) return { exists: false };
+  try {
+    const config = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    const codeCfg = config?.code;
+    const rootInclude = config?.include;
+    const rootIgnore = config?.ignore;
+    const pluginInclude = codeCfg?.include;
+    const pluginIgnore = codeCfg?.ignore;
+    const include = [...rootInclude ?? [], ...pluginInclude ?? []];
+    const ignore = [...rootIgnore ?? [], ...pluginIgnore ?? []];
+    return {
+      exists: true,
+      ignore: ignore.length > 0 ? ignore : void 0,
+      include: include.length > 0 ? include : void 0,
+      plugins: config?.plugins
+    };
+  } catch {
+    return { exists: false };
+  }
+}
+__name(scanConfig, "scanConfig");
+function scanDb(repoPath) {
+  const dbPath = path2.join(repoPath, ".brainbank", "data", "brainbank.db");
+  if (!fs2.existsSync(dbPath)) return { exists: false, sizeMB: 0 };
+  try {
+    const stat = fs2.statSync(dbPath);
+    return {
+      exists: true,
+      sizeMB: Math.round(stat.size / 1024 / 1024 * 10) / 10,
+      lastModified: stat.mtime
+    };
+  } catch {
+    return { exists: false, sizeMB: 0 };
+  }
+}
+__name(scanDb, "scanDb");
+
+// src/cli/tui/index-tui.tsx
+import { useState, useMemo, useCallback, useEffect, useRef } from "react";
+import { render, Box, Text, useApp, useInput, useStdout } from "ink";
+
+// src/cli/tui/tree-scanner.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { execSync as execSync2 } from "child_process";
+import picomatch2 from "picomatch";
+var EXT_COLORS = {
+  ".ts": "#519ABA",
+  ".tsx": "#519ABA",
+  ".js": "#CBCB41",
+  ".jsx": "#61DAFB",
+  ".mjs": "#CBCB41",
+  ".py": "#4B8BBE",
+  ".go": "#7FD5EA",
+  ".rs": "#DEA584",
+  ".rb": "#CC3E44",
+  ".java": "#CC3E44",
+  ".c": "#599EFF",
+  ".cpp": "#599EFF",
+  ".h": "#926BD4",
+  ".cs": "#68217A",
+  ".php": "#777BB3",
+  ".swift": "#F05138",
+  ".kt": "#7F52FF",
+  ".css": "#42A5F5",
+  ".scss": "#F06292",
+  ".html": "#E44D26",
+  ".vue": "#8DC149",
+  ".svelte": "#FF3E00",
+  ".json": "#CBCB41",
+  ".yaml": "#F44336",
+  ".yml": "#F44336",
+  ".md": "#519ABA",
+  ".sql": "#E0B040",
+  ".sh": "#89E051",
+  ".bash": "#89E051",
+  ".zsh": "#89E051",
+  ".lua": "#51A0CF",
+  ".zig": "#F69A1B"
+};
+function getExtColor(ext) {
+  return EXT_COLORS[ext] ?? "#7C8DA6";
+}
+__name(getExtColor, "getExtColor");
+function buildFileTree(repoPath, include) {
+  const items = [];
+  const entries = readSortedEntries(repoPath);
+  const hasInclude = include && include.length > 0;
+  const isIncluded = hasInclude ? picomatch2(include, { dot: true }) : null;
+  const includeBases = hasInclude ? include.map((p) => picomatch2.scan(p).base).filter((b) => b && b !== ".") : null;
+  function shouldCheck(relPath, isDir) {
+    if (!hasInclude) return true;
+    if (!isDir) return isIncluded(relPath);
+    if (includeBases) {
+      return includeBases.some(
+        (base) => relPath.startsWith(base) || base.startsWith(relPath)
+      );
+    }
+    return true;
+  }
+  __name(shouldCheck, "shouldCheck");
+  for (const entry of entries) {
+    if (entry.isDir) {
+      const dirPath = path3.join(repoPath, entry.name);
+      const stats = scanDirStats(dirPath);
+      if (stats.total === 0) continue;
+      const dirChecked = shouldCheck(entry.name, true);
+      items.push({
+        path: entry.name,
+        name: entry.name,
+        depth: 0,
+        isDir: true,
+        ext: "",
+        checked: dirChecked,
+        expanded: true,
+        hasChildren: true,
+        fileCount: stats.total
+      });
+      const children = readSortedEntries(dirPath);
+      for (const child of children) {
+        const childRel = `${entry.name}/${child.name}`;
+        if (child.isDir) {
+          const childAbs = path3.join(dirPath, child.name);
+          const cs = scanDirStats(childAbs);
+          if (cs.total === 0) continue;
+          items.push({
+            path: childRel,
+            name: child.name,
+            depth: 1,
+            isDir: true,
+            ext: "",
+            checked: shouldCheck(childRel, true),
+            expanded: false,
+            hasChildren: cs.hasSubdirs || cs.total > 0,
+            fileCount: cs.total
+          });
+        } else {
+          const ext = path3.extname(child.name).toLowerCase();
+          if (!SUPPORTED_EXTENSIONS[ext]) continue;
+          items.push({
+            path: childRel,
+            name: child.name,
+            depth: 1,
+            isDir: false,
+            ext,
+            checked: shouldCheck(childRel, false),
+            expanded: false,
+            hasChildren: false,
+            fileCount: 0
+          });
+        }
+      }
+    } else {
+      const ext = path3.extname(entry.name).toLowerCase();
+      if (!SUPPORTED_EXTENSIONS[ext]) continue;
+      items.push({
+        path: entry.name,
+        name: entry.name,
+        depth: 0,
+        isDir: false,
+        ext,
+        checked: shouldCheck(entry.name, false),
+        expanded: false,
+        hasChildren: false,
+        fileCount: 0
+      });
+    }
+  }
+  return items;
+}
+__name(buildFileTree, "buildFileTree");
+function expandDir(items, index, repoPath) {
+  const node = items[index];
+  if (!node || !node.isDir || node.expanded) return items;
+  const absDir = path3.join(repoPath, node.path);
+  const entries = readSortedEntries(absDir);
+  const children = [];
+  for (const entry of entries) {
+    const childRel = `${node.path}/${entry.name}`;
+    if (entry.isDir) {
+      const childAbs = path3.join(absDir, entry.name);
+      const stats = scanDirStats(childAbs);
+      if (stats.total === 0) continue;
+      children.push({
+        path: childRel,
+        name: entry.name,
+        depth: node.depth + 1,
+        isDir: true,
+        ext: "",
+        checked: node.checked,
+        expanded: false,
+        hasChildren: stats.hasSubdirs || stats.total > 0,
+        fileCount: stats.total
+      });
+    } else {
+      const ext = path3.extname(entry.name).toLowerCase();
+      if (!SUPPORTED_EXTENSIONS[ext]) continue;
+      children.push({
+        path: childRel,
+        name: entry.name,
+        depth: node.depth + 1,
+        isDir: false,
+        ext,
+        checked: node.checked,
+        expanded: false,
+        hasChildren: false,
+        fileCount: 0
+      });
+    }
+  }
+  const next = [...items];
+  next[index] = { ...node, expanded: true };
+  next.splice(index + 1, 0, ...children);
+  return next;
+}
+__name(expandDir, "expandDir");
+function collapseDir(items, index) {
+  const node = items[index];
+  if (!node || !node.isDir || !node.expanded) return items;
+  let removeCount = 0;
+  for (let i = index + 1; i < items.length; i++) {
+    if (items[i].depth <= node.depth) break;
+    removeCount++;
+  }
+  const next = [...items];
+  next[index] = { ...node, expanded: false };
+  next.splice(index + 1, removeCount);
+  return next;
+}
+__name(collapseDir, "collapseDir");
+function toggleDir(items, index) {
+  const node = items[index];
+  if (!node || !node.isDir) return items;
+  const newChecked = !node.checked;
+  const next = [...items];
+  next[index] = { ...node, checked: newChecked };
+  for (let i = index + 1; i < next.length; i++) {
+    if (next[i].depth <= node.depth) break;
+    next[i] = { ...next[i], checked: newChecked };
+  }
+  return next;
+}
+__name(toggleDir, "toggleDir");
+function toggleFile(items, index) {
+  const node = items[index];
+  if (!node || node.isDir) return items;
+  const next = [...items];
+  next[index] = { ...node, checked: !node.checked };
+  return next;
+}
+__name(toggleFile, "toggleFile");
+function setAllDirs(items, checked) {
+  return items.map((item) => item.isDir ? { ...item, checked } : { ...item, checked });
+}
+__name(setAllDirs, "setAllDirs");
+function generatePatternsFromTree(items, originalInclude) {
+  const include = [];
+  const ignore = [];
+  const allDirs = items.filter((i) => i.isDir);
+  const topDirs = allDirs.filter((i) => i.depth === 0);
+  if (topDirs.every((d) => d.checked)) {
+    const uncheckedSubs = allDirs.filter((d) => !d.checked && d.depth > 0);
+    if (uncheckedSubs.length === 0) return { include: [], ignore: [] };
+    for (const item of uncheckedSubs) {
+      ignore.push(`${item.path}/**`);
+    }
+    return { include, ignore };
+  }
+  if (allDirs.every((d) => !d.checked)) {
+    return { include: [], ignore: [] };
+  }
+  const originalByDir = /* @__PURE__ */ new Map();
+  if (originalInclude && originalInclude.length > 0) {
+    for (const pattern of originalInclude) {
+      const base = pattern.replace(/\/\*\*$/, "").replace(/\/\*$/, "");
+      const parts = base.split("/");
+      for (let i = 1; i <= parts.length; i++) {
+        const dirPath = parts.slice(0, i).join("/");
+        const existing = originalByDir.get(dirPath) ?? [];
+        existing.push(pattern);
+        originalByDir.set(dirPath, existing);
+      }
+    }
+  }
+  function getVisibleChildren(parentIdx) {
+    const parent = items[parentIdx];
+    const children = [];
+    for (let i = parentIdx + 1; i < items.length; i++) {
+      if (items[i].depth <= parent.depth) break;
+      if (items[i].depth === parent.depth + 1) children.push(items[i]);
+    }
+    return children;
+  }
+  __name(getVisibleChildren, "getVisibleChildren");
+  function isFullInclusion(idx) {
+    const children = getVisibleChildren(idx);
+    if (children.length === 0) return true;
+    return children.filter((c2) => c2.isDir).every((c2) => c2.checked);
+  }
+  __name(isFullInclusion, "isFullInclusion");
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (!item.isDir || !item.checked) continue;
+    let coveredByParent = false;
+    for (let j = i - 1; j >= 0; j--) {
+      const ancestor = items[j];
+      if (ancestor.isDir && ancestor.depth < item.depth && item.path.startsWith(ancestor.path + "/") && ancestor.checked) {
+        if (isFullInclusion(j)) {
+          coveredByParent = true;
+        }
+        break;
+      }
+    }
+    if (coveredByParent) continue;
+    const origPatterns = originalByDir.get(item.path);
+    if (origPatterns && origPatterns.length > 0) {
+      for (const p of origPatterns) {
+        if (!include.includes(p)) {
+          include.push(p);
+        }
+      }
+    } else {
+      include.push(`${item.path}/**`);
+    }
+  }
+  const includedPrefixes = new Set(include);
+  for (const item of items) {
+    if (item.isDir || !item.checked) continue;
+    const covered = [...includedPrefixes].some((p) => {
+      const base = p.replace(/\/\*\*$/, "").replace(/\/\*$/, "");
+      return item.path.startsWith(base + "/") || item.path === base;
+    });
+    if (!covered) {
+      include.push(item.path);
+    }
+  }
+  for (const item of items) {
+    if (item.isDir || item.checked) continue;
+    const parentPath = item.path.split("/").slice(0, -1).join("/");
+    const parentIncluded = includedPrefixes.has(`${parentPath}/**`);
+    if (parentIncluded) {
+      ignore.push(item.path);
+    }
+  }
+  return { include, ignore };
+}
+__name(generatePatternsFromTree, "generatePatternsFromTree");
+function countTotalFiles(items) {
+  return items.filter((i) => i.depth === 0 && i.isDir).reduce((s, i) => s + i.fileCount, 0) + items.filter((i) => i.depth === 0 && !i.isDir).length;
+}
+__name(countTotalFiles, "countTotalFiles");
+function scanDirStats(dirPath) {
+  const byLang = /* @__PURE__ */ new Map();
+  let total = 0;
+  let hasSubdirs = false;
+  function walk(dir) {
+    for (const entry of readDirSafe(dir)) {
+      if (isDirEntry(dir, entry)) {
+        if (isIgnoredDir(entry.name) || entry.name.startsWith(".")) continue;
+        hasSubdirs = true;
+        walk(path3.join(dir, entry.name));
+      } else if (entry.isFile()) {
+        const ext = path3.extname(entry.name).toLowerCase();
+        const lang = SUPPORTED_EXTENSIONS[ext];
+        if (lang) {
+          byLang.set(lang, (byLang.get(lang) ?? 0) + 1);
+          total++;
+        }
+      }
+    }
+  }
+  __name(walk, "walk");
+  walk(dirPath);
+  return { total, byLang, hasSubdirs };
+}
+__name(scanDirStats, "scanDirStats");
+function readSortedEntries(dir) {
+  const raw = readDirSafe(dir);
+  const entries = [];
+  for (const e of raw) {
+    if (e.name.startsWith(".")) continue;
+    if (isDirEntry(dir, e)) {
+      if (isIgnoredDir(e.name)) continue;
+      entries.push({ name: e.name, isDir: true });
+    } else if (e.isFile()) {
+      entries.push({ name: e.name, isDir: false });
+    }
+  }
+  return entries.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+__name(readSortedEntries, "readSortedEntries");
+function readDirSafe(dir) {
+  try {
+    return fs3.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+__name(readDirSafe, "readDirSafe");
+function isDirEntry(parentDir, entry) {
+  if (entry.isDirectory()) return true;
+  if (entry.isSymbolicLink()) {
+    try {
+      return fs3.statSync(path3.join(parentDir, entry.name)).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+__name(isDirEntry, "isDirEntry");
+function scanDocsPreview(repoPath) {
+  const mdFiles = [];
+  function walk(dir, rel) {
+    for (const entry of readDirSafe(dir)) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = path3.join(dir, entry.name);
+      const relPath = rel ? `${rel}/${entry.name}` : entry.name;
+      if (isDirEntry(dir, entry)) {
+        if (isIgnoredDir(entry.name)) continue;
+        walk(fullPath, relPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        mdFiles.push(relPath);
+      }
+    }
+  }
+  __name(walk, "walk");
+  walk(repoPath, "");
+  mdFiles.sort();
+  if (mdFiles.length === 0) {
+    return [{ text: "  No markdown files found", dim: true }];
+  }
+  const lines = [
+    { text: `\u{1F4C4} ${mdFiles.length} markdown files`, bold: true },
+    { text: "" }
+  ];
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of mdFiles) {
+    const parts = f.split("/");
+    const group = parts.length > 1 ? parts[0] : "(root)";
+    const list = groups.get(group) || [];
+    list.push(f);
+    groups.set(group, list);
+  }
+  for (const [group, files] of groups) {
+    if (group !== "(root)") {
+      lines.push({ text: `  ${group}/`, bold: true, color: "#E0AF68" });
+    }
+    for (const f of files) {
+      const name = group === "(root)" ? f : f.slice(group.length + 1);
+      lines.push({ text: `    MD  ${name}`, color: "#519ABA" });
+    }
+    lines.push({ text: "" });
+  }
+  return lines;
+}
+__name(scanDocsPreview, "scanDocsPreview");
+function scanGitPreview(repoPath) {
+  const gitDir = path3.join(repoPath, ".git");
+  if (!fs3.existsSync(gitDir)) {
+    return [{ text: "  No .git directory found", dim: true }];
+  }
+  try {
+    const raw = execSync2(
+      'git log --oneline --format="%h %ar %s" -n 20',
+      { cwd: repoPath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    const commits = raw.split("\n").filter(Boolean);
+    if (commits.length === 0) {
+      return [{ text: "  No commits found", dim: true }];
+    }
+    let totalStr = "";
+    try {
+      totalStr = execSync2(
+        "git rev-list --count HEAD",
+        { cwd: repoPath, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+      ).trim();
+    } catch {
+    }
+    const lines = [
+      { text: `\u{1F4DC} ${totalStr || "?"} commits`, bold: true },
+      { text: "" }
+    ];
+    for (const line of commits) {
+      const spaceIdx = line.indexOf(" ");
+      const hash = line.slice(0, spaceIdx);
+      const rest = line.slice(spaceIdx + 1);
+      const timeMatch = rest.match(/^(.+? ago) (.+)$/);
+      if (timeMatch) {
+        lines.push({
+          text: `  ${hash}  ${timeMatch[2]}`,
+          color: "#C0CAF5"
+        });
+      } else {
+        lines.push({ text: `  ${hash}  ${rest}`, dim: true });
+      }
+    }
+    return lines;
+  } catch {
+    return [{ text: "  Failed to read git log", dim: true }];
+  }
+}
+__name(scanGitPreview, "scanGitPreview");
+
+// src/cli/tui/index-tui.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var MAX_W = 90;
+var MAX_H = 36;
+var C = {
+  aurora: "#7AA2F7",
+  success: "#9ECE6A",
+  error: "#F7768E",
+  warning: "#E0AF68",
+  dim: "#565F89",
+  text: "#C0CAF5",
+  border: "#3B4261",
+  cyan: "#7DCFFF",
+  dir: "#E0AF68"
+};
+var EMBEDDINGS = [
+  { value: "perplexity-context", label: "perplexity-context", desc: "best accuracy", badge: "\u2605" },
+  { value: "perplexity", label: "perplexity", desc: "fast, high quality" },
+  { value: "openai", label: "openai", desc: "text-embedding-3-small" },
+  { value: "local", label: "local", desc: "offline, no API key" }
+];
+var PRUNERS = [
+  { value: "haiku", label: "haiku", desc: "AI-powered noise filter", badge: "\u2605" },
+  { value: "none", label: "none", desc: "no pruning" }
+];
+var EXPANDERS = [
+  { value: "haiku", label: "haiku", desc: "discovers related context", badge: "\u2605" },
+  { value: "none", label: "none", desc: "no expansion" }
+];
+function centerScroll(cursor, total, viewH) {
+  if (total <= viewH) return 0;
+  const half = Math.floor(viewH / 2);
+  const offset = Math.max(0, cursor - half);
+  return Math.min(offset, total - viewH);
+}
+__name(centerScroll, "centerScroll");
+function TreeItemRow({ item, isCursor }) {
+  const indent = "  ".repeat(item.depth);
+  const excluded = !item.checked;
+  const ptr = isCursor ? "\u25B8 " : "  ";
+  if (item.isDir) {
+    const arrow = item.expanded ? "\u25BE" : "\u25B8";
+    const check2 = item.checked ? "\u2713" : "\u2717";
+    const checkColor2 = item.checked ? C.success : C.error;
+    const nameColor = excluded ? C.dim : isCursor ? C.aurora : C.dir;
+    const count = String(item.fileCount);
+    return /* @__PURE__ */ jsxs(Box, { height: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs(Text, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsx(Text, { color: isCursor ? C.aurora : C.dim, children: ptr }),
+        /* @__PURE__ */ jsx(Text, { children: indent }),
+        /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+          arrow,
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: checkColor2, bold: true, children: [
+          check2,
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { color: nameColor, bold: isCursor, children: [
+          item.name,
+          "/"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: C.dim, children: count })
+    ] });
+  }
+  const check = item.checked ? "\u2713" : "\u2717";
+  const checkColor = item.checked ? C.success : C.error;
+  return /* @__PURE__ */ jsx(Box, { height: 1, children: /* @__PURE__ */ jsxs(Text, { wrap: "truncate", children: [
+    /* @__PURE__ */ jsx(Text, { color: isCursor ? C.aurora : C.dim, children: ptr }),
+    /* @__PURE__ */ jsx(Text, { children: indent }),
+    /* @__PURE__ */ jsxs(Text, { color: checkColor, children: [
+      check,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: excluded ? C.dim : getExtColor(item.ext), children: item.name })
+  ] }) });
+}
+__name(TreeItemRow, "TreeItemRow");
+function MainScreen({ scan, width, height, onConfirm, externalPreviews }) {
+  const { exit } = useApp();
+  const allMods = scan.modules;
+  const [pane, setPane] = useState("modules");
+  const [checked, setChecked] = useState(() => {
+    const configPlugins = scan.config.plugins;
+    if (configPlugins && configPlugins.length > 0) {
+      return new Set(configPlugins.filter((p) => allMods.some((m) => m.name === p)));
+    }
+    return new Set(allMods.filter((m) => m.available && m.checked).map((m) => m.name));
+  });
+  const firstAvail = allMods.findIndex((m) => m.available);
+  const [modCursor, setModCursor] = useState(Math.max(0, firstAvail));
+  const [treeItems, setTreeItems] = useState(() => buildFileTree(scan.repoPath, scan.config.include));
+  const [treeCursor, setTreeCursor] = useState(0);
+  const [filterText, setFilterText] = useState("");
+  const [isFiltering, setIsFiltering] = useState(false);
+  const isFilteringRef = useRef(false);
+  const startFiltering = useCallback(() => {
+    isFilteringRef.current = true;
+    setIsFiltering(true);
+    setFilterText("");
+    setTreeCursor(0);
+  }, []);
+  const stopFiltering = useCallback(() => {
+    isFilteringRef.current = false;
+    setIsFiltering(false);
+    setFilterText("");
+    setTreeCursor(0);
+  }, []);
+  const docsPreview = useMemo(() => scanDocsPreview(scan.repoPath), [scan.repoPath]);
+  const gitPreview = useMemo(() => scanGitPreview(scan.repoPath), [scan.repoPath]);
+  const allPreviews = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    map.set("docs", docsPreview);
+    map.set("git", gitPreview);
+    if (externalPreviews) {
+      for (const [name, lines] of externalPreviews) {
+        map.set(name, lines);
+      }
+    }
+    return map;
+  }, [docsPreview, gitPreview, externalPreviews]);
+  const focusedModName = allMods[modCursor]?.name ?? "code";
+  const panelH = Math.max(6, height - 7);
+  const treeViewH = Math.max(3, panelH - 4);
+  const modUp = /* @__PURE__ */ __name(() => setModCursor((p) => {
+    for (let i = p - 1; i >= 0; i--) if (allMods[i].available) return i;
+    return p;
+  }), "modUp");
+  const modDown = /* @__PURE__ */ __name(() => setModCursor((p) => {
+    for (let i = p + 1; i < allMods.length; i++) if (allMods[i].available) return i;
+    return p;
+  }), "modDown");
+  useInput((input, key) => {
+    const filtering = isFilteringRef.current;
+    if (key.escape) {
+      if (filtering || filterText) {
+        stopFiltering();
+        return;
+      }
+      exit();
+      return;
+    }
+    if (input === "q" && !filtering) {
+      exit();
+      return;
+    }
+    if (key.tab && !filtering) {
+      setPane((p) => p === "modules" ? "tree" : "modules");
+      return;
+    }
+    if (key.return) {
+      if (filtering) {
+        isFilteringRef.current = false;
+        setIsFiltering(false);
+        return;
+      }
+      const selected = [...checked];
+      if (selected.length === 0) return;
+      const patterns = generatePatternsFromTree(treeItems, scan.config.include);
+      onConfirm(selected, patterns.include, patterns.ignore);
+      return;
+    }
+    if (pane === "modules") {
+      if (key.upArrow || input === "k") {
+        modUp();
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        modDown();
+        return;
+      }
+      if (input === " ") {
+        const mod = allMods[modCursor];
+        if (!mod?.available) return;
+        setChecked((prev) => {
+          const next = new Set(prev);
+          if (next.has(mod.name)) next.delete(mod.name);
+          else next.add(mod.name);
+          return next;
+        });
+        return;
+      }
+    }
+    if (pane === "tree") {
+      if (filtering) {
+        if (key.backspace || key.delete) {
+          setFilterText((prev) => prev.slice(0, -1));
+          setTreeCursor(0);
+          return;
+        }
+        if (input && !key.upArrow && !key.downArrow && !key.leftArrow && !key.rightArrow) {
+          setFilterText((prev) => prev + input);
+          setTreeCursor(0);
+          return;
+        }
+      }
+      if (input === "/" && !filtering) {
+        startFiltering();
+        return;
+      }
+      if (key.upArrow || !filtering && input === "k") {
+        setTreeCursor((p) => Math.max(0, p - 1));
+        return;
+      }
+      if (key.downArrow || !filtering && input === "j") {
+        setTreeCursor((p) => Math.min(filteredItems.length - 1, p + 1));
+        return;
+      }
+      if (key.rightArrow || !filtering && input === "l") {
+        const item = filteredItems[treeCursor];
+        if (item?.isDir && !item.expanded) {
+          setTreeItems((prev) => expandDir(prev, prev.indexOf(item), scan.repoPath));
+        }
+        return;
+      }
+      if (key.leftArrow || !filtering && input === "h") {
+        const item = filteredItems[treeCursor];
+        if (item?.isDir && item.expanded) {
+          setTreeItems((prev) => collapseDir(prev, prev.indexOf(item)));
+        }
+        return;
+      }
+      if (input === " ") {
+        const item = filteredItems[treeCursor];
+        if (!item) return;
+        const realIdx = treeItems.indexOf(item);
+        if (realIdx < 0) return;
+        if (item.isDir) setTreeItems((prev) => toggleDir(prev, realIdx));
+        else setTreeItems((prev) => toggleFile(prev, realIdx));
+        return;
+      }
+      if (!filtering && input === "a") {
+        setTreeItems((prev) => setAllDirs(prev, true));
+        return;
+      }
+      if (!filtering && input === "n") {
+        setTreeItems((prev) => setAllDirs(prev, false));
+        return;
+      }
+      if (!filtering && input === "i") {
+        setTreeItems((prev) => prev.map((it) => ({ ...it, checked: !it.checked })));
+        return;
+      }
+    }
+  });
+  const filteredItems = useMemo(() => {
+    if (!filterText) return treeItems;
+    const lower = filterText.toLowerCase();
+    const matchedPaths = /* @__PURE__ */ new Set();
+    for (const item of treeItems) {
+      if (item.name.toLowerCase().includes(lower)) {
+        matchedPaths.add(item.path);
+        const parts = item.path.split("/");
+        for (let i = 1; i < parts.length; i++) {
+          matchedPaths.add(parts.slice(0, i).join("/"));
+        }
+      }
+    }
+    return treeItems.filter((item) => matchedPaths.has(item.path));
+  }, [treeItems, filterText]);
+  const totalFiles = countTotalFiles(treeItems);
+  const selectedDirs = treeItems.filter((i) => i.depth === 0 && i.isDir && i.checked).length;
+  const totalDirs = treeItems.filter((i) => i.depth === 0 && i.isDir).length;
+  const visible = filteredItems.slice(
+    centerScroll(treeCursor, filteredItems.length, treeViewH),
+    centerScroll(treeCursor, filteredItems.length, treeViewH) + treeViewH
+  );
+  const scrollOffset = centerScroll(treeCursor, filteredItems.length, treeViewH);
+  const dbInfo = scan.db?.exists ? `${scan.db.sizeMB} MB` : "new";
+  const sidebarW = 30;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsxs(Box, { paddingX: 2, gap: 2, marginTop: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: C.aurora, bold: true, children: "BrainBank" }),
+      /* @__PURE__ */ jsx(Text, { color: C.dim, children: "\xB7" }),
+      /* @__PURE__ */ jsx(Text, { color: C.text, children: scan.repoPath }),
+      /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+        "\xB7 \u{1F4BE} ",
+        dbInfo
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 1, height: panelH, children: [
+      /* @__PURE__ */ jsxs(
+        Box,
+        {
+          flexDirection: "column",
+          width: sidebarW,
+          borderStyle: "round",
+          borderColor: pane === "modules" ? C.aurora : C.border,
+          children: [
+            /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: pane === "modules" ? C.aurora : C.dim, bold: true, children: "Modules" }) }),
+            /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: allMods.map((m, i) => {
+              const avail = m.available;
+              const isCur = i === modCursor;
+              const isChk = checked.has(m.name);
+              const box = !avail ? "\u2500" : isChk ? "\u2713" : " ";
+              const boxCol = !avail ? C.dim : isChk ? C.success : C.dim;
+              const curCol = isCur ? pane === "modules" ? C.aurora : C.dim : "transparent";
+              return /* @__PURE__ */ jsxs(Box, { height: 1, children: [
+                /* @__PURE__ */ jsxs(Text, { color: curCol, children: [
+                  isCur ? "\u25B8" : " ",
+                  " "
+                ] }),
+                /* @__PURE__ */ jsxs(Text, { color: boxCol, children: [
+                  "[",
+                  box,
+                  "] "
+                ] }),
+                /* @__PURE__ */ jsx(Text, { color: avail ? C.text : C.dim, children: m.name.charAt(0).toUpperCase() + m.name.slice(1) })
+              ] }, m.name);
+            }) }),
+            /* @__PURE__ */ jsx(Box, { flexGrow: 1 }),
+            /* @__PURE__ */ jsx(Box, { paddingX: 1, paddingBottom: 1, flexDirection: "column", children: allMods.filter((m) => m.available && checked.has(m.name)).map((m) => /* @__PURE__ */ jsx(Box, { height: 1, children: /* @__PURE__ */ jsx(Text, { color: C.dim, wrap: "truncate", children: m.summary }) }, `s${m.name}`)) })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        Box,
+        {
+          flexDirection: "column",
+          flexGrow: 1,
+          borderStyle: "round",
+          borderColor: pane === "tree" ? C.aurora : C.border,
+          marginBottom: 1,
+          children: [
+            /* @__PURE__ */ jsxs(Box, { paddingX: 1, justifyContent: "space-between", marginBottom: 1, children: [
+              /* @__PURE__ */ jsxs(Text, { children: [
+                /* @__PURE__ */ jsx(Text, { color: pane === "tree" ? C.aurora : C.dim, bold: true, children: "Explorer" }),
+                /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+                /* @__PURE__ */ jsx(Text, { color: C.text, children: focusedModName.charAt(0).toUpperCase() + focusedModName.slice(1) })
+              ] }),
+              focusedModName === "code" && /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+                selectedDirs,
+                "/",
+                totalDirs,
+                " dirs \xB7 ",
+                totalFiles,
+                " files"
+              ] })
+            ] }),
+            focusedModName === "code" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, height: treeViewH, overflow: "hidden", children: [
+              (isFiltering || filterText) && /* @__PURE__ */ jsxs(Box, { height: 1, marginBottom: 0, children: [
+                /* @__PURE__ */ jsx(Text, { color: C.aurora, bold: true, children: "/ " }),
+                /* @__PURE__ */ jsx(Text, { color: C.text, children: filterText }),
+                /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "\u258E" }),
+                filterText && /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+                  " (",
+                  filteredItems.length,
+                  " matches)"
+                ] })
+              ] }),
+              visible.map((item, i) => {
+                const globalIdx = centerScroll(treeCursor, filteredItems.length, treeViewH) + i;
+                return /* @__PURE__ */ jsx(
+                  TreeItemRow,
+                  {
+                    item,
+                    isCursor: pane === "tree" && globalIdx === treeCursor
+                  },
+                  item.path
+                );
+              }),
+              visible.length < treeViewH && Array.from(
+                { length: treeViewH - visible.length - (isFiltering || filterText ? 1 : 0) },
+                (_, i) => /* @__PURE__ */ jsx(Box, { height: 1, children: /* @__PURE__ */ jsx(Text, { children: " " }) }, `e${i}`)
+              )
+            ] }),
+            focusedModName !== "code" && allPreviews.has(focusedModName) && /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingLeft: 1, height: treeViewH, overflow: "hidden", children: allPreviews.get(focusedModName).slice(0, treeViewH).map((line, i) => /* @__PURE__ */ jsx(
+              Text,
+              {
+                color: line.dim ? C.dim : line.color ?? C.text,
+                bold: line.bold,
+                wrap: "truncate",
+                children: line.text
+              },
+              `p${i}`
+            )) }),
+            focusedModName !== "code" && !allPreviews.has(focusedModName) && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, height: treeViewH, justifyContent: "center", alignItems: "center", children: [
+              /* @__PURE__ */ jsx(Text, { color: C.dim, children: "No preview available" }),
+              /* @__PURE__ */ jsx(Text, { color: C.dim, children: "This plugin will be indexed with default settings" })
+            ] }),
+            focusedModName === "code" && filteredItems.length > treeViewH && /* @__PURE__ */ jsx(Box, { paddingX: 2, justifyContent: "flex-end", children: /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+              scrollOffset + 1,
+              "\u2013",
+              Math.min(scrollOffset + treeViewH, filteredItems.length),
+              "/",
+              filteredItems.length
+            ] }) })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { paddingX: 2, justifyContent: "space-between", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "Tab" }),
+        " pane",
+        /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "\u2191\u2193" }),
+        " move",
+        /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "Space" }),
+        " toggle",
+        /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "\u2192\u2190" }),
+        " expand",
+        /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "a" }),
+        " all",
+        /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "n" }),
+        " none",
+        /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "i" }),
+        " invert",
+        /* @__PURE__ */ jsx(Text, { color: C.dim, children: " \xB7 " }),
+        /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "/" }),
+        " filter"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: C.aurora, bold: true, children: [
+        "Enter: ",
+        scan.config.exists ? "Index \u26A1" : "Next \u2192"
+      ] })
+    ] })
+  ] });
+}
+__name(MainScreen, "MainScreen");
+function ConfigPanel({ onDone }) {
+  const { exit } = useApp();
+  const SECTIONS = ["embedding", "pruner", "expander"];
+  const [section, setSection] = useState("embedding");
+  const [embIdx, setEmbIdx] = useState(0);
+  const [prunerIdx, setPrunerIdx] = useState(0);
+  const [expanderIdx, setExpanderIdx] = useState(0);
+  useInput((input, key) => {
+    if (key.escape || input === "q") {
+      exit();
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      if (section === "embedding") setEmbIdx((p) => Math.max(0, p - 1));
+      else if (section === "pruner") setPrunerIdx((p) => Math.max(0, p - 1));
+      else setExpanderIdx((p) => Math.max(0, p - 1));
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      if (section === "embedding") setEmbIdx((p) => Math.min(EMBEDDINGS.length - 1, p + 1));
+      else if (section === "pruner") setPrunerIdx((p) => Math.min(PRUNERS.length - 1, p + 1));
+      else setExpanderIdx((p) => Math.min(EXPANDERS.length - 1, p + 1));
+      return;
+    }
+    if (key.tab) {
+      setSection((p) => {
+        const idx = SECTIONS.indexOf(p);
+        return SECTIONS[(idx + 1) % SECTIONS.length];
+      });
+      return;
+    }
+    if (key.return) {
+      onDone(EMBEDDINGS[embIdx].value, PRUNERS[prunerIdx].value, EXPANDERS[expanderIdx].value);
+      return;
+    }
+  });
+  const renderOpt = /* @__PURE__ */ __name((item, i, cur, sel) => /* @__PURE__ */ jsxs(Box, { height: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: cur ? C.aurora : C.dim, children: [
+      cur ? "\u25B8" : " ",
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: sel ? C.success : C.dim, children: [
+      sel ? "\u25CF" : "\u25CB",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: cur ? C.text : C.dim, bold: cur, children: item.label.padEnd(22) }),
+    /* @__PURE__ */ jsx(Text, { color: C.dim, children: item.desc }),
+    item.badge ? /* @__PURE__ */ jsxs(Text, { color: C.warning, children: [
+      " ",
+      item.badge
+    ] }) : null
+  ] }, item.value), "renderOpt");
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Box, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: C.cyan, bold: true, children: "\u2699 First-Time Setup" }) }),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: section === "embedding" ? C.aurora : C.border,
+        paddingX: 2,
+        paddingY: 1,
+        children: [
+          /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: section === "embedding" ? C.aurora : C.dim, bold: true, children: "Embedding Provider" }) }),
+          EMBEDDINGS.map((it, i) => renderOpt(it, i, section === "embedding" && i === embIdx, i === embIdx))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: section === "pruner" ? C.aurora : C.border,
+        paddingX: 2,
+        paddingY: 1,
+        children: [
+          /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: section === "pruner" ? C.aurora : C.dim, bold: true, children: "Noise Pruner" }) }),
+          PRUNERS.map((it, i) => renderOpt(it, i, section === "pruner" && i === prunerIdx, i === prunerIdx))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: section === "expander" ? C.aurora : C.border,
+        paddingX: 2,
+        paddingY: 1,
+        children: [
+          /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: section === "expander" ? C.aurora : C.dim, bold: true, children: "Context Expander" }) }),
+          EXPANDERS.map((it, i) => renderOpt(it, i, section === "expander" && i === expanderIdx, i === expanderIdx))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(Box, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: C.dim, children: [
+      /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "\u2191\u2193" }),
+      " select \xB7 ",
+      /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "Tab" }),
+      " section \xB7 ",
+      /* @__PURE__ */ jsx(Text, { color: C.aurora, children: "Enter" }),
+      " start indexing"
+    ] }) })
+  ] });
+}
+__name(ConfigPanel, "ConfigPanel");
+function IndexApp({ scan, externalPreviews }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [rawW, setRawW] = useState(stdout?.columns || 100);
+  const [rawH, setRawH] = useState(stdout?.rows || 30);
+  const [phase, setPhase] = useState("main");
+  const [selectedModules, setSelectedModules] = useState([]);
+  const [patterns, setPatterns] = useState({ include: [], ignore: [] });
+  const width = Math.min(rawW, MAX_W);
+  const height = Math.min(rawH, MAX_H);
+  useEffect(() => {
+    if (!stdout) return;
+    const onResize = /* @__PURE__ */ __name(() => {
+      setRawW(stdout.columns);
+      setRawH(stdout.rows);
+    }, "onResize");
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  const handleMainConfirm = /* @__PURE__ */ __name((modules, include, ignore) => {
+    setSelectedModules(modules);
+    setPatterns({ include, ignore });
+    if (scan.config.exists) {
+      _lastSelection = { modules, include, ignore };
+      setTimeout(() => exit(), 50);
+    } else {
+      setPhase("config");
+    }
+  }, "handleMainConfirm");
+  const handleConfigDone = /* @__PURE__ */ __name((embedding, pruner, expander) => {
+    _lastSelection = { modules: selectedModules, ...patterns, config: { embedding, pruner, expander } };
+    setTimeout(() => exit(), 50);
+  }, "handleConfigDone");
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, height, children: [
+    phase === "main" && /* @__PURE__ */ jsx(
+      MainScreen,
+      {
+        scan,
+        width,
+        height,
+        onConfirm: handleMainConfirm,
+        externalPreviews
+      }
+    ),
+    phase === "config" && /* @__PURE__ */ jsx(ConfigPanel, { onDone: handleConfigDone })
+  ] });
+}
+__name(IndexApp, "IndexApp");
+var _lastSelection = null;
+async function runIndexTui(scan, externalPreviews) {
+  _lastSelection = null;
+  const instance = render(/* @__PURE__ */ jsx(IndexApp, { scan, externalPreviews }));
+  await instance.waitUntilExit();
+  return _lastSelection;
+}
+__name(runIndexTui, "runIndexTui");
+
+// src/cli/commands/index.ts
+async function cmdIndex() {
+  const positional = stripFlags(args);
+  const repoPath = positional[1] || ".";
+  const force = hasFlag("force");
+  const depth = parseInt(getFlag("depth") || "500", 10);
+  const onlyRaw = getFlag("only");
+  const docsPath = getFlag("docs");
+  const skipPrompt = hasFlag("yes") || hasFlag("y");
+  const forceSetup = hasFlag("setup");
+  const scan = scanRepo(repoPath);
+  const configPlugins = scan.config.plugins ?? [];
+  const externalDiscovery = await discoverExternalPlugins(repoPath, configPlugins);
+  let externalPreviews = externalDiscovery.previews;
+  if (externalDiscovery.modules.length > 0) {
+    scan.modules = [...scan.modules, ...externalDiscovery.modules];
+  }
+  let modules;
+  let tuiInclude = [];
+  let tuiIgnore = [];
+  let tuiConfig;
+  if (onlyRaw) {
+    printIndexHeader(scan, depth);
+    modules = onlyRaw.split(",").map((s) => s.trim());
+  } else if (scan.config.plugins && scan.config.plugins.length > 0 && !forceSetup) {
+    printIndexHeader(scan, depth);
+    modules = scan.config.plugins;
+  } else if (skipPrompt) {
+    printIndexHeader(scan, depth);
+    modules = buildDefaultModules(scan);
+  } else {
+    const selection = await runIndexTui(scan, externalPreviews);
+    if (!selection) {
+      console.log(c.dim("\n  Cancelled. Exiting.\n"));
+      return;
+    }
+    modules = selection.modules;
+    tuiInclude = selection.include;
+    tuiIgnore = selection.ignore;
+    tuiConfig = selection.config;
+    if (modules.length === 0) {
+      console.log(c.dim("\n  Nothing selected. Exiting.\n"));
+      return;
+    }
+    const oldPlugins = scan.config.plugins ?? [];
+    const removed = oldPlugins.filter((p) => !modules.includes(p));
+    if (removed.length > 0) {
+      console.log(c.bold("\n\u2501\u2501\u2501 Deindexing \u2501\u2501\u2501\n"));
+      for (const mod of removed) {
+        console.log(`  ${c.yellow("\u2717")} Removing ${mod} data...`);
+        deindexModule(scan.repoPath, mod);
+        console.log(`  ${c.green("\u2713")} ${mod} data cleared`);
+      }
+    }
+    console.log(c.bold("\n\u2501\u2501\u2501 BrainBank \u2501\u2501\u2501\n"));
+    console.log("  Selected modules:");
+    for (const m of modules) {
+      console.log(`    ${c.green("\u2713")} ${m}`);
+    }
+    if (tuiInclude.length > 0) {
+      console.log(`  Include: ${c.cyan(tuiInclude.join(", "))}`);
+    }
+    if (tuiIgnore.length > 0) {
+      console.log(`  Ignore: ${c.yellow(tuiIgnore.join(", "))}`);
+    }
+    console.log("");
+  }
+  if (docsPath && !modules.includes("docs")) {
+    modules.push("docs");
+  }
+  if (tuiConfig) {
+    saveConfigFromTui(scan.repoPath, modules, tuiConfig.embedding, tuiConfig.pruner, tuiConfig.expander, tuiInclude, tuiIgnore);
+  } else if (tuiInclude.length > 0 || tuiIgnore.length > 0) {
+    updateConfigPlugins(scan.repoPath, modules, tuiInclude, tuiIgnore);
+  }
+  console.log(c.bold(`
+\u2501\u2501\u2501 Indexing: ${modules.join(", ")} \u2501\u2501\u2501`));
+  const ctx = contextFromCLI(repoPath);
+  if (tuiInclude.length > 0 && !ctx.flags?.include) {
+    ctx.flags = { ...ctx.flags, include: tuiInclude.join(",") };
+  }
+  if (tuiIgnore.length > 0 && !ctx.flags?.ignore) {
+    ctx.flags = { ...ctx.flags, ignore: tuiIgnore.join(",") };
+  }
+  const brain = await createBrain(ctx);
+  await brain.initialize();
+  const config = await getConfig(repoPath);
+  await registerConfigCollections(brain, repoPath, config);
+  if (docsPath) {
+    const absDocsPath = path4.resolve(docsPath);
+    const collName = path4.basename(absDocsPath);
+    try {
+      const docsPlugin = findDocsPlugin(brain);
+      await docsPlugin?.addCollection({
+        name: collName,
+        path: absDocsPath,
+        pattern: "**/*.md",
+        ignore: ["deprecated/**", "node_modules/**"]
+      });
+      console.log(c.dim(`  Registered docs collection: ${collName}`));
+    } catch {
+      console.log(c.yellow(`  Warning: docs module not loaded, skipping --docs`));
+    }
+  }
+  const result = await brain.index({
+    modules,
+    forceReindex: force,
+    pluginOptions: { depth },
+    onProgress: /* @__PURE__ */ __name((stage, msg) => {
+      process.stdout.write(`\r  ${c.cyan(stage.toUpperCase())} ${msg}                    `);
+    }, "onProgress")
+  });
+  console.log("\n");
+  console.log(c.bold("\n\u2501\u2501\u2501 Changes \u2501\u2501\u2501\n"));
+  let hasChanges = false;
+  for (const [name, value] of Object.entries(result)) {
+    if (!value) continue;
+    const v = value;
+    if (typeof v.indexed !== "number") {
+      console.log(`  ${c.green("\u2713")} ${name}: done`);
+      continue;
+    }
+    const indexed = v.indexed;
+    const skipped = v.skipped ?? 0;
+    const removed = v.removed ?? 0;
+    const chunks = v.chunks ?? 0;
+    if (indexed > 0 || removed > 0) hasChanges = true;
+    const parts = [];
+    if (indexed > 0) parts.push(c.green(`+${indexed} files (${chunks} chunks)`));
+    if (removed > 0) parts.push(c.red(`\u2212${removed} files`));
+    if (skipped > 0) parts.push(c.dim(`${skipped} unchanged`));
+    console.log(`  ${c.bold(name)}: ${parts.join("  ")}`);
+  }
+  if (!hasChanges) {
+    console.log(c.dim("  No changes \u2014 everything up to date"));
+  }
+  const stats = brain.stats();
+  console.log(`
+  ${c.bold("Totals")}:`);
+  for (const [name, s] of Object.entries(stats)) {
+    if (!s || typeof s !== "object") continue;
+    const entries = Object.entries(s).map(([k, v]) => `${k}: ${v}`).join(", ");
+    console.log(`    ${name}: ${entries}`);
+  }
+  brain.close();
+  await autoExportMcp(repoPath);
+}
+__name(cmdIndex, "cmdIndex");
+function printIndexHeader(scan, _depth) {
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank \u2501\u2501\u2501"));
+  console.log(c.dim(`  ${scan.repoPath}
+`));
+  const plugins = scan.config.plugins ?? [];
+  console.log(`  Plugins: ${c.cyan(plugins.join(", "))}`);
+  if (scan.config.include?.length) {
+    console.log("");
+    for (const pattern of scan.config.include) {
+      const exists = validatePattern(scan.repoPath, pattern);
+      const icon = exists ? c.green("\u2713") : c.red("\u2717");
+      const label = exists ? c.dim(pattern) : c.red(pattern);
+      console.log(`  ${icon} ${label}`);
+    }
+  }
+  if (scan.config.ignore?.length) {
+    console.log("");
+    console.log(c.dim("  Ignore:"));
+    for (const pattern of scan.config.ignore) {
+      console.log(`    ${c.yellow("\u2500")} ${c.dim(pattern)}`);
+    }
+  }
+  if (scan.db?.exists) {
+    const ago = scan.db.lastModified ? timeSince(scan.db.lastModified) : "";
+    console.log(c.dim(`
+  DB: ${scan.db.sizeMB} MB${ago ? `, last indexed ${ago}` : ""}`));
+  }
+  console.log("");
+}
+__name(printIndexHeader, "printIndexHeader");
+function validatePattern(repoPath, pattern) {
+  const base = pattern.replace(/\/\*\*$/, "").replace(/\/\*$/, "");
+  const absPath = path4.join(repoPath, base);
+  try {
+    fs4.statSync(absPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(validatePattern, "validatePattern");
+function buildDefaultModules(scan) {
+  return scan.modules.filter((m) => m.available && m.checked).map((m) => m.name);
+}
+__name(buildDefaultModules, "buildDefaultModules");
+function timeSince(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+__name(timeSince, "timeSince");
+var DOC_FOLDERS = ["docs", "doc", "wiki", "documentation", "guides", "notes"];
+function autoDetectDocCollections(repoPath) {
+  const resolved = path4.resolve(repoPath);
+  const collections = [];
+  for (const folder of DOC_FOLDERS) {
+    const absPath = path4.join(resolved, folder);
+    try {
+      const stat = fs4.statSync(absPath);
+      if (stat.isDirectory()) {
+        const entries = fs4.readdirSync(absPath, { recursive: true });
+        const hasMd = entries.some((e) => typeof e === "string" && /\.md$/i.test(e));
+        if (hasMd) {
+          collections.push({
+            name: folder,
+            path: folder,
+            pattern: "**/*.md",
+            context: `${folder} directory`
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return collections;
+}
+__name(autoDetectDocCollections, "autoDetectDocCollections");
+function saveConfigFromTui(repoPath, modules, embedding, pruner, expander, include, ignore) {
+  const configDir = path4.join(repoPath, ".brainbank");
+  const configPath = path4.join(configDir, "config.json");
+  const config = {
+    plugins: modules,
+    embedding
+  };
+  if (pruner !== "none") {
+    config.pruner = pruner;
+  }
+  if (expander !== "none") {
+    config.expander = expander;
+  }
+  if (include.length > 0) {
+    config.include = include;
+  }
+  if (ignore.length > 0) {
+    config.ignore = ignore;
+  }
+  if (modules.includes("docs")) {
+    const collections = autoDetectDocCollections(repoPath);
+    if (collections.length > 0) {
+      config.docs = { collections };
+      console.log(c.dim(`  Auto-detected docs: ${collections.map((dc) => dc.name).join(", ")}`));
+    }
+  }
+  const detectedKeys = {};
+  const needsPerplexity = embedding.startsWith("perplexity");
+  const needsAnthropic = pruner === "haiku" || expander === "haiku";
+  const needsOpenai = embedding === "openai";
+  if (needsPerplexity && process.env.PERPLEXITY_API_KEY) {
+    detectedKeys.perplexity = process.env.PERPLEXITY_API_KEY;
+  }
+  if (needsAnthropic && process.env.ANTHROPIC_API_KEY) {
+    detectedKeys.anthropic = process.env.ANTHROPIC_API_KEY;
+  }
+  if (needsOpenai && process.env.OPENAI_API_KEY) {
+    detectedKeys.openai = process.env.OPENAI_API_KEY;
+  }
+  if (Object.keys(detectedKeys).length > 0) {
+    config.keys = detectedKeys;
+  }
+  fs4.mkdirSync(configDir, { recursive: true });
+  fs4.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  console.log(c.green(`  \u2713 Saved ${path4.relative(process.cwd(), configPath)}`));
+}
+__name(saveConfigFromTui, "saveConfigFromTui");
+function updateConfigPlugins(repoPath, modules, include, ignore) {
+  const configPath = path4.join(repoPath, ".brainbank", "config.json");
+  try {
+    const raw = fs4.readFileSync(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    config.plugins = modules;
+    if (include.length > 0) {
+      config.include = include;
+    } else {
+      delete config.include;
+    }
+    if (ignore.length > 0) {
+      config.ignore = ignore;
+    } else {
+      delete config.ignore;
+    }
+    if (modules.includes("docs")) {
+      const existing = config.docs;
+      const hasCollections = existing && Array.isArray(existing.collections) && existing.collections.length > 0;
+      if (!hasCollections) {
+        const collections = autoDetectDocCollections(repoPath);
+        if (collections.length > 0) {
+          config.docs = { ...existing ?? {}, collections };
+          console.log(c.dim(`  Auto-detected docs: ${collections.map((dc) => dc.name).join(", ")}`));
+        }
+      }
+    }
+    fs4.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    console.log(c.green(`  \u2713 Updated config.json`));
+  } catch {
+  }
+}
+__name(updateConfigPlugins, "updateConfigPlugins");
+function deindexModule(repoPath, moduleName) {
+  const dbPath = path4.join(repoPath, ".brainbank", "data", "brainbank.db");
+  if (!fs4.existsSync(dbPath)) return;
+  let db;
+  try {
+    const sqlite = __require("sqlite");
+    db = new sqlite.DatabaseSync(dbPath);
+  } catch {
+    console.log(c.yellow(`    Could not open DB \u2014 skip deindex for ${moduleName}`));
+    return;
+  }
+  if (!db) return;
+  const tables = {
+    code: [
+      "DELETE FROM code_call_edges",
+      "DELETE FROM code_refs",
+      "DELETE FROM code_symbols",
+      "DELETE FROM code_imports",
+      "DELETE FROM code_vectors",
+      "DELETE FROM code_chunks",
+      "DELETE FROM indexed_files",
+      "DELETE FROM plugin_tracking WHERE plugin = 'code'"
+    ],
+    docs: [
+      "DELETE FROM doc_vectors",
+      "DELETE FROM doc_chunks",
+      "DELETE FROM path_contexts",
+      "DELETE FROM collections",
+      "DELETE FROM plugin_tracking WHERE plugin = 'docs'"
+    ],
+    git: [
+      "DELETE FROM git_vectors",
+      "DELETE FROM git_commits",
+      "DELETE FROM plugin_tracking WHERE plugin = 'git'"
+    ]
+  };
+  const statements = tables[moduleName];
+  if (!statements) {
+    console.log(c.dim(`    No known tables for ${moduleName}`));
+    try {
+      db.close();
+    } catch {
+    }
+    return;
+  }
+  for (const sql of statements) {
+    try {
+      db.exec(sql);
+    } catch {
+    }
+  }
+  try {
+    db.close();
+  } catch {
+  }
+}
+__name(deindexModule, "deindexModule");
+
+// src/cli/commands/collection.ts
+async function cmdCollection() {
+  const pos = stripFlags(args);
+  const sub = pos[1];
+  if (sub === "add") {
+    const path6 = pos[2];
+    const name = getFlag("name");
+    const pattern = getFlag("pattern") ?? "**/*.md";
+    const context = getFlag("context");
+    const ignoreRaw = getFlag("ignore");
+    if (!path6 || !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();
+    const docsPlugin = findDocsPlugin(brain);
+    if (!docsPlugin) {
+      console.log(c.red("Docs plugin not loaded. Install @brainbank/docs."));
+      process.exit(1);
+    }
+    await docsPlugin.addCollection({
+      name,
+      path: path6,
+      pattern,
+      ignore: ignoreRaw ? ignoreRaw.split(",") : [],
+      context: context ?? void 0
+    });
+    console.log(c.green(`\u2713 Collection '${name}' added: ${path6} (${pattern})`));
+    if (context) console.log(c.dim(`  Context: ${context}`));
+    brain.close();
+    return;
+  }
+  if (sub === "list") {
+    const brain = await createBrain();
+    await brain.initialize();
+    const docsPlugin = findDocsPlugin(brain);
+    if (!docsPlugin) {
+      console.log(c.yellow("  Docs plugin not loaded."));
+      brain.close();
+      return;
+    }
+    const collections = docsPlugin.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 = pos[2];
+    if (!name) {
+      console.log(c.red("Usage: brainbank collection remove <name>"));
+      process.exit(1);
+    }
+    const brain = await createBrain();
+    const docsPlugin = findDocsPlugin(brain);
+    if (!docsPlugin) {
+      console.log(c.red("Docs plugin not loaded."));
+      process.exit(1);
+    }
+    await docsPlugin.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");
+
+// src/cli/commands/kv.ts
+async function cmdKv() {
+  const pos = stripFlags(args);
+  const sub = pos[1];
+  if (sub === "add") {
+    const collName = pos[2];
+    const content = pos.slice(3).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 = pos[2];
+    const query = pos.slice(3).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 = pos[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 = pos[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 = pos[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");
+
+// src/cli/commands/docs.ts
+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 docsPlugin = findDocsPlugin(brain);
+  if (!docsPlugin) {
+    console.log(c.red("  Docs plugin not loaded. Install @brainbank/docs."));
+    process.exit(1);
+  }
+  const results = await docsPlugin.indexDocs(opts);
+  console.log("\n");
+  for (const [name, stat] of Object.entries(results)) {
+    const removedStr = stat.removed > 0 ? `, ${c.red(String(stat.removed) + " removed")}` : "";
+    console.log(`  ${c.green(name)}: ${stat.indexed} indexed, ${stat.skipped} skipped${removedStr}, ${stat.chunks} chunks`);
+  }
+  brain.close();
+}
+__name(cmdDocs, "cmdDocs");
+async function cmdDocSearch() {
+  const query = stripFlags(args).slice(1).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 docsPlugin = findDocsPlugin(brain);
+  if (!docsPlugin) {
+    console.log(c.red("Docs plugin not loaded. Install @brainbank/docs."));
+    process.exit(1);
+  }
+  const results = await docsPlugin.search(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.type === "document" ? 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");
+
+// src/cli/server-client.ts
+import * as http from "http";
+async function tryServerContext(options) {
+  const info = isServerRunning();
+  if (!info) return null;
+  try {
+    const body = JSON.stringify({
+      task: options.task,
+      repo: options.repo,
+      sources: options.sources,
+      pathPrefix: options.pathPrefix,
+      affectedFiles: options.affectedFiles
+    });
+    const response = await httpPost(info.port, "/context", body);
+    const data = JSON.parse(response);
+    if (data.error) return null;
+    return data.context ?? null;
+  } catch {
+    return null;
+  }
+}
+__name(tryServerContext, "tryServerContext");
+async function tryServerSearch(mode, options) {
+  const info = isServerRunning();
+  if (!info) return null;
+  const endpoint = mode === "search" ? "/search" : mode === "hybrid" ? "/hsearch" : "/ksearch";
+  try {
+    const body = JSON.stringify({
+      query: options.query,
+      repo: options.repo,
+      sources: options.sources,
+      pathPrefix: options.pathPrefix,
+      maxResults: options.maxResults
+    });
+    const response = await httpPost(info.port, endpoint, body);
+    const data = JSON.parse(response);
+    if (data.error) return null;
+    return data.results ?? null;
+  } catch {
+    return null;
+  }
+}
+__name(tryServerSearch, "tryServerSearch");
+async function serverHealth() {
+  const info = isServerRunning();
+  if (!info) return null;
+  try {
+    const response = await httpGet(info.port, "/health");
+    return JSON.parse(response);
+  } catch {
+    return null;
+  }
+}
+__name(serverHealth, "serverHealth");
+function httpPost(port, path6, body) {
+  return new Promise((resolve5, reject) => {
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port,
+      path: path6,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(body)
+      },
+      timeout: 12e4
+      // 2 minutes — context queries can be slow on first load
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve5(Buffer.concat(chunks).toString("utf8")));
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+__name(httpPost, "httpPost");
+function httpGet(port, path6) {
+  return new Promise((resolve5, reject) => {
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port,
+      path: path6,
+      method: "GET",
+      timeout: 5e3
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve5(Buffer.concat(chunks).toString("utf8")));
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    req.end();
+  });
+}
+__name(httpGet, "httpGet");
+
+// src/cli/commands/search.ts
+function parseSourceFlags() {
+  const NON_SOURCE_FLAGS = /* @__PURE__ */ new Set([
+    "repo",
+    "depth",
+    "collection",
+    "pattern",
+    "context",
+    "name",
+    "keep",
+    "pruner",
+    "only",
+    "docs-path",
+    "mode",
+    "limit",
+    "ignore",
+    "include",
+    "meta",
+    "k",
+    "yes",
+    "y",
+    "force",
+    "verbose",
+    "path"
+  ]);
+  const sources = {};
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      const name = args[i].slice(2);
+      if (name === "yes" || name === "force" || name === "verbose") continue;
+      const next = args[i + 1];
+      if (next !== void 0 && /^\d+$/.test(next) && !NON_SOURCE_FLAGS.has(name)) {
+        sources[name] = parseInt(next, 10);
+        i++;
+        continue;
+      }
+      if (NON_SOURCE_FLAGS.has(name) && next !== void 0 && !next.startsWith("--")) {
+        i++;
+      }
+      continue;
+    }
+    positional.push(args[i]);
+  }
+  const query = positional.slice(1).join(" ");
+  return { sources, query };
+}
+__name(parseSourceFlags, "parseSourceFlags");
+function parsePaths() {
+  const raw = getFlag("path");
+  if (!raw) return void 0;
+  const paths = raw.split(",").map((p) => p.trim()).filter(Boolean);
+  return paths.length === 1 ? paths[0] : paths;
+}
+__name(parsePaths, "parsePaths");
+function printFilterInfo(sources, pathPrefix) {
+  const parts = [];
+  const entries = Object.entries(sources);
+  if (entries.length > 0) parts.push(...entries.map(([k, v]) => `${k}=${v}`));
+  if (pathPrefix) {
+    const paths = Array.isArray(pathPrefix) ? pathPrefix : [pathPrefix];
+    parts.push(`path=${paths.join(",")}`);
+  }
+  if (parts.length > 0) console.log(c.dim(`  Filters: ${parts.join(", ")}`));
+}
+__name(printFilterInfo, "printFilterInfo");
+function buildSearchOptions(sources, pathPrefix) {
+  const opts = {
+    sources: Object.keys(sources).length > 0 ? sources : {},
+    source: "cli"
+  };
+  if (pathPrefix) opts.pathPrefix = pathPrefix;
+  return opts;
+}
+__name(buildSearchOptions, "buildSearchOptions");
+async function cmdSearch() {
+  const { sources, query } = parseSourceFlags();
+  if (!query) {
+    console.log(c.red("Usage: brainbank search <query> [--repo <path>] [--path <dir>] [--code <n>] [--git <n>]"));
+    process.exit(1);
+  }
+  const pathPrefix = parsePaths();
+  const repo = getFlag("repo") ?? process.cwd();
+  const delegated = await tryServerSearch("search", {
+    query,
+    repo,
+    sources: Object.keys(sources).length > 0 ? sources : void 0,
+    pathPrefix
+  });
+  if (delegated) {
+    console.log(c.bold(`
+\u2501\u2501\u2501 BrainBank Search: "${query}" \u2501\u2501\u2501
+`));
+    printFilterInfo(sources, pathPrefix);
+    printResults(delegated);
+    return;
+  }
+  const brain = await createBrain();
+  console.log(c.bold(`
+\u2501\u2501\u2501 BrainBank Search: "${query}" \u2501\u2501\u2501
+`));
+  printFilterInfo(sources, pathPrefix);
+  const opts = buildSearchOptions(sources, pathPrefix);
+  const results = await brain.search(query, opts);
+  printResults(results);
+  brain.close();
+}
+__name(cmdSearch, "cmdSearch");
+async function cmdHybridSearch() {
+  const { sources, query } = parseSourceFlags();
+  if (!query) {
+    console.log(c.red("Usage: brainbank hsearch <query> [--repo <path>] [--path <dir>] [--code <n>] [--git <n>] [--docs <n>]"));
+    process.exit(1);
+  }
+  const pathPrefix = parsePaths();
+  const repo = getFlag("repo") ?? process.cwd();
+  const delegated = await tryServerSearch("hybrid", {
+    query,
+    repo,
+    sources: Object.keys(sources).length > 0 ? sources : void 0,
+    pathPrefix
+  });
+  if (delegated) {
+    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`));
+    printFilterInfo(sources, pathPrefix);
+    console.log("");
+    printResults(delegated);
+    return;
+  }
+  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`));
+  printFilterInfo(sources, pathPrefix);
+  console.log("");
+  const opts = buildSearchOptions(sources, pathPrefix);
+  const results = await brain.hybridSearch(query, opts);
+  printResults(results);
+  brain.close();
+}
+__name(cmdHybridSearch, "cmdHybridSearch");
+async function cmdKeywordSearch() {
+  const { sources, query } = parseSourceFlags();
+  if (!query) {
+    console.log(c.red("Usage: brainbank ksearch <query> [--repo <path>] [--path <dir>] [--code <n>] [--git <n>]"));
+    process.exit(1);
+  }
+  const pathPrefix = parsePaths();
+  const repo = getFlag("repo") ?? process.cwd();
+  const delegated = await tryServerSearch("keyword", {
+    query,
+    repo,
+    sources: Object.keys(sources).length > 0 ? sources : void 0,
+    pathPrefix
+  });
+  if (delegated) {
+    console.log(c.bold(`
+\u2501\u2501\u2501 BrainBank Keyword Search: "${query}" \u2501\u2501\u2501`));
+    console.log(c.dim(`  Mode: BM25 full-text (instant)`));
+    printFilterInfo(sources, pathPrefix);
+    console.log("");
+    printResults(delegated, 0.4);
+    return;
+  }
+  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)`));
+  printFilterInfo(sources, pathPrefix);
+  console.log("");
+  const opts = buildSearchOptions(sources, pathPrefix);
+  const results = await brain.searchBM25(query, opts);
+  printResults(results, 0.4);
+  brain.close();
+}
+__name(cmdKeywordSearch, "cmdKeywordSearch");
+
+// src/cli/commands/context.ts
+function parseContextFlags() {
+  const NON_SOURCE = /* @__PURE__ */ new Set([
+    "repo",
+    "depth",
+    "collection",
+    "pattern",
+    "context",
+    "name",
+    "keep",
+    "pruner",
+    "only",
+    "docs-path",
+    "mode",
+    "limit",
+    "ignore",
+    "meta",
+    "k",
+    "yes",
+    "y",
+    "force",
+    "verbose",
+    "path"
+  ]);
+  const sources = {};
+  for (let i = 0; i < args.length; i++) {
+    if (!args[i].startsWith("--")) continue;
+    const name = args[i].slice(2);
+    if (name.startsWith("no-")) {
+      sources[name.slice(3)] = 0;
+      continue;
+    }
+    const next = args[i + 1];
+    if (next !== void 0 && /^\d+$/.test(next) && !NON_SOURCE.has(name)) {
+      sources[name] = parseInt(next, 10);
+      i++;
+    }
+  }
+  return sources;
+}
+__name(parseContextFlags, "parseContextFlags");
+async function cmdContext() {
+  const pos = stripFlags(args);
+  const sub = pos[1];
+  if (sub === "add") {
+    const collection = pos[2];
+    const path6 = pos[3];
+    const desc = pos.slice(4).join(" ");
+    if (!collection || !path6 || !desc) {
+      console.log(c.red("Usage: brainbank context add <collection> <path> <description>"));
+      process.exit(1);
+    }
+    const brain2 = await createBrain();
+    await brain2.initialize();
+    const docsPlugin = findDocsPlugin(brain2);
+    if (!docsPlugin) {
+      console.log(c.red("Docs plugin not loaded."));
+      process.exit(1);
+    }
+    docsPlugin.addContext(collection, path6, desc);
+    console.log(c.green(`\u2713 Context added: ${collection}:${path6} \u2192 "${desc}"`));
+    brain2.close();
+    return;
+  }
+  if (sub === "list") {
+    const brain2 = await createBrain();
+    await brain2.initialize();
+    const docsPlugin = findDocsPlugin(brain2);
+    if (!docsPlugin) {
+      console.log(c.yellow("  Docs plugin not loaded."));
+      brain2.close();
+      return;
+    }
+    const contexts = docsPlugin.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 = stripFlags(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 sources = parseContextFlags();
+  const rawPath = getFlag("path");
+  const pathPrefix = rawPath ? rawPath.split(",").map((p) => p.trim()).filter(Boolean) : void 0;
+  const normalizedPath = pathPrefix && pathPrefix.length === 1 ? pathPrefix[0] : pathPrefix;
+  const ignorePaths = getFlagAll("ignore");
+  const repo = getFlag("repo");
+  const fields = parseFieldFlags();
+  const serverResult = await tryServerContext({
+    task,
+    repo: repo ?? process.cwd(),
+    sources: Object.keys(sources).length > 0 ? sources : void 0,
+    pathPrefix: normalizedPath
+  });
+  if (serverResult !== null) {
+    console.log(serverResult);
+    return;
+  }
+  const brain = await createBrain();
+  const context = await brain.getContext(task, {
+    sources: Object.keys(sources).length > 0 ? sources : void 0,
+    pathPrefix: normalizedPath,
+    ignorePaths: ignorePaths.length > 0 ? ignorePaths : void 0,
+    source: "cli",
+    fields: Object.keys(fields).length > 0 ? fields : void 0
+  });
+  console.log(context);
+  brain.close();
+}
+__name(cmdContext, "cmdContext");
+function parseFieldFlags() {
+  const FIELD_BOOLEANS = /* @__PURE__ */ new Set(["lines", "symbols", "compact", "expander"]);
+  const FIELD_NEGATABLE = /* @__PURE__ */ new Set(["callTree", "imports"]);
+  const fields = {};
+  for (let i = 0; i < args.length; i++) {
+    if (!args[i].startsWith("--")) continue;
+    const raw = args[i].slice(2);
+    if (raw.startsWith("no-")) {
+      const name = raw.slice(3);
+      if (FIELD_NEGATABLE.has(name)) {
+        fields[name] = false;
+      }
+      continue;
+    }
+    const dotIdx = raw.indexOf(".");
+    if (dotIdx > 0) {
+      const fieldName = raw.slice(0, dotIdx);
+      const rest = raw.slice(dotIdx + 1);
+      const eqIdx = rest.indexOf("=");
+      if (eqIdx > 0) {
+        const key = rest.slice(0, eqIdx);
+        const val = parseInt(rest.slice(eqIdx + 1), 10);
+        if (!isNaN(val)) {
+          fields[fieldName] = { [key]: val };
+        }
+      }
+      continue;
+    }
+    if (FIELD_BOOLEANS.has(raw)) {
+      fields[raw] = true;
+    }
+  }
+  return fields;
+}
+__name(parseFieldFlags, "parseFieldFlags");
+
+// src/cli/commands/files.ts
+async function cmdFiles() {
+  const patterns = [];
+  const showLines = args.includes("--lines");
+  for (let i = 1; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      if (args[i] === "--repo") {
+        i++;
+      }
+      continue;
+    }
+    patterns.push(args[i]);
+  }
+  if (patterns.length === 0) {
+    console.log(c.red("Usage: brainbank files <path|glob> [...paths] [--lines]"));
+    console.log(c.dim("  Exact:     brainbank files src/auth/login.ts"));
+    console.log(c.dim("  Directory: brainbank files src/graph/"));
+    console.log(c.dim('  Glob:      brainbank files "src/**/*.service.ts"'));
+    console.log(c.dim("  Fuzzy:     brainbank files plugin.ts"));
+    console.log(c.dim("  Lines:     brainbank files src/plugin.ts --lines"));
+    process.exit(1);
+  }
+  const brain = await createBrain();
+  await brain.initialize();
+  const results = brain.resolveFiles(patterns);
+  if (results.length === 0) {
+    console.log(c.yellow("No matching files found in the index."));
+    console.log(c.dim("Run `brainbank index` first to index your codebase."));
+    brain.close();
+    return;
+  }
+  for (const r of results) {
+    const meta = r.metadata;
+    const startLine = meta.startLine ?? 1;
+    console.log(c.bold(`
+\u2500\u2500 ${r.filePath} \u2500\u2500
+`));
+    if (showLines) {
+      const codeLines = r.content.split("\n");
+      const pad = String(startLine + codeLines.length - 1).length;
+      for (let i = 0; i < codeLines.length; i++) {
+        const lineNum = c.dim(`${String(startLine + i).padStart(pad)}|`);
+        console.log(`${lineNum} ${codeLines[i]}`);
+      }
+    } else {
+      console.log(r.content);
+    }
+  }
+  console.log(c.dim(`
+${results.length} file(s) resolved.`));
+  brain.close();
+}
+__name(cmdFiles, "cmdFiles");
+
+// src/cli/commands/stats.ts
+import * as path5 from "path";
+function formatStatKey(key) {
+  return key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").replace(/\b\w/g, (c2) => c2.toUpperCase()).padEnd(16);
+}
+__name(formatStatKey, "formatStatKey");
+async function cmdStats() {
+  const plain = args.includes("--plain");
+  if (!plain) {
+    try {
+      const repoPath = path5.resolve(getFlag("repo") ?? process.cwd());
+      const dbPath = path5.join(repoPath, ".brainbank", "data", "brainbank.db");
+      const configPath = path5.join(repoPath, ".brainbank", "config.json");
+      const { runStatsTui } = await import("./stats-tui-ZY2NQSEA.js");
+      await runStatsTui(dbPath, repoPath, configPath);
+      return;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("ENOENT")) {
+        console.log(c.yellow("No BrainBank database found. Run `brainbank index` first.\n"));
+        return;
+      }
+    }
+  }
+  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("Plugins")}: ${brain.plugins.join(", ")}
+`);
+  for (const [name, pluginStats] of Object.entries(s)) {
+    if (!pluginStats) continue;
+    console.log(`  ${c.cyan(name)}`);
+    for (const [key, value] of Object.entries(pluginStats)) {
+      console.log(`    ${formatStatKey(key)}${value}`);
+    }
+    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");
+
+// src/cli/commands/reembed.ts
+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");
+  for (const [name, count] of Object.entries(result.counts)) {
+    if (count > 0) {
+      const label = name.charAt(0).toUpperCase() + name.slice(1);
+      console.log(`  ${c.green("\u2713")} ${label.padEnd(8)} ${count} vectors`);
+    }
+  }
+  console.log(`
+  ${c.bold("Total")}: ${result.total} vectors regenerated
+`);
+  brain.close();
+}
+__name(cmdReembed, "cmdReembed");
+
+// src/cli/commands/watch.ts
+async function cmdWatch() {
+  const brain = await createBrain();
+  await brain.initialize();
+  const config = await loadConfig(brain.config.repoPath);
+  const codeIgnore = config?.code?.ignore ?? [];
+  const codeInclude = config?.code?.include ?? [];
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank Watch \u2501\u2501\u2501\n"));
+  console.log(c.dim(`  Watching ${brain.config.repoPath} for changes...`));
+  if (codeInclude.length > 0) {
+    console.log(c.dim(`  Include: ${codeInclude.join(", ")}`));
+  }
+  if (codeIgnore.length > 0) {
+    console.log(c.dim(`  Ignoring: ${codeIgnore.join(", ")}`));
+  }
+  console.log(c.dim("  Press Ctrl+C to stop.\n"));
+  const watcher = brain.watch({
+    debounceMs: 2e3,
+    ignore: codeIgnore,
+    onIndex: /* @__PURE__ */ __name((sourceId, pluginName) => {
+      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`  ${c.dim(ts)} ${c.green("\u2713")} ${c.cyan(pluginName)}: ${sourceId}`);
+    }, "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");
+
+// src/cli/commands/mcp.ts
+async function cmdMcp() {
+  await import("./mcp.js");
+}
+__name(cmdMcp, "cmdMcp");
+
+// src/cli/commands/daemon.ts
+async function cmdDaemon() {
+  const pos = stripFlags(args);
+  const sub = pos[1];
+  if (sub === "stop") return stopDaemon();
+  if (sub === "restart") {
+    stopDaemon();
+    return forkDaemon();
+  }
+  if (sub === "start") return forkDaemon();
+  return startForeground();
+}
+__name(cmdDaemon, "cmdDaemon");
+async function startForeground() {
+  const port = parseInt(getFlag("port") ?? String(DEFAULT_PORT), 10);
+  const { HttpServer } = await import("./http-server-QUXHLWUM.js");
+  const server = new HttpServer({
+    port,
+    factory: /* @__PURE__ */ __name(async (repoPath) => {
+      const brain = await createBrain(repoPath);
+      await brain.initialize();
+      return brain;
+    }, "factory"),
+    onError: /* @__PURE__ */ __name((repo, err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(c.red(`  Pool error [${repo}]: ${msg}`));
+    }, "onError"),
+    onLog: /* @__PURE__ */ __name((msg) => console.log(c.dim(`  ${msg}`)), "onLog")
+  });
+  console.log(c.bold("\n\u2501\u2501\u2501 BrainBank HTTP Daemon \u2501\u2501\u2501\n"));
+  await server.start();
+  console.log(c.dim(`  Port: ${port}`));
+  console.log(c.dim("  Press Ctrl+C to stop.\n"));
+  const shutdown = /* @__PURE__ */ __name(() => {
+    console.log(c.dim("\n  Shutting down..."));
+    server.close();
+    process.exit(0);
+  }, "shutdown");
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await new Promise(() => {
+  });
+}
+__name(startForeground, "startForeground");
+async function forkDaemon() {
+  const port = parseInt(getFlag("port") ?? String(DEFAULT_PORT), 10);
+  const { fork } = await import("child_process");
+  const existing = isServerRunning();
+  if (existing) {
+    console.log(c.yellow(`  Daemon already running (PID ${existing.pid}, port ${existing.port})`));
+    return;
+  }
+  const child = fork(process.argv[1], ["daemon", "--port", String(port)], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  console.log(c.green(`  \u2713 Daemon started (PID ${child.pid}, port ${port})`));
+  console.log(c.dim("  Stop with: brainbank daemon stop"));
+}
+__name(forkDaemon, "forkDaemon");
+function stopDaemon() {
+  const info = isServerRunning();
+  if (!info) {
+    console.log(c.yellow("  No daemon running."));
+    return;
+  }
+  try {
+    process.kill(info.pid, "SIGTERM");
+    removePid();
+    console.log(c.green(`  \u2713 Daemon stopped (PID ${info.pid})`));
+  } catch {
+    removePid();
+    console.log(c.yellow(`  PID ${info.pid} not found. Cleaned up stale PID file.`));
+  }
+}
+__name(stopDaemon, "stopDaemon");
+
+// src/cli/commands/status.ts
+function formatUptime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainMinutes = minutes % 60;
+  return remainMinutes > 0 ? `${hours}h ${remainMinutes}m` : `${hours}h`;
+}
+__name(formatUptime, "formatUptime");
+async function cmdStatus() {
+  const info = isServerRunning();
+  if (!info) {
+    console.log(`
+  ${c.dim("HTTP Server:")} ${c.yellow("stopped")}
+`);
+    console.log(c.dim("  Start with: brainbank daemon"));
+    console.log("");
+    return;
+  }
+  const health = await serverHealth();
+  if (health) {
+    const uptime = formatUptime(health.uptime);
+    console.log(`
+  ${c.dim("HTTP Server:")} ${c.green("running")}`);
+    console.log(`  ${c.dim("PID:")}         ${health.pid}`);
+    console.log(`  ${c.dim("Port:")}        ${health.port}`);
+    console.log(`  ${c.dim("Uptime:")}      ${uptime}`);
+    console.log(`  ${c.dim("Workspaces:")}  ${health.workspaces}`);
+    console.log("");
+  } else {
+    console.log(`
+  ${c.dim("HTTP Server:")} ${c.yellow("stale")} (PID ${info.pid} not responding)`);
+    console.log(c.dim("  The PID file may be stale. Restart with: brainbank daemon"));
+    console.log("");
+  }
+}
+__name(cmdStatus, "cmdStatus");
+
+// src/cli/commands/help.ts
+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")} ${c.dim("(i)")} [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(c.dim("    All accept --repo <path> --path <dir> --<source> <n>"));
+  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(`  ${c.cyan("files")} <path|glob> [...] [--lines]  View full indexed files directly`);
+  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("mcp")}                                Start MCP server (stdio)`);
+  console.log(`  ${c.cyan("mcp:export")} [target]                Export MCP config (antigravity)`);
+  console.log(`  ${c.cyan("daemon")}                             Start HTTP daemon (foreground)`);
+  console.log(`  ${c.cyan("daemon start")}                       Start HTTP daemon (background)`);
+  console.log(`  ${c.cyan("daemon stop")}                        Stop background daemon`);
+  console.log(`  ${c.cyan("daemon restart")}                     Restart background daemon`);
+  console.log(`  ${c.cyan("status")}                             Show daemon status`);
+  console.log(`  ${c.cyan("--version")} ${c.dim("(-v)")}                      Show version`);
+  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("--<source> <n>")}          Source filter: max results from <source> (0 = skip)`);
+  console.log(`  ${c.dim("--path <dir>")}            Filter context results to files under this path prefix`);
+  console.log(`  ${c.dim("--ignore <globs>")}        Ignore glob patterns for code indexing (comma-separated)`);
+  console.log(`  ${c.dim("--include <globs>")}       Include only these paths for code indexing (comma-separated)`);
+  console.log(`  ${c.dim("--yes / -y")}              Skip interactive prompt (auto-select all available)`);
+  console.log(`  ${c.dim("--setup")}                 Re-run interactive setup (modules, folders, config)`);
+  console.log(`  ${c.dim("--port <n>")}              HTTP daemon port (default: 8181)`);
+  console.log("");
+  console.log(c.bold("Examples:"));
+  console.log(c.dim("  brainbank index ."));
+  console.log(c.dim('  brainbank index . --ignore "sdk/**,vendor/**"'));
+  console.log(c.dim('  brainbank index . --include "src/**,lib/**"'));
+  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 hsearch "auth" --code 0 --git 10           # git only'));
+  console.log(c.dim('  brainbank search "handler" --git 0                   # code only'));
+  console.log(c.dim('  brainbank hsearch "api" --docs 10 --code 0 --git 0   # docs only'));
+  console.log(c.dim('  brainbank context "auth flow" | pbcopy               # \u2192 clipboard'));
+  console.log(c.dim("  brainbank daemon start                               # background HTTP"));
+  console.log(c.dim("  brainbank mcp                                        # MCP stdio"));
+  console.log(c.dim("  brainbank mcp:export antigravity                     # export MCP config"));
+}
+__name(showHelp, "showHelp");
+
+// src/cli/index.ts
+var command = args[0];
+async function main() {
+  switch (command) {
+    case "--version":
+    case "-v":
+      console.log(`brainbank v${VERSION}`);
+      break;
+    case "i":
+    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 "files":
+      return cmdFiles();
+    case "stats":
+      return cmdStats();
+    case "reembed":
+      return cmdReembed();
+    case "watch":
+      return cmdWatch();
+    case "mcp":
+      return cmdMcp();
+    case "mcp:export":
+      return cmdMcpExport();
+    case "serve":
+      return cmdMcp();
+    // backward compat
+    case "daemon":
+      return cmdDaemon();
+    case "status":
+      return cmdStatus();
+    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