brainbank 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,845 @@
+import { EventEmitter } from 'node:events';
+import { P as ProgressCallback, a as BrainBankConfig, I as Indexer, C as Collection, b as IndexResult, D as DocumentCollection, S as SearchResult, c as ContextOptions, d as CoEditSuggestion, e as IndexStats, R as ResolvedConfig, E as EmbeddingProvider, V as VectorIndex, f as SearchHit, g as CodeChunk, h as Database, H as HNSWIndex, M as MemoryPattern, i as Reranker } from './types-Da_zLLOl.js';
+export { B as BrainBankModule, j as CollectionAddOptions, k as CollectionItem, l as CollectionSearchOptions, m as DistilledStrategy, n as DocChunk, G as GitCommitRecord, o as IndexerContext, p as ModuleContext, q as SearchResultType } from './types-Da_zLLOl.js';
+export { code } from './code.js';
+export { git } from './git.js';
+export { docs } from './docs.js';
+import 'better-sqlite3';
+
+/**
+ * BrainBank — Watch Mode
+ *
+ * Auto-indexes on file changes using fs.watch.
+ * Works with built-in indexers (code, git, docs) and custom indexers.
+ *
+ * Built-in behavior:
+ *   - Code files → re-indexes changed file
+ *   - Doc files  → re-indexes changed collection
+ *
+ * Custom indexers:
+ *   - Implement `onFileChange(path, event)` to handle changes
+ *   - Implement `watchPatterns()` to specify which files to watch
+ *
+ * Usage:
+ *   const watcher = brain.watch({ paths: ['.'] });
+ *   watcher.close(); // stop watching
+ */
+
+interface WatchOptions {
+    /** Paths to watch. Default: [config.repoPath] */
+    paths?: string[];
+    /** Debounce interval in ms. Default: 2000 */
+    debounceMs?: number;
+    /** Called when a file is re-indexed. */
+    onIndex?: (filePath: string, indexer: string) => void;
+    /** Called on errors. */
+    onError?: (error: Error) => void;
+}
+interface Watcher {
+    /** Stop watching. */
+    close(): void;
+    /** Whether the watcher is active. */
+    readonly active: boolean;
+}
+
+/**
+ * BrainBank — Re-embedding Engine
+ *
+ * Regenerates all vectors without re-indexing.
+ * Reads existing text from SQLite, embeds with the current provider,
+ * and replaces vector BLOBs. No file I/O, no git parsing, no re-chunking.
+ *
+ * Usage:
+ *   const result = await brain.reembed({ onProgress });
+ *   // → { code: 1200, git: 500, docs: 80, kv: 45, notes: 12, total: 1837 }
+ */
+
+interface ReembedResult {
+    code: number;
+    git: number;
+    memory: number;
+    notes: number;
+    docs: number;
+    kv: number;
+    total: number;
+}
+interface ReembedOptions {
+    /** Progress callback: (tableName, current, total) */
+    onProgress?: ProgressCallback;
+    /** Batch size for embedBatch. Default: 50 */
+    batchSize?: number;
+}
+
+/**
+ * BrainBank — Main Orchestrator
+ *
+ * Composable semantic knowledge bank for AI agents.
+ * Enable only the modules you need via .use():
+ *
+ *   import { BrainBank } from 'brainbank';
+ *   import { code } from 'brainbank/code';
+ *   import { docs } from 'brainbank/docs';
+ *   import { notes } from 'brainbank/notes';
+ *   import { memory } from 'brainbank/memory';
+ *
+ *   const brain = new BrainBank()
+ *     .use(code({ repoPath: '.' }))
+ *     .use(docs())
+ *     .use(notes())
+ *     .use(memory());
+ */
+
+declare class BrainBank extends EventEmitter {
+    private _config;
+    private _db;
+    private _embedding;
+    private _modules;
+    private _search?;
+    private _bm25?;
+    private _contextBuilder?;
+    private _initialized;
+    private _watcher?;
+    private _collections;
+    private _kvHnsw?;
+    private _kvVecs;
+    private _sharedHnsw;
+    constructor(config?: BrainBankConfig);
+    /**
+     * Register an indexer. Chainable.
+     *
+     *   brain.use(code({ repoPath: '.' })).use(docs());
+     */
+    use(indexer: Indexer): this;
+    /** Get the list of registered indexer names. */
+    get indexers(): string[];
+    /** @deprecated Use .indexers instead. */
+    get modules(): string[];
+    /** Check if an indexer is loaded. Also matches type prefix (e.g. 'code' matches 'code:frontend'). */
+    has(name: string): boolean;
+    /** Get an indexer instance. Throws if not loaded. */
+    indexer<T extends Indexer = Indexer>(name: string): T;
+    /** @deprecated Use .indexer() instead. */
+    module(name: string): Indexer;
+    /** Find all indexers whose name equals or starts with the type prefix. */
+    private _findAllByType;
+    /** Find the first indexer that matches the type. */
+    private _findFirstByType;
+    /**
+     * Initialize database, HNSW indices, and load existing vectors.
+     * Only initializes registered modules.
+     * Automatically called by index/search methods if not yet initialized.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get or create a dynamic collection.
+     * Collections are the universal data primitive — store anything, search semantically.
+     *
+     *   const errors = brain.collection('debug_errors');
+     *   await errors.add('Fixed null check', { file: 'api.ts' });
+     *   const hits = await errors.search('null pointer');
+     */
+    collection(name: string): Collection;
+    /** List all collection names that have data. */
+    listCollectionNames(): string[];
+    /**
+     * Index code and git history in one call.
+     * Incremental — only processes changes since last run.
+     */
+    index(options?: {
+        gitDepth?: number;
+        forceReindex?: boolean;
+        onProgress?: (stage: string, msg: string) => void;
+    }): Promise<{
+        code?: IndexResult;
+        git?: IndexResult;
+    }>;
+    /** Index only code files. */
+    indexCode(options?: {
+        forceReindex?: boolean;
+        onProgress?: ProgressCallback;
+    }): Promise<IndexResult>;
+    /** Index only git history. */
+    indexGit(options?: {
+        depth?: number;
+        onProgress?: ProgressCallback;
+    }): Promise<IndexResult>;
+    /** Register a document collection. */
+    addCollection(collection: DocumentCollection): Promise<void>;
+    /** Remove a collection and all its indexed data. */
+    removeCollection(name: string): Promise<void>;
+    /** List all registered collections. */
+    listCollections(): DocumentCollection[];
+    /** Index all (or specific) document collections. */
+    indexDocs(options?: {
+        collections?: string[];
+        onProgress?: (collection: string, file: string, current: number, total: number) => void;
+    }): Promise<Record<string, {
+        indexed: number;
+        skipped: number;
+        chunks: number;
+    }>>;
+    /** Search documents only. */
+    searchDocs(query: string, options?: {
+        collection?: string;
+        k?: number;
+        minScore?: number;
+    }): Promise<SearchResult[]>;
+    /** Add context description for a collection path. */
+    addContext(collection: string, path: string, context: string): void;
+    /** Remove context for a collection path. */
+    removeContext(collection: string, path: string): void;
+    /** List all context entries. */
+    listContexts(): {
+        collection: string;
+        path: string;
+        context: string;
+    }[];
+    /**
+     * Get formatted context for a task.
+     * Returns markdown ready for system prompt injection.
+     */
+    getContext(task: string, options?: ContextOptions): Promise<string>;
+    /** Semantic search across all loaded modules. */
+    search(query: string, options?: {
+        codeK?: number;
+        gitK?: number;
+        memoryK?: number;
+        minScore?: number;
+        useMMR?: boolean;
+    }): Promise<SearchResult[]>;
+    /** Semantic search over code only. */
+    searchCode(query: string, k?: number): Promise<SearchResult[]>;
+    /** Semantic search over commits only. */
+    searchCommits(query: string, k?: number): Promise<SearchResult[]>;
+    /**
+     * Hybrid search: vector + BM25 fused with Reciprocal Rank Fusion.
+     * Best quality — catches both exact keyword matches and conceptual similarities.
+     */
+    hybridSearch(query: string, options?: {
+        /** @deprecated Use collections: { code: N } instead */
+        codeK?: number;
+        /** @deprecated Use collections: { git: N } instead */
+        gitK?: number;
+        memoryK?: number;
+        minScore?: number;
+        useMMR?: boolean;
+        /**
+         * Sources to include and max results per source.
+         * Reserved keys: "code", "git", "docs" control built-in indexers.
+         * Any other key is treated as a KV collection name.
+         * Example: { code: 8, git: 5, docs: 4, errors: 3, slack: 2 }
+         */
+        collections?: Record<string, number>;
+    }): Promise<SearchResult[]>;
+    /** BM25 keyword search only (no embeddings needed). */
+    searchBM25(query: string, options?: {
+        codeK?: number;
+        gitK?: number;
+        memoryK?: number;
+    }): SearchResult[];
+    /** Rebuild FTS5 indices. */
+    rebuildFTS(): void;
+    /** Get git history for a specific file. */
+    fileHistory(filePath: string, limit?: number): Promise<any[]>;
+    /** Get co-edit suggestions for a file. */
+    coEdits(filePath: string, limit?: number): CoEditSuggestion[];
+    /** Get statistics for all loaded modules. */
+    stats(): IndexStats;
+    /**
+     * Start watching for file changes and auto-re-index.
+     * Works with built-in and custom indexers.
+     *
+     *   const watcher = brain.watch({
+     *     onIndex: (file, indexer) => console.log(`${indexer}: ${file}`),
+     *   });
+     *   // later: watcher.close();
+     */
+    watch(options?: WatchOptions): Watcher;
+    /**
+     * Re-embed all existing text with the current embedding provider.
+     * Use this when switching providers (e.g. Local → OpenAI).
+     * Does NOT re-parse files, git history, or documents — only regenerates vectors.
+     *
+     * @example
+     *   const brain = new BrainBank({ embeddingProvider: new OpenAIEmbedding() });
+     *   await brain.initialize();
+     *   const result = await brain.reembed();
+     *   // → { code: 1200, git: 500, docs: 80, kv: 45, notes: 12, total: 1837 }
+     */
+    reembed(options?: ReembedOptions): Promise<ReembedResult>;
+    /** Close database and release resources. */
+    close(): void;
+    /** Whether the brainbank has been initialized. */
+    get isInitialized(): boolean;
+    /** The resolved configuration. */
+    get config(): Readonly<ResolvedConfig>;
+    /** Load vectors from SQLite into HNSW index. */
+    private _loadVectors;
+}
+
+/**
+ * BrainBank — Local Embedding Provider
+ *
+ * Uses @xenova/transformers with all-MiniLM-L6-v2 (384 dims, WASM).
+ * Downloads ~23MB on first use, cached locally.
+ * No external API calls — runs entirely in-process.
+ */
+
+declare class LocalEmbedding implements EmbeddingProvider {
+    readonly dims: number;
+    private _pipeline;
+    private _modelName;
+    private _cacheDir;
+    constructor(options?: {
+        model?: string;
+        cacheDir?: string;
+    });
+    /**
+     * Lazy-load the transformer pipeline.
+     * Singleton — created once and reused.
+     */
+    private _getPipeline;
+    /**
+     * Embed a single text string.
+     * Returns a normalized Float32Array of length 384.
+     */
+    embed(text: string): Promise<Float32Array>;
+    /**
+     * Embed multiple texts.
+     * Processes sequentially to avoid OOM on large batches.
+     */
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    close(): Promise<void>;
+}
+
+/**
+ * BrainBank — OpenAI Embedding Provider
+ *
+ * Uses OpenAI's embedding API via fetch (no SDK dependency).
+ * Supports text-embedding-3-small, text-embedding-3-large, and ada-002.
+ *
+ * Usage:
+ *   const brain = new BrainBank({
+ *     embeddingProvider: new OpenAIEmbedding({ model: 'text-embedding-3-small' }),
+ *   });
+ */
+
+interface OpenAIEmbeddingOptions {
+    /** OpenAI API key. Falls back to OPENAI_API_KEY env var. */
+    apiKey?: string;
+    /** Model name. Default: 'text-embedding-3-small' */
+    model?: string;
+    /** Vector dimensions. If omitted, uses model default. text-embedding-3-* supports custom dims. */
+    dims?: number;
+    /** Base URL override (for Azure, proxies, etc.) */
+    baseUrl?: string;
+}
+declare class OpenAIEmbedding implements EmbeddingProvider {
+    readonly dims: number;
+    private _apiKey;
+    private _model;
+    private _baseUrl;
+    private _requestDims;
+    private _retrying;
+    constructor(options?: OpenAIEmbeddingOptions);
+    embed(text: string): Promise<Float32Array>;
+    embedBatch(texts: string[]): Promise<Float32Array[]>;
+    close(): Promise<void>;
+    private _isTokenLimitError;
+    private _request;
+}
+
+/**
+ * BrainBank — Math Utilities
+ *
+ * Pure vector math functions for similarity calculations.
+ * No dependencies — works on Float32Array directly.
+ */
+/**
+ * Cosine similarity between two vectors.
+ * Assumes vectors are already normalized (unit length).
+ * Returns value between -1.0 and 1.0.
+ */
+declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * L2-normalize a vector to unit length.
+ * Returns a new Float32Array.
+ */
+declare function normalize(vec: Float32Array): Float32Array;
+
+/**
+ * BrainBank — Maximum Marginal Relevance (MMR)
+ *
+ * Diversifies vector search results to avoid returning redundant items.
+ * λ=1.0 → pure relevance, λ=0.0 → pure diversity.
+ * Default λ=0.7 balances both.
+ */
+
+/**
+ * Search with Maximum Marginal Relevance for diversified results.
+ *
+ * Algorithm:
+ *   1. Get 3x candidates from HNSW
+ *   2. Greedily select items that maximize: λ * relevance - (1-λ) * max_sim_to_selected
+ */
+declare function searchMMR(index: VectorIndex, query: Float32Array, vectorCache: Map<number, Float32Array>, k: number, lambda?: number): SearchHit[];
+
+/**
+ * BrainBank — Code Chunker
+ *
+ * Language-aware code splitting into semantic blocks.
+ * Detects functions, classes, and methods using regex + brace balancing.
+ * Falls back to sliding window for unsupported languages.
+ */
+
+interface ChunkerConfig {
+    /** Max lines per chunk. Default: 80 */
+    maxLines?: number;
+    /** Min lines for a detected block to be a chunk. Default: 3 */
+    minLines?: number;
+    /** Overlap between adjacent generic chunks. Default: 5 */
+    overlap?: number;
+}
+declare class CodeChunker {
+    private MAX;
+    private MIN;
+    private OVERLAP;
+    constructor(config?: ChunkerConfig);
+    /**
+     * Split file content into semantic chunks.
+     * Small files (< maxLines) become a single chunk.
+     * For JS/TS/Python: detects functions and classes.
+     * For other languages: sliding window with overlap.
+     */
+    chunk(filePath: string, content: string, language: string): CodeChunk[];
+    private _chunkJS;
+    private _chunkPython;
+    private _chunkGeneric;
+    private _findBlockEnd;
+    private _splitLarge;
+}
+
+/**
+ * BrainBank — Code Indexer
+ *
+ * Walks a repository, chunks source files semantically,
+ * embeds each chunk, and stores in SQLite + HNSW.
+ * Incremental: only re-indexes files that changed (by content hash).
+ */
+
+interface CodeIndexerDeps {
+    db: Database;
+    hnsw: HNSWIndex;
+    vectorCache: Map<number, Float32Array>;
+    embedding: EmbeddingProvider;
+}
+interface CodeIndexOptions {
+    forceReindex?: boolean;
+    onProgress?: ProgressCallback;
+}
+declare class CodeIndexer {
+    private _chunker;
+    private _deps;
+    private _repoPath;
+    private _maxFileSize;
+    constructor(repoPath: string, deps: CodeIndexerDeps, maxFileSize?: number);
+    /**
+     * Index all supported files in the repository.
+     * Skips unchanged files (same content hash).
+     */
+    index(options?: CodeIndexOptions): Promise<IndexResult>;
+    private _walkRepo;
+    private _hash;
+}
+
+/**
+ * BrainBank — Git Indexer
+ *
+ * Reads git history, embeds commit messages + diffs,
+ * and computes file co-edit relationships.
+ * Incremental: only processes new commits.
+ */
+
+interface GitIndexerDeps {
+    db: Database;
+    hnsw: HNSWIndex;
+    vectorCache: Map<number, Float32Array>;
+    embedding: EmbeddingProvider;
+}
+interface GitIndexOptions {
+    depth?: number;
+    onProgress?: ProgressCallback;
+}
+declare class GitIndexer {
+    private _deps;
+    private _repoPath;
+    private _maxDiffBytes;
+    constructor(repoPath: string, deps: GitIndexerDeps, maxDiffBytes?: number);
+    /**
+     * Index git history.
+     * Only processes commits not already in the database.
+     */
+    index(options?: GitIndexOptions): Promise<IndexResult>;
+    /**
+     * Compute which files tend to be edited together.
+     * Stored in the co_edits table for later suggestion.
+     */
+    private _computeCoEdits;
+}
+
+/**
+ * BrainBank — Document Indexer
+ *
+ * Indexes generic document collections (markdown, text, etc.)
+ * with heading-aware smart chunking, inspired by qmd.
+ *
+ *   const indexer = new DocIndexer(db, embedding, hnsw, vecCache);
+ *   await indexer.indexCollection('notes', '/path/to/notes', '**\/*.md');
+ */
+
+declare class DocIndexer {
+    private _db;
+    private _embedding;
+    private _hnsw;
+    private _vecCache;
+    constructor(_db: Database, _embedding: EmbeddingProvider, _hnsw: HNSWIndex, _vecCache: Map<number, Float32Array>);
+    /**
+     * Index all documents in a collection.
+     * Incremental — skips unchanged files (by content hash).
+     */
+    indexCollection(collection: string, dirPath: string, pattern?: string, options?: {
+        ignore?: string[];
+        onProgress?: (file: string, current: number, total: number) => void;
+    }): Promise<{
+        indexed: number;
+        skipped: number;
+        chunks: number;
+    }>;
+    /**
+     * Remove all indexed data for a collection.
+     */
+    removeCollection(collection: string): void;
+    /**
+     * Split document into chunks at natural markdown boundaries.
+     * Uses heading-aware scoring like qmd.
+     */
+    private _smartChunk;
+    /**
+     * Find all potential break points in the document with scores.
+     */
+    private _findBreakPoints;
+    /**
+     * Extract document title from first heading or filename.
+     */
+    private _extractTitle;
+}
+
+/**
+ * BrainBank — Language Registry
+ *
+ * Supported file extensions, language mappings, and ignore lists.
+ * Controls which files get indexed and how they're chunked.
+ */
+declare const SUPPORTED_EXTENSIONS: Record<string, string>;
+declare const IGNORE_DIRS: Set<string>;
+/** Check if a file extension is supported for indexing. */
+declare function isSupported(filePath: string): boolean;
+/** Get the language name for a file. Returns undefined if not supported. */
+declare function getLanguage(filePath: string): string | undefined;
+
+/**
+ * BrainBank — Pattern Store (Agent Memory)
+ *
+ * Stores what the agent learned from past tasks.
+ * Each pattern records task, approach, and success rate.
+ * Searchable by semantic similarity via HNSW.
+ */
+
+interface PatternStoreDeps {
+    db: Database;
+    hnsw: HNSWIndex;
+    vectorCache: Map<number, Float32Array>;
+    embedding: EmbeddingProvider;
+}
+declare class PatternStore {
+    private _deps;
+    constructor(deps: PatternStoreDeps);
+    /**
+     * Store a learned pattern.
+     * Returns the pattern ID.
+     */
+    learn(pattern: MemoryPattern): Promise<number>;
+    /**
+     * Search for similar successful patterns.
+     * Filters by minimum success rate.
+     */
+    search(query: string, k?: number, minSuccess?: number): Promise<(MemoryPattern & {
+        score: number;
+    })[]>;
+    /**
+     * Get all patterns for a specific task type.
+     */
+    getByTaskType(taskType: string, limit?: number): MemoryPattern[];
+    /** Total number of stored patterns. */
+    get count(): number;
+}
+
+/**
+ * BrainBank — Consolidator
+ *
+ * Maintenance operations for the agent memory:
+ *   - prune: remove old failed patterns
+ *   - dedup: merge near-duplicate patterns (cosine > 0.95)
+ *   - consolidate: run both
+ */
+
+declare class Consolidator {
+    private _db;
+    private _vectorCache;
+    constructor(_db: Database, _vectorCache: Map<number, Float32Array>);
+    /**
+     * Remove old failed patterns.
+     * Criteria: success_rate < 0.3 AND created > 90 days ago.
+     */
+    prune(maxAgeDays?: number, minSuccess?: number): number;
+    /**
+     * Merge near-duplicate patterns.
+     * Keeps the one with higher success_rate.
+     * Threshold: cosine similarity > 0.95.
+     */
+    dedup(threshold?: number): number;
+    /**
+     * Run full consolidation: prune + dedup.
+     */
+    consolidate(): {
+        pruned: number;
+        deduped: number;
+    };
+}
+
+/**
+ * BrainBank — Note Memory Store
+ *
+ * Stores structured note digests for long-term agent memory.
+ * Each digest captures decisions, files changed, patterns, and open questions.
+ * Supports vector + BM25 hybrid retrieval via HNSW + FTS5.
+ *
+ * Memory tiers:
+ *   - "short" (default): Full digest, last ~20 notes
+ *   - "long":  Compressed to patterns + decisions only
+ */
+
+interface NoteDigest {
+    title: string;
+    summary: string;
+    decisions?: string[];
+    filesChanged?: string[];
+    patterns?: string[];
+    openQuestions?: string[];
+    tags?: string[];
+}
+interface StoredNote extends NoteDigest {
+    id: number;
+    tier: 'short' | 'long';
+    createdAt: number;
+    score?: number;
+}
+interface RecallOptions {
+    /** Max results. Default: 5 */
+    k?: number;
+    /** Search mode. Default: 'hybrid' */
+    mode?: 'hybrid' | 'vector' | 'keyword';
+    /** Minimum score threshold. Default: 0.15 */
+    minScore?: number;
+    /** Filter by tier. Default: all */
+    tier?: 'short' | 'long';
+}
+declare class NoteStore {
+    private _db;
+    private _embedding;
+    private _hnsw;
+    private _vecs;
+    constructor(db: Database, embedding: EmbeddingProvider, hnsw: HNSWIndex, vecs: Map<number, Float32Array>);
+    /**
+     * Store a note digest.
+     * Embeds title + summary for vector search, auto-indexed in FTS5.
+     */
+    remember(digest: NoteDigest): Promise<number>;
+    /**
+     * Recall relevant notes.
+     * Supports vector, keyword, or hybrid (default) retrieval.
+     */
+    recall(query: string, options?: RecallOptions): Promise<StoredNote[]>;
+    /**
+     * List recent notes.
+     */
+    list(limit?: number, tier?: 'short' | 'long'): StoredNote[];
+    /**
+     * Get total count of notes.
+     */
+    count(): {
+        total: number;
+        short: number;
+        long: number;
+    };
+    /**
+     * Consolidate old short-term notes into long-term.
+     * Keeps the most recent `keepRecent` as short-term, compresses the rest.
+     */
+    consolidate(keepRecent?: number): {
+        promoted: number;
+    };
+    private _searchVector;
+    private _searchBM25;
+    private _rowToNote;
+}
+
+/**
+ * BrainBank — Unified Search
+ *
+ * Searches across all three indices (code, git, memory)
+ * and returns typed results sorted by relevance.
+ */
+
+interface SearchDeps {
+    db: Database;
+    codeHnsw?: HNSWIndex;
+    gitHnsw?: HNSWIndex;
+    memHnsw?: HNSWIndex;
+    codeVecs: Map<number, Float32Array>;
+    gitVecs: Map<number, Float32Array>;
+    memVecs: Map<number, Float32Array>;
+    embedding: EmbeddingProvider;
+    reranker?: Reranker;
+}
+interface SearchOptions {
+    /** Max code results. Default: 6 */
+    codeK?: number;
+    /** Max git results. Default: 5 */
+    gitK?: number;
+    /** Max memory results. Default: 4 */
+    memoryK?: number;
+    /** Minimum similarity score. Default: 0.25 */
+    minScore?: number;
+    /** Use MMR for diversity. Default: true */
+    useMMR?: boolean;
+    /** MMR lambda. Default: 0.7 */
+    mmrLambda?: number;
+}
+declare class UnifiedSearch {
+    private _deps;
+    constructor(deps: SearchDeps);
+    /**
+     * Search across all indices.
+     * Returns combined results sorted by score.
+     */
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Re-rank results using position-aware blending.
+     *
+     * Top 1-3:  75% retrieval / 25% reranker (preserves exact matches)
+     * Top 4-10: 60% retrieval / 40% reranker
+     * Top 11+:  40% retrieval / 60% reranker (trust reranker more)
+     */
+    private _rerank;
+}
+
+/**
+ * BrainBank — Co-Edit Analyzer
+ *
+ * Suggests files that historically change together.
+ * Based on git commit co-occurrence analysis.
+ */
+
+declare class CoEditAnalyzer {
+    private _db;
+    constructor(_db: Database);
+    /**
+     * Get files that frequently change alongside the given file.
+     * Returns sorted by co-edit count (highest first).
+     */
+    suggest(filePath: string, limit?: number): CoEditSuggestion[];
+}
+
+/**
+ * BrainBank — Context Builder
+ *
+ * Builds a formatted markdown context block from search results.
+ * Ready for injection into an LLM system prompt.
+ * Groups code by file, includes git history and learned patterns.
+ */
+
+declare class ContextBuilder {
+    private _search;
+    private _coEdits;
+    constructor(_search: UnifiedSearch, _coEdits: CoEditAnalyzer);
+    /**
+     * Build a full context block for a task.
+     * Returns clean markdown ready for system prompt injection.
+     */
+    build(task: string, options?: ContextOptions): Promise<string>;
+}
+
+/**
+ * BrainBank — BM25 Full-Text Search
+ *
+ * Keyword search via SQLite FTS5 with BM25 ranking.
+ * Searches across code chunks, git commits, and memory patterns.
+ * Uses Porter stemming + unicode61 tokenizer.
+ */
+
+interface BM25Options {
+    /** Max code results. Default: 8 */
+    codeK?: number;
+    /** Max git results. Default: 5 */
+    gitK?: number;
+    /** Max memory results. Default: 4 */
+    memoryK?: number;
+}
+declare class BM25Search {
+    private _db;
+    constructor(_db: Database);
+    /**
+     * Full-text keyword search across all FTS5 indices.
+     * Uses BM25 scoring — lower scores = better matches.
+     * Query syntax: simple words, OR, NOT, "exact phrases", prefix*
+     */
+    search(query: string, options?: BM25Options): SearchResult[];
+    /**
+     * Rebuild the FTS index from scratch.
+     * Call this after bulk imports or if FTS gets out of sync.
+     */
+    rebuild(): void;
+}
+
+/**
+ * BrainBank — Reciprocal Rank Fusion (RRF)
+ *
+ * Combines results from multiple search systems (vector + BM25)
+ * using the RRF algorithm: score = Σ 1/(k + rank_i)
+ *
+ * This is the same algorithm used by Elasticsearch, QMD, and most
+ * production hybrid search systems. Simple but very effective.
+ *
+ * Reference: Cormack et al., "Reciprocal Rank Fusion outperforms
+ * Condorcet and individual Rank Learning Methods" (2009)
+ */
+
+/**
+ * Fuse ranked lists from different search systems into a single ranked list.
+ *
+ * @param resultSets - Arrays of SearchResult from different systems (e.g. vector, BM25)
+ * @param k - Smoothing constant. Default: 60 (standard value). Higher = less emphasis on top ranks.
+ * @param maxResults - Maximum results to return.
+ */
+declare function reciprocalRankFusion(resultSets: SearchResult[][], k?: number, maxResults?: number): SearchResult[];
+
+declare const DEFAULTS: ResolvedConfig;
+/**
+ * Merge partial config with defaults.
+ * All fields become required.
+ * Relative dbPath is resolved against repoPath.
+ */
+declare function resolveConfig(partial?: BrainBankConfig): ResolvedConfig;
+
+export { BM25Search, BrainBank, BrainBankConfig, CoEditAnalyzer, CoEditSuggestion, CodeChunk, CodeChunker, CodeIndexer, Collection, Consolidator, ContextBuilder, ContextOptions, DEFAULTS, DocIndexer, DocumentCollection, EmbeddingProvider, GitIndexer, HNSWIndex, IGNORE_DIRS, IndexResult, IndexStats, Indexer, LocalEmbedding, MemoryPattern, type NoteDigest, NoteStore, OpenAIEmbedding, type OpenAIEmbeddingOptions, PatternStore, ProgressCallback, type RecallOptions, type ReembedOptions, type ReembedResult, Reranker, ResolvedConfig, SUPPORTED_EXTENSIONS, SearchHit, SearchResult, type StoredNote, UnifiedSearch, VectorIndex, type WatchOptions, type Watcher, cosineSimilarity, getLanguage, isSupported, normalize, reciprocalRankFusion, resolveConfig, searchMMR };