brainbank 0.1.3 → 0.1.4

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;
+}

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

@@ -0,0 +1,324 @@
+/**
+ * BrainBank CLI — Plugin Loader
+ *
+ * Generic plugin loader registry with dynamic @brainbank/* package loading,
+ * npm package fallback for third-party plugins, and auto-discovery of
+ * user plugins from .brainbank/plugins/.
+ */
+
+import type { Plugin, PluginScanInfo, PluginPreviewLine } from '@/plugin.ts';
+import type { EmbeddingProvider } from '@/types.ts';
+import type { ProjectConfig } from './config-loader.ts';
+import type { ScanModule } from '@/cli/commands/scan.ts';
+import type { PreviewLine } from '@/cli/tui/tree-scanner.ts';
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { c } from '../utils.ts';
+
+/** Plugin factory — accepts config, returns Plugin. */
+type PluginFactory = (opts: Record<string, unknown>) => Plugin;
+
+/** Loader function: dynamically imports a package and returns its factory. */
+type PluginLoaderFn = () => Promise<PluginFactory | null>;
+
+/** Built-in plugin loader registry. Extensible at runtime. */
+const PLUGIN_LOADERS = new Map<string, PluginLoaderFn>([
+    ['code', async () => { try { return (await import('@brainbank/code')).code as PluginFactory; } catch { return null; } }],
+    ['git', async () => { try { return (await import('@brainbank/git')).git as PluginFactory; } catch { return null; } }],
+    ['docs', async () => { try { return (await import('@brainbank/docs')).docs as PluginFactory; } catch { return null; } }],
+]);
+
+/** Built-in plugin names — used to skip npm fallback. */
+const BUILTIN_PLUGINS = new Set(['code', 'git', 'docs']);
+
+
+
+/**
+ * Load a plugin factory by name.
+ * 1. Check the built-in loader registry.
+ * 2. Fallback: try `import(name)` for npm packages (third-party plugins).
+ * Returns null if not installed.
+ */
+export async function loadPlugin(name: string): Promise<PluginFactory | null> {
+    // Built-in loader
+    const loader = PLUGIN_LOADERS.get(name);
+    if (loader) return loader();
+
+    // npm package fallback — try importing the package directly
+    try {
+        const mod = await import(name) as Record<string, unknown>;
+        // Convention: export default factory, or named export matching short name
+        // e.g. 'brainbank-csv' exports `csv()`, '@myorg/brainbank-csv' exports `csv()`
+        const shortName = name.replace(/^@[^/]+\//, '').replace(/^brainbank-/, '');
+        const factory = mod.default ?? mod[shortName];
+        if (typeof factory === 'function') return factory as PluginFactory;
+
+        // Fallback: check all exports for a function that returns a Plugin-like object
+        for (const val of Object.values(mod)) {
+            if (typeof val === 'function') return val as PluginFactory;
+        }
+    } catch {
+        // Not installed — will be reported by registerBuiltins
+    }
+
+    return null;
+}
+
+/** Register a custom plugin loader. */
+export function registerPluginLoader(name: string, loader: PluginLoaderFn): void {
+    PLUGIN_LOADERS.set(name, loader);
+}
+
+
+
+/** Check if a plugin name is a built-in. */
+export function isBuiltinPlugin(name: string): boolean {
+    return BUILTIN_PLUGINS.has(name);
+}
+
+const INDEXER_EXTENSIONS = ['.ts', '.js', '.mjs'];
+const NOT_LOADED = Symbol('not-loaded');
+let _folderPluginsCache: Plugin[] | typeof NOT_LOADED = NOT_LOADED;
+
+/** Auto-discover plugins from .brainbank/plugins/ folder. */
+export async function discoverFolderPlugins(repoPath: string): Promise<Plugin[]> {
+    if (_folderPluginsCache !== NOT_LOADED) return _folderPluginsCache;
+
+    const pluginsDir = path.resolve(repoPath, '.brainbank', 'plugins');
+
+    if (!fs.existsSync(pluginsDir)) {
+        _folderPluginsCache = [];
+        return [];
+    }
+
+    const files = fs.readdirSync(pluginsDir)
+        .filter(f => INDEXER_EXTENSIONS.some(ext => f.endsWith(ext)))
+        .sort();
+
+    const plugins: Plugin[] = [];
+
+    for (const file of files) {
+        const filePath = path.join(pluginsDir, file);
+        try {
+            const mod = await import(filePath);
+            const plugin = mod.default ?? mod;
+
+            if (plugin && typeof plugin === 'object' && plugin.name) {
+                plugins.push(plugin as Plugin);
+            } else {
+                console.error(c.yellow(`⚠ ${file}: must export a default Plugin with a 'name' property, skipping`));
+            }
+        } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(c.red(`Error loading plugin ${file}: ${message}`));
+        }
+    }
+
+    _folderPluginsCache = plugins;
+    return plugins;
+}
+
+/** Reset folder plugins cache. Useful for tests. */
+export function resetPluginCache(): void {
+    _folderPluginsCache = NOT_LOADED;
+}
+
+
+// ── External Plugin Discovery (TUI integration) ──────────────────
+
+/** Result of discovering external (non-built-in) plugins. */
+export interface ExternalPluginDiscovery {
+    /** ScanModule entries to merge into the TUI sidebar. */
+    modules: ScanModule[];
+    /** Preview lines keyed by plugin name, for the TUI explorer panel. */
+    previews: Map<string, PreviewLine[]>;
+}
+
+/**
+ * Discover external plugins from config and produce scan/preview data for the TUI.
+ *
+ * For each non-built-in plugin in the list:
+ *   1. Try `import(name)` to load the package.
+ *   2. If it exports `scan(repoPath)`, use it for the sidebar.
+ *   3. If it exports `preview(repoPath)`, use it for the explorer panel.
+ *   4. If not installed, show as unavailable with install hint.
+ *
+ * Also scans `.brainbank/plugins/` folder plugins for scan/preview exports.
+ */
+export async function discoverExternalPlugins(
+    repoPath: string,
+    pluginNames: string[],
+): Promise<ExternalPluginDiscovery> {
+    const modules: ScanModule[] = [];
+    const previews = new Map<string, PreviewLine[]>();
+    const resolvedRp = path.resolve(repoPath);
+
+    // 1. Discover npm plugins listed in config
+    for (const name of pluginNames) {
+        if (BUILTIN_PLUGINS.has(name)) continue;
+
+        try {
+            const mod = await import(name) as Record<string, unknown>;
+
+            // scan() → ScanModule for sidebar
+            if (typeof mod.scan === 'function') {
+                const info = mod.scan(resolvedRp) as PluginScanInfo;
+                modules.push(scanInfoToModule(info));
+            } else {
+                // No scan export — generic entry
+                modules.push({
+                    name,
+                    available: true,
+                    checked: true,
+                    icon: '🔌',
+                    summary: `${name} plugin`,
+                });
+            }
+
+            // preview() → PreviewLine[] for explorer
+            if (typeof mod.preview === 'function') {
+                const lines = mod.preview(resolvedRp) as PluginPreviewLine[];
+                previews.set(name, lines.map(previewLineToInternal));
+            }
+        } catch {
+            // Package not installed
+            modules.push({
+                name,
+                available: false,
+                checked: false,
+                icon: '🔌',
+                summary: 'not installed',
+                disabled: `npm i ${name}`,
+            });
+        }
+    }
+
+    // 2. Discover folder plugins that export scan/preview
+    const pluginsDir = path.resolve(repoPath, '.brainbank', 'plugins');
+    if (fs.existsSync(pluginsDir)) {
+        const files = fs.readdirSync(pluginsDir)
+            .filter(f => INDEXER_EXTENSIONS.some(ext => f.endsWith(ext)))
+            .sort();
+
+        for (const file of files) {
+            const filePath = path.join(pluginsDir, file);
+            try {
+                const mod = await import(filePath) as Record<string, unknown>;
+                const plugin = mod.default ?? mod;
+                const pluginName = (plugin && typeof plugin === 'object' && 'name' in plugin)
+                    ? (plugin as { name: string }).name
+                    : file.replace(/\.[^.]+$/, '');
+
+                // Skip if already added from config
+                if (modules.some(m => m.name === pluginName)) continue;
+
+                if (typeof mod.scan === 'function') {
+                    const info = mod.scan(resolvedRp) as PluginScanInfo;
+                    modules.push(scanInfoToModule(info));
+                } else {
+                    modules.push({
+                        name: pluginName,
+                        available: true,
+                        checked: true,
+                        icon: '🔌',
+                        summary: `local plugin (${file})`,
+                    });
+                }
+
+                if (typeof mod.preview === 'function') {
+                    const lines = mod.preview(resolvedRp) as PluginPreviewLine[];
+                    previews.set(pluginName, lines.map(previewLineToInternal));
+                }
+            } catch {
+                // Failed to load folder plugin — skip for discovery
+            }
+        }
+    }
+
+    return { modules, previews };
+}
+
+/** Convert PluginScanInfo (public type) to ScanModule (internal type). */
+function scanInfoToModule(info: PluginScanInfo): ScanModule {
+    return {
+        name: info.name,
+        available: info.available,
+        summary: info.summary,
+        icon: info.icon,
+        checked: info.checked,
+        disabled: info.disabled,
+        details: info.details,
+    };
+}
+
+/** Convert PluginPreviewLine (public type) to PreviewLine (internal type). */
+function previewLineToInternal(line: PluginPreviewLine): PreviewLine {
+    return {
+        text: line.text,
+        color: line.color,
+        bold: line.bold,
+        dim: line.dim,
+    };
+}
+
+
+// ── Provider Setup ───────────────────────────────────────────────
+
+/** Resolve an embedding key string to an EmbeddingProvider instance. */
+export async function resolveEmbeddingKey(key: string): Promise<EmbeddingProvider> {
+    const { resolveEmbedding } = await import('@/providers/embeddings/resolve.ts');
+    return resolveEmbedding(key);
+}
+
+/** Configure pruner and global embedding provider on brainOpts. */
+export async function setupProviders(
+    brainOpts: Record<string, unknown>,
+    config: ProjectConfig | null,
+    flags?: Record<string, string | undefined>,
+    env?: Record<string, string | undefined>,
+): Promise<void> {
+    // Resolve API keys: config.keys > env vars
+    const keys = config?.keys ?? {};
+    const anthropicKey = keys.anthropic || process.env.ANTHROPIC_API_KEY;
+    const perplexityKey = keys.perplexity || process.env.PERPLEXITY_API_KEY;
+    const openaiKey = keys.openai || process.env.OPENAI_API_KEY;
+
+    // Inject resolved keys into process.env so downstream providers auto-detect them
+    if (anthropicKey) process.env.ANTHROPIC_API_KEY = anthropicKey;
+    if (perplexityKey) process.env.PERPLEXITY_API_KEY = perplexityKey;
+    if (openaiKey) process.env.OPENAI_API_KEY = openaiKey;
+
+
+
+    const prunerFlag = flags?.pruner ?? (config?.pruner as string | undefined);
+    if (prunerFlag === 'haiku' || prunerFlag === 'sonnet') {
+        const { HaikuPruner } = await import('@/providers/pruners/haiku-pruner.ts');
+        const model = prunerFlag === 'sonnet' ? 'claude-sonnet-4-6' : undefined;
+        brainOpts.pruner = new HaikuPruner({ apiKey: anthropicKey, model });
+    } else if (!prunerFlag && anthropicKey) {
+        // Auto-detect: ANTHROPIC_API_KEY available → enable Haiku pruner by default
+        const { HaikuPruner } = await import('@/providers/pruners/haiku-pruner.ts');
+        brainOpts.pruner = new HaikuPruner({ apiKey: anthropicKey });
+    }
+
+    const embFlag = flags?.embedding
+        ?? (config?.embedding as string | undefined)
+        ?? env?.BRAINBANK_EMBEDDING
+        ?? process.env.BRAINBANK_EMBEDDING;
+    if (embFlag) {
+        const provider = await resolveEmbeddingKey(embFlag);
+        brainOpts.embeddingProvider = provider;
+        brainOpts.embeddingDims = provider.dims;
+    } else if (perplexityKey) {
+        // Auto-detect: PERPLEXITY_API_KEY available → use Perplexity embeddings by default
+        const provider = await resolveEmbeddingKey('perplexity');
+        brainOpts.embeddingProvider = provider;
+        brainOpts.embeddingDims = provider.dims;
+    }
+
+    // Context field defaults from config.json "context" section
+    if (config?.context) {
+        brainOpts.contextFields = config.context;
+    }
+}