grepmind-core 0.1.0-alpha

package/dist/index.js

@@ -0,0 +1,67 @@
+// grepmind-core - Core indexing library
+// No MCP dependencies, no singletons
+// Config types
+export * from './config/types.js';
+// Domain types
+export * from './types.js';
+// Git utilities
+export * from './git.js';
+// Vault utilities
+export { resolveNotePath, globVaults, getVaultRoot, toRelativePath, getVaultIndex, createVaultUtils, } from './utils/vault.js';
+// Indexer
+export { Indexer, } from './indexer/index.js';
+// Branch Indexer (overlay support for feature branches)
+export { BranchIndexer, createBranchIndexer, } from './indexer/branch.js';
+// Parser
+export { parseNote, extractLinks, extractHashtags, extractTitle, generateContentHash, generateChunkId, } from './indexer/parser.js';
+// Chunker
+export { chunkNote } from './indexer/chunker.js';
+// Embeddings
+export { WasmEmbeddingProvider, VoyageEmbeddingProvider, OllamaEmbeddingProvider, LocalAIEmbeddingProvider, createEmbeddingProvider, getModelDimensions, } from './indexer/embeddings.js';
+// Reranking
+export { WasmRerankerProvider, VoyageRerankerProvider, LocalAIRerankerProvider, normalizeScores, truncateDocument, batchArray, createRerankerProvider, } from './indexer/reranking.js';
+// Code indexing
+export { TreeSitterParser, createTreeSitterParser, } from './indexer/code/parser.js';
+export { symbolsToChunks, createFileChunk, buildEmbeddingText, smartTruncate, generateCodeChunkId, applyStableChunkIds, extractSignature, extractDocstring, } from './indexer/code/chunker.js';
+export { CodeIndexWal, } from './indexer/code/wal.js';
+// Unified SyncWal (for both notes and code)
+export { SyncWal, FileWalStorage, createWalStorage, DEFAULT_SYNC_WAL_CONFIG, } from './indexer/wal/index.js';
+// CodeIndexer
+export { CodeIndexer, createCodeIndexer, normalizeIdentifiers, withIndexLock, } from './indexer/code/index.js';
+// Tree indexing
+export { TreeIndexer, } from './indexer/code/tree/index.js';
+// Code graph indexing
+export { GraphIndexer, ReverseIndexBuilder, QUALITY_PRESETS, detectChanges, } from './indexer/code/graph/index.js';
+export { extractFacts, IMPORT_QUERY, EXPORT_QUERY, } from './indexer/code/graph/facts.js';
+export { resolveModule, loadTSConfig, ExportMapBuilder, } from './indexer/code/graph/resolver.js';
+export { analyzeFileSemantics, getImportClosure, loadTypeScript, } from './indexer/code/graph/semantic.js';
+export { extractEmbedded, extractTemplateContent, parseGraphQLContent, parseCSSContent, } from './indexer/code/graph/embedded.js';
+export { buildNodeEmbeddingText, hybridSearch, rerankWithGraph, } from './indexer/code/graph/queries.js';
+// Code Branch Indexer (overlay support for feature branches)
+export { CodeBranchIndexer, createCodeBranchIndexer, } from './indexer/code/branch.js';
+export { withRetry, withRetryResult, sleep, isRetryableError, calculateBackoff, getRetryAfter, DEFAULT_RETRY_OPTIONS, } from './indexer/code/retry.js';
+// Language extractors
+export { languageRegistry, inferSymbolTypeFromNode, } from './indexer/code/languages/index.js';
+export { genericExtractor, GenericExtractor, createGenericExtractor } from './indexer/code/languages/generic.js';
+export { cssExtractor, CssExtractor } from './indexer/code/languages/css.js';
+export { graphqlExtractor, GraphqlExtractor } from './indexer/code/languages/graphql.js';
+export { jsonExtractor, JsonExtractor } from './indexer/code/languages/json.js';
+export { yamlExtractor, YamlExtractor } from './indexer/code/languages/yaml.js';
+export { htmlExtractor, HtmlExtractor } from './indexer/code/languages/html.js';
+export { bashExtractor, BashExtractor } from './indexer/code/languages/bash.js';
+// Watcher
+export { Watcher, createWatcher, } from './indexer/watcher.js';
+// Git Sync
+export { GitSyncer, createGitSyncer, } from './indexer/git-sync.js';
+// Search - Grep
+export { escapeSqlLiteral, escapeSqlLikePattern, buildPathPrefixFilter, buildJsonStringArrayContainsAnyFilter, combineFilters, } from './search/fts.js';
+export { Grep, createGrep, highlightMatches, } from './search/grep.js';
+export { HybridGrep, } from './search/hybrid-grep.js';
+export { executeRg, buildRgArgs, processRgMessage, } from './search/rg-executor.js';
+export { parseRgQuery, resolveRegexMode, } from './search/rg-parser/index.js';
+export { extractLiterals, } from './search/rg-parser/extractor.js';
+export { decideStrategy, } from './search/rg-parser/strategy.js';
+export { buildFtsQuery, escapeTantivyTerm, } from './search/rg-parser/fts-builder.js';
+// Search - Knowledge Graph Explorer
+export { KnowledgeGraphExplorer, createKnowledgeGraphExplorer, } from './search/explore.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/indexer/branch.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Branch-aware indexer with overlay support.
+ * All dependencies are passed via constructor (no singletons).
+ *
+ * Architecture:
+ * - Base index: Full index for main branch (.lancedb/)
+ * - Overlay index: Diff index for feature branches (.lancedb/overlays/{branch}/)
+ *
+ * On feature branches:
+ * - Only changed/new chunks are stored in overlay
+ * - Deleted chunk IDs are tracked separately
+ * - Search merges base + overlay - deleted
+ */
+import type { IndexerConfig } from '../config/types.js';
+import type { EmbeddingProvider } from './embeddings.js';
+import type { VaultUtils } from '../utils/vault.js';
+import type { SearchResult, NotesError } from '../types.js';
+import { Indexer } from './index.js';
+import { type GitInfo } from '../git.js';
+/**
+ * Dependencies required by the BranchIndexer.
+ */
+export interface BranchIndexerDependencies {
+    config: IndexerConfig;
+    embeddingProvider: EmbeddingProvider;
+    vaultUtils: VaultUtils;
+    indexer: Indexer;
+}
+/**
+ * BranchIndexer - branch-aware indexing with overlay support.
+ * All dependencies are passed via constructor (no singletons).
+ */
+export declare class BranchIndexer {
+    private config;
+    private embeddingProvider;
+    private vaultUtils;
+    private indexer;
+    private db;
+    private overlayTable;
+    private deletedTable;
+    private gitInfo;
+    private initialized;
+    constructor(deps: BranchIndexerDependencies);
+    /**
+     * Get overlay directory for a branch.
+     */
+    private getOverlayPath;
+    /**
+     * Get embedding dimensions from provider.
+     */
+    private getDimensions;
+    /**
+     * Initialize branch indexer.
+     * Returns null if on main branch (use base indexer directly).
+     */
+    initialize(): Promise<GitInfo | null>;
+    private ensureOverlayTable;
+    private ensureDeletedTable;
+    /**
+     * Get all deleted chunk IDs for current branch.
+     */
+    private getDeletedIds;
+    /**
+     * Get all overlay chunk IDs.
+     */
+    private getOverlayIds;
+    /**
+     * Index a chunk in the overlay.
+     */
+    private indexOverlayChunk;
+    /**
+     * Mark chunks as deleted in overlay.
+     */
+    private markDeleted;
+    /**
+     * Index a file in the current branch context.
+     * - On main: indexes directly to base
+     * - On feature: indexes to overlay
+     */
+    indexFile(filePath: string): Promise<void | NotesError>;
+    /**
+     * Remove a file from index in current branch context.
+     */
+    removeFile(filePath: string): Promise<void>;
+    /**
+     * Search with overlay support.
+     * Merges results from base + overlay, excluding deleted.
+     */
+    search(query: string, options?: {
+        limit?: number;
+        threshold?: number;
+        tags?: string[];
+    }): Promise<SearchResult[] | NotesError>;
+    /**
+     * Sync overlay with current branch changes.
+     * Call this when switching to a feature branch.
+     */
+    syncOverlay(): Promise<{
+        indexed: number;
+        deleted: number;
+        errors: NotesError[];
+    }>;
+    /**
+     * Clear overlay for current branch.
+     */
+    clearOverlay(): Promise<void>;
+    /**
+     * Get info about current indexing context.
+     */
+    getInfo(): Promise<{
+        branch: string | null;
+        isMainBranch: boolean;
+        overlayChunks: number;
+        deletedChunks: number;
+    }>;
+}
+/**
+ * Factory function to create BranchIndexer.
+ */
+export declare function createBranchIndexer(deps: BranchIndexerDependencies): BranchIndexer;
+//# sourceMappingURL=branch.d.ts.map

package/dist/indexer/branch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/indexer/branch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAa,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAIvE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAIL,KAAK,OAAO,EACb,MAAM,WAAW,CAAC;AAuBnB;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,aAAa,CAAC;IACtB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,OAAO,CAAU;IAEzB,OAAO,CAAC,EAAE,CAAmC;IAC7C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,WAAW,CAAS;gBAEhB,IAAI,EAAE,yBAAyB;IAO3C;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;YA6C7B,kBAAkB;YAsBlB,kBAAkB;IAchC;;OAEG;YACW,aAAa;IAO3B;;OAEG;YACW,aAAa;IAO3B;;OAEG;YACW,iBAAiB;IA0C/B;;OAEG;YACW,WAAW;IAwBzB;;;;OAIG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,UAAU,CAAC;IA4C7D;;OAEG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCjD;;;OAGG;IACG,MAAM,CACV,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACZ,GACL,OAAO,CAAC,YAAY,EAAE,GAAG,UAAU,CAAC;IA+FvC;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC;IAgCxF;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBnC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC;QACvB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,YAAY,EAAE,OAAO,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CAqBH;AAUD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,yBAAyB,GAAG,aAAa,CAElF"}

package/dist/indexer/branch.js

@@ -0,0 +1,451 @@
+/**
+ * Branch-aware indexer with overlay support.
+ * All dependencies are passed via constructor (no singletons).
+ *
+ * Architecture:
+ * - Base index: Full index for main branch (.lancedb/)
+ * - Overlay index: Diff index for feature branches (.lancedb/overlays/{branch}/)
+ *
+ * On feature branches:
+ * - Only changed/new chunks are stored in overlay
+ * - Deleted chunk IDs are tracked separately
+ * - Search merges base + overlay - deleted
+ */
+import * as lancedb from '@lancedb/lancedb';
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createError, isError } from '../types.js';
+import { parseNote, generateContentHash } from './parser.js';
+import { chunkNote } from './chunker.js';
+import { getGitInfo, getChangedFilesFromMain, sanitizeBranchName, } from '../git.js';
+/**
+ * BranchIndexer - branch-aware indexing with overlay support.
+ * All dependencies are passed via constructor (no singletons).
+ */
+export class BranchIndexer {
+    config;
+    embeddingProvider;
+    vaultUtils;
+    indexer;
+    db = null;
+    overlayTable = null;
+    deletedTable = null;
+    gitInfo = null;
+    initialized = false;
+    constructor(deps) {
+        this.config = deps.config;
+        this.embeddingProvider = deps.embeddingProvider;
+        this.vaultUtils = deps.vaultUtils;
+        this.indexer = deps.indexer;
+    }
+    /**
+     * Get overlay directory for a branch.
+     */
+    getOverlayPath(branch) {
+        return path.join(this.config.lancedb.dbPath, 'overlays', sanitizeBranchName(branch));
+    }
+    /**
+     * Get embedding dimensions from provider.
+     */
+    getDimensions() {
+        return this.embeddingProvider.getDimensions();
+    }
+    /**
+     * Initialize branch indexer.
+     * Returns null if on main branch (use base indexer directly).
+     */
+    async initialize() {
+        if (this.initialized)
+            return this.gitInfo;
+        // Ensure base indexer is initialized
+        await this.indexer.initialize();
+        // Get git info from first vault path
+        const vaultPath = this.config.vaultPaths[0];
+        this.gitInfo = getGitInfo(vaultPath);
+        // If not in git repo or on main branch, no overlay needed
+        if (!this.gitInfo || this.gitInfo.isMainBranch) {
+            this.initialized = true;
+            return this.gitInfo;
+        }
+        // Overlay mode is only supported for local LanceDB paths.
+        if (/^[a-z][a-z0-9+.-]*:\/\//i.test(this.config.lancedb.dbPath)) {
+            this.initialized = true;
+            return this.gitInfo;
+        }
+        // Create overlay directory
+        const overlayPath = this.getOverlayPath(this.gitInfo.branch);
+        await fs.mkdir(overlayPath, { recursive: true });
+        // Connect to overlay database
+        this.db = await lancedb.connect(overlayPath, {
+            storageOptions: this.config.lancedb.storageOptions,
+        });
+        const tableNames = await this.db.tableNames();
+        // Open or create overlay tables
+        if (tableNames.includes('overlay_chunks')) {
+            this.overlayTable = await this.db.openTable('overlay_chunks');
+        }
+        if (tableNames.includes('deleted_chunks')) {
+            this.deletedTable = await this.db.openTable('deleted_chunks');
+        }
+        this.initialized = true;
+        return this.gitInfo;
+    }
+    async ensureOverlayTable() {
+        if (this.overlayTable)
+            return this.overlayTable;
+        const dimensions = this.getDimensions();
+        const sampleData = [{
+                id: '__init__',
+                vector: new Array(dimensions).fill(0),
+                path: '',
+                section: '',
+                title: '',
+                tags: '[]',
+                links: '[]',
+                modified: 0,
+                content_hash: '',
+                content: '',
+            }];
+        this.overlayTable = await this.db.createTable('overlay_chunks', sampleData, { mode: 'overwrite' });
+        await this.overlayTable.delete("id = '__init__'");
+        return this.overlayTable;
+    }
+    async ensureDeletedTable() {
+        if (this.deletedTable)
+            return this.deletedTable;
+        const sampleData = [{
+                id: '__init__',
+                path: '',
+                deleted_at: 0,
+            }];
+        this.deletedTable = await this.db.createTable('deleted_chunks', sampleData, { mode: 'overwrite' });
+        await this.deletedTable.delete("id = '__init__'");
+        return this.deletedTable;
+    }
+    /**
+     * Get all deleted chunk IDs for current branch.
+     */
+    async getDeletedIds() {
+        if (!this.deletedTable)
+            return new Set();
+        const results = await this.deletedTable.query().select(['id']).toArray();
+        return new Set(results.map(r => r.id));
+    }
+    /**
+     * Get all overlay chunk IDs.
+     */
+    async getOverlayIds() {
+        if (!this.overlayTable)
+            return new Set();
+        const results = await this.overlayTable.query().select(['id']).toArray();
+        return new Set(results.map(r => r.id));
+    }
+    /**
+     * Index a chunk in the overlay.
+     */
+    async indexOverlayChunk(chunk, modified) {
+        const contentHash = generateContentHash(chunk.content);
+        const table = await this.ensureOverlayTable();
+        // Check if chunk already exists with same content
+        const existing = await table.query()
+            .where(`id = '${chunk.id}'`)
+            .toArray();
+        if (existing.length > 0 && existing[0].content_hash === contentHash) {
+            return chunk.id;
+        }
+        const embedding = await this.embeddingProvider.getEmbedding(chunk.content);
+        if (isError(embedding))
+            return embedding;
+        // Delete existing if present
+        if (existing.length > 0) {
+            await table.delete(`id = '${chunk.id}'`);
+        }
+        // Also remove from deleted table if it was there
+        const deletedTable = await this.ensureDeletedTable();
+        await deletedTable.delete(`id = '${chunk.id}'`);
+        // Insert new chunk
+        await table.add([{
+                id: chunk.id,
+                vector: embedding,
+                path: chunk.path,
+                section: chunk.section,
+                title: chunk.title,
+                tags: JSON.stringify(chunk.tags),
+                links: JSON.stringify(chunk.links),
+                modified,
+                content_hash: contentHash,
+                content: chunk.content,
+            }]);
+        return chunk.id;
+    }
+    /**
+     * Mark chunks as deleted in overlay.
+     */
+    async markDeleted(chunkIds, filePath) {
+        if (chunkIds.length === 0)
+            return;
+        const table = await this.ensureDeletedTable();
+        const now = Date.now();
+        for (const id of chunkIds) {
+            // Remove from overlay if exists
+            if (this.overlayTable) {
+                await this.overlayTable.delete(`id = '${id}'`);
+            }
+            // Check if not already marked
+            const existing = await table.query().where(`id = '${id}'`).toArray();
+            if (existing.length === 0) {
+                await table.add([{
+                        id,
+                        path: filePath,
+                        deleted_at: now,
+                    }]);
+            }
+        }
+    }
+    /**
+     * Index a file in the current branch context.
+     * - On main: indexes directly to base
+     * - On feature: indexes to overlay
+     */
+    async indexFile(filePath) {
+        const gitInfo = await this.initialize();
+        // On main branch, use base indexer
+        if (!gitInfo || gitInfo.isMainBranch) {
+            return this.indexer.indexFile(filePath);
+        }
+        // On feature branch, index to overlay
+        let absolutePath;
+        if (path.isAbsolute(filePath)) {
+            absolutePath = filePath;
+        }
+        else {
+            const resolved = this.vaultUtils.resolveNotePath(filePath);
+            if (!resolved) {
+                return createError('FILE_NOT_FOUND', `File not found in any vault: ${filePath}`);
+            }
+            absolutePath = resolved;
+        }
+        const relativePath = this.vaultUtils.toRelativePath(absolutePath);
+        try {
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const stat = await fs.stat(absolutePath);
+            const note = parseNote(relativePath, content);
+            const chunks = chunkNote(note, this.config.chunking);
+            // Remove old overlay chunks for this file
+            if (this.overlayTable) {
+                await this.overlayTable.delete(`path = '${relativePath.replace(/'/g, "''")}'`);
+            }
+            // Index new chunks to overlay
+            for (const chunk of chunks) {
+                const result = await this.indexOverlayChunk(chunk, stat.mtimeMs);
+                if (isError(result))
+                    return result;
+            }
+        }
+        catch (err) {
+            return createError('INDEX_FILE_ERROR', `Failed to index ${relativePath}`, {
+                error: err.message,
+            });
+        }
+    }
+    /**
+     * Remove a file from index in current branch context.
+     */
+    async removeFile(filePath) {
+        const gitInfo = await this.initialize();
+        const relativePath = path.isAbsolute(filePath)
+            ? this.vaultUtils.toRelativePath(filePath)
+            : filePath;
+        // On main branch, use base indexer
+        if (!gitInfo || gitInfo.isMainBranch) {
+            return this.indexer.removeFile(filePath);
+        }
+        // On feature branch:
+        // 1. Remove from overlay
+        if (this.overlayTable) {
+            // Get chunk IDs before deleting
+            const chunks = await this.overlayTable.query()
+                .where(`path = '${relativePath.replace(/'/g, "''")}'`)
+                .select(['id'])
+                .toArray();
+            await this.overlayTable.delete(`path = '${relativePath.replace(/'/g, "''")}'`);
+            // Mark as deleted (they might exist in base)
+            const chunkIds = chunks.map(c => c.id);
+            await this.markDeleted(chunkIds, relativePath);
+        }
+        // 2. Also mark base chunks as deleted
+        // We need to find base chunk IDs for this file
+        // This requires querying base index - use path-based deletion marker
+        const deletedTable = await this.ensureDeletedTable();
+        await deletedTable.add([{
+                id: `__file__${relativePath}`,
+                path: relativePath,
+                deleted_at: Date.now(),
+            }]);
+    }
+    /**
+     * Search with overlay support.
+     * Merges results from base + overlay, excluding deleted.
+     */
+    async search(query, options = {}) {
+        const gitInfo = await this.initialize();
+        // On main branch, use base indexer directly
+        if (!gitInfo || gitInfo.isMainBranch) {
+            return this.indexer.search(query, options);
+        }
+        const { limit = this.config.search.defaultLimit, threshold = this.config.search.defaultThreshold, tags, } = options;
+        const queryEmbedding = await this.embeddingProvider.getEmbedding(query, 'query');
+        if (isError(queryEmbedding))
+            return queryEmbedding;
+        // Get deleted IDs and overlay IDs
+        const deletedIds = await this.getDeletedIds();
+        const overlayIds = await this.getOverlayIds();
+        // Get deleted file paths
+        const deletedPaths = new Set();
+        if (this.deletedTable) {
+            const deletedRecords = await this.deletedTable.query().toArray();
+            for (const r of deletedRecords) {
+                const id = r.id;
+                if (id.startsWith('__file__')) {
+                    deletedPaths.add(id.slice(8));
+                }
+            }
+        }
+        const results = [];
+        // 1. Search overlay first
+        if (this.overlayTable) {
+            const count = await this.overlayTable.countRows();
+            if (count > 0) {
+                const overlayResults = await this.overlayTable
+                    .search(queryEmbedding)
+                    .limit(limit * 2)
+                    .toArray();
+                for (const r of overlayResults) {
+                    const distance = r._distance;
+                    const score = 1 - (distance / 2);
+                    if (score < threshold)
+                        continue;
+                    const itemTags = JSON.parse(r.tags);
+                    const itemLinks = JSON.parse(r.links);
+                    if (tags && tags.length > 0) {
+                        if (!tags.some((tag) => itemTags.includes(tag)))
+                            continue;
+                    }
+                    results.push({
+                        path: r.path,
+                        section: r.section,
+                        score,
+                        content: r.content,
+                        title: r.title,
+                        tags: itemTags,
+                        links: itemLinks,
+                    });
+                }
+            }
+        }
+        // 2. Search base index, excluding deleted and overlay IDs
+        const baseResults = await this.indexer.search(query, {
+            limit: limit * 2,
+            threshold,
+            tags,
+        });
+        if (isError(baseResults))
+            return baseResults;
+        for (const r of baseResults) {
+            // Skip if file is deleted in this branch
+            if (deletedPaths.has(r.path))
+                continue;
+            // Generate chunk ID to check if it's in overlay or deleted
+            const chunkId = generateChunkIdFromResult(r);
+            if (overlayIds.has(chunkId) || deletedIds.has(chunkId))
+                continue;
+            results.push(r);
+        }
+        // 3. Sort by score and limit
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit);
+    }
+    /**
+     * Sync overlay with current branch changes.
+     * Call this when switching to a feature branch.
+     */
+    async syncOverlay() {
+        const gitInfo = await this.initialize();
+        if (!gitInfo || gitInfo.isMainBranch) {
+            return { indexed: 0, deleted: 0, errors: [] };
+        }
+        const vaultPath = this.config.vaultPaths[0];
+        const changes = getChangedFilesFromMain(vaultPath);
+        let indexed = 0;
+        let deleted = 0;
+        const errors = [];
+        // Index modified files
+        for (const file of changes.modified) {
+            const result = await this.indexFile(file);
+            if (isError(result)) {
+                errors.push(result);
+            }
+            else {
+                indexed++;
+            }
+        }
+        // Mark deleted files
+        for (const file of changes.deleted) {
+            await this.removeFile(file);
+            deleted++;
+        }
+        return { indexed, deleted, errors };
+    }
+    /**
+     * Clear overlay for current branch.
+     */
+    async clearOverlay() {
+        const gitInfo = await this.initialize();
+        if (!gitInfo || gitInfo.isMainBranch)
+            return;
+        const overlayPath = this.getOverlayPath(gitInfo.branch);
+        try {
+            await fs.rm(overlayPath, { recursive: true });
+        }
+        catch {
+            // Directory might not exist
+        }
+        this.overlayTable = null;
+        this.deletedTable = null;
+    }
+    /**
+     * Get info about current indexing context.
+     */
+    async getInfo() {
+        const gitInfo = await this.initialize();
+        let overlayChunks = 0;
+        let deletedChunks = 0;
+        if (this.overlayTable) {
+            overlayChunks = await this.overlayTable.countRows();
+        }
+        if (this.deletedTable) {
+            deletedChunks = await this.deletedTable.countRows();
+        }
+        return {
+            branch: gitInfo?.branch || null,
+            isMainBranch: gitInfo?.isMainBranch ?? true,
+            overlayChunks,
+            deletedChunks,
+        };
+    }
+}
+/**
+ * Generate chunk ID from search result (for filtering).
+ */
+function generateChunkIdFromResult(result) {
+    const input = result.section ? `${result.path}#${result.section}` : result.path;
+    return createHash('sha256').update(input).digest('hex').slice(0, 16);
+}
+/**
+ * Factory function to create BranchIndexer.
+ */
+export function createBranchIndexer(deps) {
+    return new BranchIndexer(deps);
+}
+//# sourceMappingURL=branch.js.map