brainbank 0.1.0-beta.1

package/src/cli/commands/search.ts

@@ -0,0 +1,203 @@
+/**
+ * brainbank search  — Semantic search (vector)
+ * brainbank hsearch — Hybrid search (vector + BM25)
+ * brainbank ksearch — Keyword search (BM25)
+ *
+ * Source filtering:
+ *   --code 10             Max code results
+ *   --git 0               Skip git results
+ *   --docs 5              Max document results
+ *   --notes 10            Custom plugin results
+ *   --slack_messages 5    Custom collection results
+ *
+ * Any --<name> <number> flag is treated as a source filter.
+ */
+
+import { c, args, getFlag, stripFlags, printResults } from '@/cli/utils.ts';
+import { createBrain } from '@/cli/factory/index.ts';
+import { tryServerSearch } from '@/cli/server-client.ts';
+
+/**
+ * Parse dynamic source flags: each `--<name> <number>` becomes `{ name: number }`.
+ *
+ * Known non-source flags (--repo, --depth, etc.) are excluded.
+ * Returns sources map + the query string (positional args).
+ */
+function parseSourceFlags(): { sources: Record<string, number>; query: string } {
+    const NON_SOURCE_FLAGS = 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: Record<string, number> = {};
+    const positional: string[] = [];
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith('--')) {
+            const name = args[i].slice(2);
+
+            // Skip boolean flags
+            if (name === 'yes' || name === 'force' || name === 'verbose') continue;
+
+            // If next arg is a number and flag is not a known non-source flag
+            const next = args[i + 1];
+            if (next !== undefined && /^\d+$/.test(next) && !NON_SOURCE_FLAGS.has(name)) {
+                sources[name] = parseInt(next, 10);
+                i++; // skip the value
+                continue;
+            }
+
+            // Known value flag — skip its value
+            if (NON_SOURCE_FLAGS.has(name) && next !== undefined && !next.startsWith('--')) {
+                i++;
+            }
+            continue;
+        }
+        positional.push(args[i]);
+    }
+
+    const query = positional.slice(1).join(' '); // skip command name
+    return { sources, query };
+}
+
+/** Parse --path as comma-separated list of path prefixes. */
+function parsePaths(): string | string[] | undefined {
+    const raw = getFlag('path');
+    if (!raw) return undefined;
+    const paths = raw.split(',').map(p => p.trim()).filter(Boolean);
+    return paths.length === 1 ? paths[0] : paths;
+}
+
+/** Print active source and path filters. */
+function printFilterInfo(sources: Record<string, number>, pathPrefix?: string | string[]): void {
+    const parts: string[] = [];
+    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(', ')}`));
+}
+
+/** Build search options from sources map + optional path prefix(es). */
+function buildSearchOptions(sources: Record<string, number>, pathPrefix?: string | string[]): { sources: Record<string, number>; source: 'cli'; pathPrefix?: string | string[] } {
+    const opts: { sources: Record<string, number>; source: 'cli'; pathPrefix?: string | string[] } = {
+        sources: Object.keys(sources).length > 0 ? sources : {},
+        source: 'cli',
+    };
+    if (pathPrefix) opts.pathPrefix = pathPrefix;
+    return opts;
+}
+
+export async function cmdSearch(): Promise<void> {
+    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();
+
+    // Try daemon delegation first (hot HNSW)
+    const delegated = await tryServerSearch('search', {
+        query, repo,
+        sources: Object.keys(sources).length > 0 ? sources : undefined,
+        pathPrefix,
+    });
+    if (delegated) {
+        console.log(c.bold(`\n━━━ BrainBank Search: "${query}" ━━━\n`));
+        printFilterInfo(sources, pathPrefix);
+        printResults(delegated);
+        return;
+    }
+
+    // Fall back to local
+    const brain = await createBrain();
+    console.log(c.bold(`\n━━━ BrainBank Search: "${query}" ━━━\n`));
+    printFilterInfo(sources, pathPrefix);
+
+    const opts = buildSearchOptions(sources, pathPrefix);
+    const results = await brain.search(query, opts);
+    printResults(results);
+    brain.close();
+}
+
+export async function cmdHybridSearch(): Promise<void> {
+    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();
+
+    // Try daemon delegation first (hot HNSW)
+    const delegated = await tryServerSearch('hybrid', {
+        query, repo,
+        sources: Object.keys(sources).length > 0 ? sources : undefined,
+        pathPrefix,
+    });
+    if (delegated) {
+        console.log(c.bold(`\n━━━ BrainBank Hybrid Search: "${query}" ━━━`));
+        console.log(c.dim(`  Mode: vector + BM25 → Reciprocal Rank Fusion`));
+        printFilterInfo(sources, pathPrefix);
+        console.log('');
+        printResults(delegated);
+        return;
+    }
+
+    // Fall back to local
+    const brain = await createBrain();
+    console.log(c.bold(`\n━━━ BrainBank Hybrid Search: "${query}" ━━━`));
+    console.log(c.dim(`  Mode: vector + BM25 → Reciprocal Rank Fusion`));
+    printFilterInfo(sources, pathPrefix);
+    console.log('');
+
+    const opts = buildSearchOptions(sources, pathPrefix);
+    const results = await brain.hybridSearch(query, opts);
+    printResults(results);
+    brain.close();
+}
+
+export async function cmdKeywordSearch(): Promise<void> {
+    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();
+
+    // Try daemon delegation first (hot HNSW)
+    const delegated = await tryServerSearch('keyword', {
+        query, repo,
+        sources: Object.keys(sources).length > 0 ? sources : undefined,
+        pathPrefix,
+    });
+    if (delegated) {
+        console.log(c.bold(`\n━━━ BrainBank Keyword Search: "${query}" ━━━`));
+        console.log(c.dim(`  Mode: BM25 full-text (instant)`));
+        printFilterInfo(sources, pathPrefix);
+        console.log('');
+        printResults(delegated, 0.40);
+        return;
+    }
+
+    // Fall back to local
+    const brain = await createBrain();
+    await brain.initialize();
+    console.log(c.bold(`\n━━━ BrainBank Keyword Search: "${query}" ━━━`));
+    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.40);
+    brain.close();
+}

package/src/cli/commands/stats.ts

@@ -0,0 +1,68 @@
+/** brainbank stats — Show index statistics (interactive TUI or plain text). */
+
+import * as path from 'node:path';
+import { c, args, getFlag } from '@/cli/utils.ts';
+import { createBrain } from '@/cli/factory/index.ts';
+
+/** Convert camelCase/snake_case stat keys to human-readable labels. */
+function formatStatKey(key: string): string {
+    return key
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/_/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase())
+        .padEnd(16);
+}
+
+export async function cmdStats(): Promise<void> {
+    const plain = args.includes('--plain');
+
+    if (!plain) {
+        // Interactive TUI mode
+        try {
+            const repoPath = path.resolve(getFlag('repo') ?? process.cwd());
+            const dbPath = path.join(repoPath, '.brainbank', 'data', 'brainbank.db');
+            const configPath = path.join(repoPath, '.brainbank', 'config.json');
+
+            const { runStatsTui } = await import('@/cli/tui/stats-tui.tsx');
+            await runStatsTui(dbPath, repoPath, configPath);
+            return;
+        } catch (err: unknown) {
+            // Fall back to plain mode if TUI fails (e.g., no DB, piped output)
+            if (err instanceof Error && err.message.includes('ENOENT')) {
+                console.log(c.yellow('No BrainBank database found. Run `brainbank index` first.\n'));
+                return;
+            }
+            // For other errors, fall through to plain mode
+        }
+    }
+
+    // Plain text mode (original output)
+    const brain = await createBrain();
+    await brain.initialize();
+
+    const s = brain.stats();
+
+    console.log(c.bold('\n━━━ BrainBank Stats ━━━\n'));
+    console.log(`  ${c.cyan('Plugins')}: ${brain.plugins.join(', ')}\n`);
+
+    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();
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,47 @@
+/**
+ * Status Command — Show BrainBank server status.
+ *
+ * Usage: brainbank status
+ */
+
+import { c } from '@/cli/utils.ts';
+import { serverHealth } from '@/cli/server-client.ts';
+import { isServerRunning } from '@/services/daemon.ts';
+
+function formatUptime(seconds: number): string {
+    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`;
+}
+
+export async function cmdStatus(): Promise<void> {
+    const info = isServerRunning();
+
+    if (!info) {
+        console.log(`\n  ${c.dim('HTTP Server:')} ${c.yellow('stopped')}\n`);
+        console.log(c.dim('  Start with: brainbank daemon'));
+        console.log('');
+        return;
+    }
+
+    // Try to get detailed health from the server
+    const health = await serverHealth();
+
+    if (health) {
+        const uptime = formatUptime(health.uptime);
+        console.log(`\n  ${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 {
+        // PID file exists but server not responding
+        console.log(`\n  ${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('');
+    }
+}

package/src/cli/commands/watch.ts

@@ -0,0 +1,47 @@
+/** brainbank watch — Watch for file changes. */
+
+import { c } from '@/cli/utils.ts';
+import { createBrain } from '@/cli/factory/index.ts';
+import { loadConfig } from '@/cli/factory/config-loader.ts';
+
+export async function cmdWatch(): Promise<void> {
+    const brain = await createBrain();
+    await brain.initialize();
+
+    // Read ignore/include patterns from config (code.ignore + code.include)
+    const config = await loadConfig(brain.config.repoPath);
+    const codeIgnore = (config?.code as Record<string, unknown> | undefined)?.ignore as string[] ?? [];
+    const codeInclude = (config?.code as Record<string, unknown> | undefined)?.include as string[] ?? [];
+
+    console.log(c.bold('\n━━━ BrainBank Watch ━━━\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: 2000,
+        ignore: codeIgnore,
+        onIndex: (sourceId: string, pluginName: string) => {
+            const ts = new Date().toLocaleTimeString();
+            console.log(`  ${c.dim(ts)} ${c.green('✓')} ${c.cyan(pluginName)}: ${sourceId}`);
+        },
+        onError: (err: Error) => {
+            console.error(`  ${c.red('✗')} ${err.message}`);
+        },
+    });
+
+    process.on('SIGINT', () => {
+        console.log(c.dim('\n  Stopping watcher...'));
+        watcher.close();
+        brain.close();
+        process.exit(0);
+    });
+
+    await new Promise(() => {});
+}
+

package/src/cli/factory/brain-context.ts

@@ -0,0 +1,43 @@
+/**
+ * BrainBank — Brain Context
+ *
+ * Portable input for `createBrain()`. Decouples the factory from
+ * `process.argv` / `process.env` so it can be called from the CLI,
+ * MCP server, tests, or any programmatic consumer.
+ */
+
+import { getFlag } from '../utils.ts';
+
+/** Everything the factory needs to build a BrainBank instance. */
+export interface BrainContext {
+    /** Repository root path. */
+    repoPath: string;
+    /** Environment variable overrides. Falls back to `process.env`. */
+    env?: Record<string, string | undefined>;
+    /** CLI flag overrides (e.g. `{ ignore: 'dist,vendor' }`). */
+    flags?: Record<string, string | undefined>;
+}
+
+/** Build a `BrainContext` from CLI argv + process.env. */
+export function contextFromCLI(repoPath?: string): BrainContext {
+    return {
+        repoPath: repoPath ?? getFlag('repo') ?? '.',
+        env: process.env as Record<string, string | undefined>,
+        flags: {
+            ignore: getFlag('ignore'),
+            include: getFlag('include'),
+            pruner: getFlag('pruner'),
+            embedding: getFlag('embedding'),
+        },
+    };
+}
+
+/** Read a flag from context, falling back to process.env equivalent. */
+export function ctxFlag(ctx: BrainContext, name: string): string | undefined {
+    return ctx.flags?.[name];
+}
+
+/** Read an env var from context, falling back to process.env. */
+export function ctxEnv(ctx: BrainContext, name: string): string | undefined {
+    return ctx.env?.[name] ?? process.env[name];
+}

package/src/cli/factory/builtin-registration.ts

@@ -0,0 +1,87 @@
+/**
+ * BrainBank CLI — Plugin Registration
+ *
+ * Generic plugin registration with per-plugin config resolution.
+ */
+
+import type { BrainBank } from '@/brainbank.ts';
+import type { DocumentCollection } from '@/types.ts';
+import type { ProjectConfig } from './config-loader.ts';
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { c } from '../utils.ts';
+import { loadPlugin, resolveEmbeddingKey } from './plugin-loader.ts';
+
+/** Read a nested property from a generic config section. */
+function pluginCfg(config: ProjectConfig | null, pluginName: string): Record<string, unknown> {
+    const section = config?.[pluginName];
+    if (section && typeof section === 'object' && !Array.isArray(section)) {
+        return section as Record<string, unknown>;
+    }
+    return {};
+}
+
+/** Register plugins with per-plugin config. */
+export async function registerBuiltins(
+    brain: BrainBank, rp: string, pluginNames: string[],
+    config: ProjectConfig | null, ignorePatterns: string[] = [], includePatterns: string[] = [],
+): Promise<void> {
+    for (const name of pluginNames) {
+        const factory = await loadPlugin(name);
+        if (!factory) {
+            console.error(c.yellow(`  ⚠ @brainbank/${name} not installed — skipping ${name} indexing`));
+            console.error(c.dim(`    Install: npm i -g @brainbank/${name}`));
+            continue;
+        }
+
+        const cfg = pluginCfg(config, name);
+
+        // Resolve per-plugin embedding if configured
+        const embKey = cfg.embedding as string | undefined;
+        const embeddingProvider = embKey ? await resolveEmbeddingKey(embKey) : undefined;
+
+        // Merge ignore/include patterns for plugins that support them
+        // Sources: per-plugin config (e.g. config.code.ignore), root config (config.ignore), CLI flags
+        const configIgnore = cfg.ignore as string[] | undefined ?? [];
+        const rootIgnore = (config?.ignore ?? []) as string[];
+        const mergedIgnore = [...configIgnore, ...rootIgnore, ...ignorePatterns];
+
+        const configInclude = cfg.include as string[] | undefined ?? [];
+        const rootInclude = (config?.include ?? []) as string[];
+        const mergedInclude = [...configInclude, ...rootInclude, ...includePatterns];
+
+        brain.use(factory({
+            ...cfg,
+            repoPath: rp,
+            embeddingProvider,
+            ignore: mergedIgnore.length > 0 ? mergedIgnore : undefined,
+            include: mergedInclude.length > 0 ? mergedInclude : undefined,
+        }));
+    }
+}
+
+/** Register doc collections from config. Call after brain.initialize(). */
+export async function registerConfigCollections(brain: BrainBank, rp: string, config: ProjectConfig | null): Promise<void> {
+    const docsCfg = pluginCfg(config, 'docs');
+    const collections = docsCfg.collections as DocumentCollection[] | undefined;
+    if (!collections?.length) return;
+
+    const { isDocsPlugin } = await import('@/plugin.ts');
+    const rawPlugin = brain.plugin('docs');
+    if (!rawPlugin || !isDocsPlugin(rawPlugin)) return;
+
+    const repoPath = path.resolve(rp);
+    for (const coll of collections) {
+        const absPath = path.resolve(repoPath, coll.path);
+        try {
+            await rawPlugin.addCollection({
+                name: coll.name, path: absPath,
+                pattern: coll.pattern ?? '**/*.md', ignore: coll.ignore, context: coll.context,
+            });
+        } catch (e: unknown) {
+            if (!(e instanceof Error && e.message.includes('already'))) throw e;
+            // Collection already registered — skip
+        }
+    }
+}

package/src/cli/factory/config-loader.ts

@@ -0,0 +1,77 @@
+/**
+ * BrainBank CLI — Config Loader
+ *
+ * Loads .brainbank/config.json (or .ts/.js/.mjs fallback).
+ * Config priority: CLI flags > config file > defaults.
+ */
+
+import type { Plugin } from '@/plugin.ts';
+import type { BrainBankConfig, DocumentCollection } from '@/types.ts';
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { c } from '../utils.ts';
+
+/** Full .brainbank/config.json schema. */
+export interface ProjectConfig {
+    plugins?: string[];
+    embedding?: string;
+    pruner?: string;
+    maxFileSize?: number;
+    indexers?: Plugin[];
+    brainbank?: Partial<BrainBankConfig>;
+    /** Optional API keys — override env vars. Kept out of version control. */
+    keys?: {
+        anthropic?: string;
+        perplexity?: string;
+        openai?: string;
+    };
+    /** Context field defaults (e.g. { lines: true, callTree: true, symbols: false }). */
+    context?: Record<string, unknown>;
+    /** Per-plugin config sections (e.g. code, git, docs). */
+    [pluginName: string]: unknown;
+}
+
+const CONFIG_NAMES = ['config.json', 'config.ts', 'config.js', 'config.mjs'];
+const NOT_LOADED = Symbol('not-loaded');
+let _configCache: ProjectConfig | null | typeof NOT_LOADED = NOT_LOADED;
+
+/** Load .brainbank/config.json (or .ts fallback) if present. */
+export async function loadConfig(repoPath: string): Promise<ProjectConfig | null> {
+    if (_configCache !== NOT_LOADED) return _configCache;
+
+    const brainbankDir = path.resolve(repoPath, '.brainbank');
+
+    for (const name of CONFIG_NAMES) {
+        const configPath = path.join(brainbankDir, name);
+        if (!fs.existsSync(configPath)) continue;
+
+        try {
+            if (name === 'config.json') {
+                const raw = fs.readFileSync(configPath, 'utf-8');
+                _configCache = JSON.parse(raw) as ProjectConfig;
+            } else {
+                const mod = await import(configPath);
+                _configCache = (mod.default ?? mod) as ProjectConfig;
+            }
+            return _configCache;
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(c.red(`Error loading .brainbank/${name}: ${message}`));
+            process.exit(1);
+        }
+    }
+
+    _configCache = null;
+    return null;
+}
+
+/** Get the loaded config (for use by commands). */
+export async function getConfig(repoPath?: string): Promise<ProjectConfig | null> {
+    return loadConfig(repoPath ?? '.');
+}
+
+/** Reset config cache. Useful for tests. */
+export function resetConfigCache(): void {
+    _configCache = NOT_LOADED;
+}

package/src/cli/factory/index.ts

@@ -0,0 +1,69 @@
+/**
+ * BrainBank CLI — Brain Factory
+ *
+ * Creates a configured BrainBank instance with dynamically loaded plugins,
+ * auto-discovered indexers, and config file support.
+ * Delegates to focused modules in factory/.
+ */
+
+import type { Plugin } from '@/plugin.ts';
+import type { BrainBankConfig } from '@/types.ts';
+import type { BrainContext } from './brain-context.ts';
+
+import { BrainBank } from '@/brainbank.ts';
+import { contextFromCLI, ctxFlag, ctxEnv } from './brain-context.ts';
+import { registerBuiltins, registerConfigCollections } from './builtin-registration.ts';
+import { loadConfig, getConfig, resetConfigCache } from './config-loader.ts';
+import { discoverFolderPlugins, resetPluginCache, setupProviders } from './plugin-loader.ts';
+
+export type { ProjectConfig } from './config-loader.ts';
+export type { BrainContext } from './brain-context.ts';
+export { contextFromCLI } from './brain-context.ts';
+export { getConfig, registerConfigCollections };
+
+/** Reset factory caches. Useful for tests. */
+export function resetFactoryCache(): void {
+    resetConfigCache();
+    resetPluginCache();
+}
+
+/**
+ * Create a BrainBank with built-in + discovered + config plugins.
+ *
+ * Accepts either a `BrainContext` (for programmatic use) or an optional
+ * `repoPath` string (for CLI backward compat — builds context from argv).
+ */
+export async function createBrain(contextOrRepo?: BrainContext | string): Promise<BrainBank> {
+    const ctx: BrainContext = typeof contextOrRepo === 'string'
+        ? contextFromCLI(contextOrRepo)
+        : contextOrRepo ?? contextFromCLI();
+
+    const rp = ctx.repoPath;
+    const config = await loadConfig(rp);
+    const folderPlugins = await discoverFolderPlugins(rp);
+
+    const brainOpts: Partial<BrainBankConfig> & Record<string, unknown> = { repoPath: rp, ...(config?.brainbank ?? {}) };
+    if (config?.maxFileSize) brainOpts.maxFileSize = config.maxFileSize as number;
+    await setupProviders(brainOpts, config, ctx.flags, ctx.env);
+
+    const brain = new BrainBank(brainOpts);
+    const builtins = config?.plugins ?? ['code', 'git', 'docs'];
+
+    // Merge ignore patterns from context flags
+    const ignoreFlag = ctxFlag(ctx, 'ignore');
+    const ignorePatterns = ignoreFlag ? ignoreFlag.split(',').map(s => s.trim()) : [];
+
+    // Merge include patterns from context flags
+    const includeFlag = ctxFlag(ctx, 'include');
+    const includePatterns = includeFlag ? includeFlag.split(',').map(s => s.trim()) : [];
+
+    await registerBuiltins(brain, rp, builtins, config, ignorePatterns, includePatterns);
+
+    for (const plugin of folderPlugins) brain.use(plugin);
+
+    if (config?.indexers) {
+        for (const plugin of config.indexers as Plugin[]) brain.use(plugin);
+    }
+
+    return brain;
+}