brainbank 0.7.0 → 0.8.0

package/src/cli/commands/index.ts

@@ -0,0 +1,282 @@
+/**
+ * brainbank index [path] — Interactive scan → select → index
+ *
+ * Scans the repo first, shows a summary tree, and prompts the user
+ * with checkboxes to select which modules to index. Use --yes to skip.
+ */
+
+import type { ScanResult, ScanModule } from './scan.ts';
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { c, args, getFlag, hasFlag, stripFlags } from '@/cli/utils.ts';
+import { createBrain, getConfig, registerConfigCollections } from '@/cli/factory/index.ts';
+import { findDocsPlugin } from '@/cli/utils.ts';
+import { scanRepo } from './scan.ts';
+
+export async function cmdIndex(): Promise<void> {
+    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 scan = scanRepo(repoPath);
+    printScanTree(scan, depth);
+
+
+    let modules: string[];
+
+    if (onlyRaw) {
+        // --only flag: explicit module selection
+        modules = onlyRaw.split(',').map(s => s.trim());
+    } else if (scan.config.plugins && scan.config.plugins.length > 0) {
+        // Config exists with plugins field — use it as source of truth
+        modules = scan.config.plugins;
+        console.log(c.dim(`\n  Using config: plugins = [${modules.join(', ')}]\n`));
+    } else if (skipPrompt) {
+        modules = buildDefaultModules(scan);
+    } else {
+        modules = await promptModules(scan);
+        if (modules.length === 0) {
+            console.log(c.dim('\n  Nothing selected. Exiting.\n'));
+            return;
+        }
+
+        // Clean screen and show selection summary
+        console.clear();
+        console.log(c.bold('\n━━━ BrainBank ━━━\n'));
+        console.log('  Selected modules:');
+        for (const m of modules) {
+            console.log(`    ${c.green('✓')} ${m}`);
+        }
+        console.log('');
+    }
+
+    // If --docs is passed, auto-include 'docs' in modules
+    if (docsPath && !modules.includes('docs')) {
+        modules.push('docs');
+    }
+
+    // Auto-generate config.json if it doesn't exist yet
+    if (!scan.config.exists && !skipPrompt) {
+        await saveConfig(scan.repoPath, modules);
+    }
+
+
+    console.log(c.bold(`\n━━━ Indexing: ${modules.join(', ')} ━━━`));
+
+    const brain = await createBrain(repoPath);
+    await brain.initialize();
+
+    const config = await getConfig(repoPath);
+    await registerConfigCollections(brain, repoPath, config);
+
+    if (docsPath) {
+        const absDocsPath = path.resolve(docsPath);
+        const collName = path.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: (stage, msg) => {
+            process.stdout.write(`\r  ${c.cyan(stage.toUpperCase())} ${msg}                    `);
+        },
+    });
+
+    console.log('\n');
+    for (const [name, value] of Object.entries(result)) {
+        if (!value) continue;
+        const v = value as Record<string, unknown>;
+        if (typeof v.indexed === 'number') {
+            const parts = [`${v.indexed} indexed`, `${v.skipped ?? 0} skipped`];
+            if (typeof v.chunks === 'number') parts.push(`${v.chunks} chunks`);
+            if (typeof v.removed === 'number' && v.removed > 0) parts.push(`${v.removed} removed`);
+            console.log(`  ${c.green(name)}: ${parts.join(', ')}`);
+        } else {
+            console.log(`  ${c.green(name)}: done`);
+        }
+    }
+
+    const stats = brain.stats();
+    console.log(`\n  ${c.bold('Totals')}:`);
+    for (const [name, s] of Object.entries(stats)) {
+        if (!s || typeof s !== 'object') continue;
+        const entries = Object.entries(s as Record<string, unknown>)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(', ');
+        console.log(`    ${name}: ${entries}`);
+    }
+
+    brain.close();
+}
+
+
+function printScanTree(scan: ScanResult, depth: number): void {
+    console.clear();
+    console.log(c.bold('\n━━━ BrainBank Scan ━━━'));
+    console.log(c.dim(`  Repo: ${scan.repoPath}`));
+
+    // Multi-repo detection
+    if (scan.gitSubdirs.length > 0) {
+        console.log(c.cyan(`\n  🔀 Multi-repo — ${scan.gitSubdirs.length} git repos detected`));
+        for (const sub of scan.gitSubdirs) {
+            console.log(c.dim(`     └── ${sub.name}`));
+        }
+    }
+
+    // Dynamic module display
+    for (const mod of scan.modules) {
+        console.log('');
+        if (mod.available) {
+            const extra = mod.name === 'git' ? ` (depth: ${depth})` : '';
+            console.log(`  ${mod.icon} ${c.bold(capitalizeFirst(mod.name))} — ${mod.summary}${extra}`);
+            if (mod.details) {
+                for (const d of mod.details) {
+                    console.log(c.dim(`     ${d}`));
+                }
+            }
+        } else {
+            console.log(`  ${mod.icon} ${c.dim(`${capitalizeFirst(mod.name)} — ${mod.summary}`)}`);
+        }
+    }
+
+    // Config ignore
+    if (scan.config.ignore?.length) {
+        console.log(c.dim(`     Ignore: ${scan.config.ignore.join(', ')}`));
+    }
+
+    // Config & DB
+    console.log('');
+    if (scan.config.exists) {
+        console.log(`  ⚙️  ${c.dim('Config:')} .brainbank/config.json ${c.green('✓')}`);
+    }
+    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}` : ''}`);
+    } else {
+        console.log(`  💾 ${c.dim('DB: new (first index)')}`);
+    }
+    console.log('');
+}
+
+
+/** Build the default list of available modules based on scan. */
+function buildDefaultModules(scan: ScanResult): string[] {
+    return scan.modules.filter(m => m.available && m.checked).map(m => m.name);
+}
+
+/** Interactive checkbox prompt via @inquirer/prompts. */
+async function promptModules(scan: ScanResult): Promise<string[]> {
+    const { checkbox } = await import('@inquirer/prompts');
+    console.log(c.dim('  ─────────────────────────────────────────\n'));
+
+    const choices = scan.modules.map((m: ScanModule) => ({
+        name: `${capitalizeFirst(m.name).padEnd(6)} — ${m.summary}`,
+        value: m.name,
+        checked: m.checked && m.available,
+        disabled: m.available ? undefined : m.disabled,
+    }));
+
+    return checkbox<string>({
+        message: 'Select modules to index:\n',
+        choices,
+    });
+}
+
+
+function timeSince(date: Date): string {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    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`;
+}
+
+/** Capitalize first letter. */
+function capitalizeFirst(s: string): string {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+/** Generate .brainbank/config.json from the selected modules. */
+async function saveConfig(repoPath: string, modules: string[]): Promise<void> {
+    const { select } = await import('@inquirer/prompts');
+
+    // Embedding provider selection
+    const envEmbedding = process.env.BRAINBANK_EMBEDDING;
+    const embedding = await select<string>({
+        message: 'Embedding provider:',
+        choices: [
+            {
+                name: 'perplexity-context  — best accuracy (recommended)',
+                value: 'perplexity-context',
+            },
+            {
+                name: 'perplexity          — fast, high quality',
+                value: 'perplexity',
+            },
+            {
+                name: 'openai              — text-embedding-3-small',
+                value: 'openai',
+            },
+            {
+                name: 'local               — offline, no API key needed',
+                value: 'local',
+            },
+        ],
+        default: envEmbedding ?? 'perplexity-context',
+    });
+
+    // Pruner selection
+    const pruner = await select<string>({
+        message: 'Noise pruner:',
+        choices: [
+            {
+                name: 'none   — no pruning (default)',
+                value: 'none',
+            },
+            {
+                name: 'haiku  — AI-powered noise filter (Claude Haiku)',
+                value: 'haiku',
+            },
+        ],
+        default: 'none',
+    });
+
+    const configDir = path.join(repoPath, '.brainbank');
+    const configPath = path.join(configDir, 'config.json');
+
+    const config: Record<string, unknown> = {
+        plugins: modules,
+        embedding,
+    };
+
+    if (pruner !== 'none') {
+        config.pruner = pruner;
+    }
+
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    console.log(c.green(`  ✓ Saved ${path.relative(process.cwd(), configPath)}`));
+}
+

package/src/cli/commands/kv.ts

@@ -0,0 +1,140 @@
+/**
+ * brainbank kv add|search|list|trim|clear — Dynamic KV collection management
+ */
+
+import { c, args, getFlag, stripFlags } from '@/cli/utils.ts';
+import { createBrain } from '@/cli/factory/index.ts';
+
+export async function cmdKv(): Promise<void> {
+    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(`✓ 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') as 'hybrid' | 'vector' | 'keyword';
+
+        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(`\n━━━ ${collName}: "${query}" ━━━\n`));
+            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 brain = await createBrain();
+            await brain.initialize();
+            const names = brain.listCollectionNames();
+            if (names.length === 0) {
+                console.log(c.yellow('  No KV collections found.'));
+            } else {
+                console.log(c.bold('\n━━━ KV Collections ━━━\n'));
+                for (const n of names) {
+                    const coll = brain.collection(n);
+                    console.log(`  ${c.cyan(n)} — ${coll.count()} items`);
+                }
+            }
+            brain.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(`\n━━━ ${collName} (${coll.count()} items) ━━━\n`));
+            for (const item of items) {
+                const age = Math.round((Date.now() / 1000 - 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(`✓ 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(`✓ Cleared ${before} items from '${collName}'`));
+        brain.close();
+        return;
+    }
+
+    console.log(c.red('Usage: brainbank kv <add|search|list|trim|clear>'));
+    process.exit(1);
+}
+

package/src/cli/commands/mcp.ts

@@ -0,0 +1,13 @@
+/** brainbank mcp — Start MCP server (stdio). Requires @brainbank/mcp. */
+
+import { c } from '@/cli/utils.ts';
+
+export async function cmdMcp(): Promise<void> {
+    try {
+        await import('@brainbank/mcp');
+    } catch {
+        console.error(c.red('Error: @brainbank/mcp is not installed.'));
+        console.error(c.dim('  Install: npm i @brainbank/mcp'));
+        process.exit(1);
+    }
+}

package/src/cli/commands/reembed.ts

@@ -0,0 +1,30 @@
+/** brainbank reembed — Re-embed all vectors. */
+
+import { c } from '@/cli/utils.ts';
+import { createBrain } from '@/cli/factory/index.ts';
+
+export async function cmdReembed(): Promise<void> {
+    const brain = await createBrain();
+    await brain.initialize();
+
+    console.log(c.bold('\n━━━ BrainBank Re-embed ━━━\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: (table: string, current: number, total: number) => {
+            process.stdout.write(`\r  ${c.cyan(table.padEnd(8))} ${current}/${total}`);
+        },
+    });
+
+    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('✓')} ${label.padEnd(8)} ${count} vectors`);
+        }
+    }
+    console.log(`\n  ${c.bold('Total')}: ${result.total} vectors regenerated\n`);
+
+    brain.close();
+}