grepmind-core 0.1.0-alpha

package/dist/indexer/code/index.js

@@ -0,0 +1,2070 @@
+// CodeIndexer - main code indexing class
+// Refactored for DI: accepts config and embedding provider via constructor
+import * as lancedb from '@lancedb/lancedb';
+import { BooleanQuery, MatchQuery, Occur, PhraseQuery } from '@lancedb/lancedb';
+import { glob } from 'glob';
+import fs from 'node:fs/promises';
+import { existsSync, mkdirSync, rmSync, statSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import _ignore from 'ignore';
+const ignore = _ignore.default || _ignore;
+import { minimatch } from 'minimatch';
+import { DEFAULT_RERANKING_CONFIG, } from '../../config/types.js';
+import { createTreeSitterParser } from './parser.js';
+import { applyStableChunkIds, symbolsToChunks, createFileChunk, buildEmbeddingText, generateContentHash, } from './chunker.js';
+import { languageRegistry } from './languages/index.js';
+import { createError, isError } from '../../types.js';
+import { CodeIndexWal } from './wal.js';
+import { withRetry } from './retry.js';
+import { GraphIndexer } from './graph/index.js';
+import { buildPathPrefixFilter, combineFilters } from '../../search/fts.js';
+import { TreeIndexer } from './tree/index.js';
+// Import language extractors to register them
+import './languages/typescript.js';
+import './languages/css.js';
+import './languages/graphql.js';
+import './languages/json.js';
+import './languages/yaml.js';
+import './languages/html.js';
+import './languages/bash.js';
+// Lock timeout for concurrent indexing protection
+const LOCK_TIMEOUT_MS = 60_000; // 1 minute
+// Default retry options for embedding calls
+const DEFAULT_EMBEDDING_RETRY = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    retryableErrors: [
+        '429',
+        'rate limit',
+        'Rate limit',
+        'RATE_LIMIT',
+        '5',
+        'ECONNRESET',
+        'ETIMEDOUT',
+        'timeout',
+        'temporarily unavailable',
+        'service unavailable',
+    ],
+};
+export function normalizeIdentifiers(content) {
+    return content
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[_-]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Convert CodeChunk (camelCase) to LanceDB record (snake_case).
+ * Required because LanceDB SQL doesn't support camelCase column names.
+ */
+function toChunkRecord(chunk, vector, normalizeContent) {
+    const normalized = normalizeContent ? normalizeIdentifiers(chunk.content) : chunk.content;
+    return {
+        id: chunk.id,
+        vector,
+        path: chunk.path,
+        language: chunk.language,
+        symbol_type: chunk.symbolType,
+        symbol_name: chunk.symbolName,
+        signature: chunk.signature,
+        parent_symbol: chunk.parentSymbol,
+        scope: JSON.stringify(chunk.scope),
+        content: chunk.content,
+        content_normalized: normalized,
+        start_line: chunk.startLine,
+        end_line: chunk.endLine,
+        docstring: chunk.docstring,
+        modified: chunk.modified,
+        content_hash: chunk.contentHash,
+    };
+}
+/**
+ * Convert LanceDB record (snake_case) to CodeSearchResult (camelCase).
+ * Required because LanceDB SQL doesn't support camelCase column names.
+ */
+function fromChunkRecord(r) {
+    return {
+        id: r.id,
+        path: r.path,
+        language: r.language,
+        symbolType: r.symbol_type,
+        symbolName: r.symbol_name,
+        signature: r.signature,
+        parentSymbol: r.parent_symbol,
+        scope: JSON.parse(r.scope || '[]'),
+        content: r.content,
+        startLine: r.start_line,
+        endLine: r.end_line,
+        docstring: r.docstring,
+        modified: r.modified,
+        contentHash: r.content_hash,
+        score: (r._distance !== undefined) ? 1 - r._distance / 2 : 1.0,
+    };
+}
+// Default include patterns
+const DEFAULT_INCLUDE = [
+    '**/*.ts',
+    '**/*.tsx',
+    '**/*.js',
+    '**/*.jsx',
+    '**/*.mjs',
+    '**/*.cjs',
+    '**/*.css',
+    '**/*.graphql',
+    '**/*.gql',
+    '**/*.graphqls',
+    '**/*.json',
+    '**/*.yaml',
+    '**/*.yml',
+    '**/*.html',
+    '**/*.htm',
+    '**/*.sh',
+    '**/*.bash',
+    '**/*.zsh',
+];
+// Default exclude patterns
+const DEFAULT_EXCLUDE = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/out/**',
+    '**/.git/**',
+    '**/.next/**',
+    '**/.nuxt/**',
+    '**/.svelte-kit/**',
+    '**/coverage/**',
+    '**/__pycache__/**',
+    '**/*.min.js',
+    '**/*.bundle.js',
+    '**/*.chunk.js',
+    '**/vendor/**',
+    '**/third_party/**',
+    '**/*.d.ts', // Declaration files excluded by default
+];
+// Valid languages for filter sanitization
+const VALID_LANGUAGES = new Set([
+    'typescript',
+    'tsx',
+    'javascript',
+    'jsx',
+    'css',
+    'graphql',
+    'json',
+    'yaml',
+    'html',
+    'bash',
+]);
+// Valid symbol types for filter sanitization
+const VALID_SYMBOL_TYPES = new Set([
+    'function',
+    'class',
+    'method',
+    'interface',
+    'type',
+    'variable',
+    'comment',
+    'file',
+]);
+/**
+ * Sanitize identifier for SQL WHERE clause.
+ */
+function sanitizeIdentifier(value) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
+        throw new Error(`Invalid identifier: ${value}`);
+    }
+    return value;
+}
+/**
+ * Sanitize path for SQL WHERE clause.
+ */
+function sanitizePath(value) {
+    return value.replace(/'/g, "''");
+}
+/**
+ * Execute function with index lock to prevent concurrent indexing.
+ */
+async function withIndexLock(lockDir, fn) {
+    const lockPath = path.join(lockDir, 'code_index.lock');
+    // Atomic lock acquisition via mkdir (throws EEXIST if already locked)
+    try {
+        mkdirSync(lockPath);
+    }
+    catch (err) {
+        if (err.code === 'EEXIST') {
+            // Lock exists - check if stale
+            try {
+                const stat = statSync(lockPath);
+                if (Date.now() - stat.mtimeMs > LOCK_TIMEOUT_MS) {
+                    // Stale lock - remove and retry once
+                    rmSync(lockPath, { recursive: true });
+                    mkdirSync(lockPath);
+                }
+                else {
+                    throw new Error('Code index is locked by another process');
+                }
+            }
+            catch (statErr) {
+                // Lock was removed between EEXIST and stat - retry
+                if (statErr.code === 'ENOENT') {
+                    mkdirSync(lockPath);
+                }
+                else {
+                    throw statErr;
+                }
+            }
+        }
+        else {
+            throw err;
+        }
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        rmSync(lockPath, { recursive: true, force: true });
+    }
+}
+/**
+ * CodeIndexer - indexes code files using Tree-sitter and LanceDB.
+ */
+export class CodeIndexer {
+    db = null;
+    chunksTable = null;
+    fileIndexTable = null;
+    initialized = false;
+    rootPath;
+    dbPath;
+    localStateDir;
+    metaPath;
+    gitignore = null;
+    wal;
+    walEnabled;
+    retryOptions;
+    parser;
+    graphIndexer = null;
+    treeIndexer = null;
+    // Injected dependencies
+    embeddingProvider;
+    rerankerProvider;
+    embeddingConfig;
+    rerankingConfig;
+    codeConfig;
+    codeFtsConfig;
+    lancedbStorageOptions;
+    // Unified SyncWal (optional - when provided, uses unified recovery)
+    syncWal = null;
+    constructor(rootPath, dbPath, deps, options = {}) {
+        this.rootPath = path.resolve(rootPath);
+        this.dbPath = dbPath;
+        this.localStateDir = options.localStateDir ?? dbPath;
+        this.metaPath = path.join(this.localStateDir, 'code_meta.json');
+        this.wal = new CodeIndexWal(this.localStateDir);
+        this.walEnabled = options.walEnabled ?? deps.codeConfig.wal?.enabled ?? true;
+        this.retryOptions = {
+            ...DEFAULT_EMBEDDING_RETRY,
+            ...deps.codeConfig.retry,
+            ...options.retryOptions,
+        };
+        this.parser = createTreeSitterParser();
+        if (deps.codeConfig.graph.enabled) {
+            this.graphIndexer = new GraphIndexer({
+                rootPath: this.rootPath,
+                dbPath: this.dbPath,
+                codeConfig: deps.codeConfig,
+                parser: this.parser,
+                storageOptions: deps.lancedbStorageOptions,
+            });
+        }
+        if (deps.codeConfig.tree?.enabled) {
+            this.treeIndexer = new TreeIndexer(this.rootPath, this.dbPath, deps.embeddingProvider, deps.embeddingProvider.getDimensions(), deps.codeConfig.tree, {
+                localStateDir: this.localStateDir,
+                lancedbStorageOptions: deps.lancedbStorageOptions,
+            });
+        }
+        // Store injected dependencies
+        this.embeddingProvider = deps.embeddingProvider;
+        this.rerankerProvider = deps.rerankerProvider ?? null;
+        this.embeddingConfig = deps.embeddingConfig;
+        this.rerankingConfig = deps.rerankingConfig ?? DEFAULT_RERANKING_CONFIG;
+        this.codeConfig = deps.codeConfig;
+        this.codeFtsConfig = deps.codeFtsConfig;
+        this.lancedbStorageOptions = deps.lancedbStorageOptions;
+        // Store unified SyncWal if provided
+        this.syncWal = deps.syncWal || null;
+    }
+    async loadMeta() {
+        try {
+            const content = await fs.readFile(this.metaPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveMeta() {
+        const modelName = this.embeddingProvider.getModelName();
+        const meta = {
+            model: modelName,
+            provider: this.embeddingConfig.provider,
+            dimensions: this.embeddingProvider.getDimensions(),
+            createdAt: Date.now(),
+        };
+        await fs.mkdir(path.dirname(this.metaPath), { recursive: true });
+        await fs.writeFile(this.metaPath, JSON.stringify(meta, null, 2));
+    }
+    /**
+     * Create file filter based on include/exclude patterns and .gitignore.
+     */
+    createFileFilter(options) {
+        const include = options.include || this.codeConfig.include || DEFAULT_INCLUDE;
+        const exclude = options.exclude || this.codeConfig.exclude || DEFAULT_EXCLUDE;
+        const maxFileSize = options.maxFileSize || this.codeConfig.maxFileSize || 1024 * 1024;
+        // Load .gitignore (always respected)
+        if (!this.gitignore) {
+            const ig = ignore();
+            const gitignorePath = path.join(this.rootPath, '.gitignore');
+            if (existsSync(gitignorePath)) {
+                try {
+                    const content = readFileSync(gitignorePath, 'utf8');
+                    ig.add(content);
+                }
+                catch {
+                    // Ignore errors reading .gitignore
+                }
+            }
+            this.gitignore = ig;
+        }
+        return (filePath) => {
+            const relativePath = path.relative(this.rootPath, filePath);
+            // 1. Must match at least one include pattern
+            const included = include.some((p) => minimatch(relativePath, p));
+            if (!included) {
+                return false;
+            }
+            // 2. Must not match any exclude pattern
+            if (exclude.some((p) => minimatch(relativePath, p))) {
+                return false;
+            }
+            // 3. Must not be in .gitignore
+            if (this.gitignore && this.gitignore.ignores(relativePath)) {
+                return false;
+            }
+            // 4. File size check is done at read time
+            return true;
+        };
+    }
+    /**
+     * Compute manifest hash from sorted file paths for recovery validation.
+     * Both notes and code use the same hash algorithm.
+     */
+    computeManifestHash(files) {
+        // Sort deterministically by path
+        const sortedPaths = files.map(f => path.relative(this.rootPath, f)).sort();
+        const content = sortedPaths.join('\n');
+        return crypto.createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * Initialize the indexer - connect to LanceDB and initialize parser.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // Ensure LanceDB directory exists
+        const isRemoteDbPath = /^[a-z][a-z0-9+.-]*:\/\//i.test(this.dbPath);
+        if (!isRemoteDbPath) {
+            await fs.mkdir(this.dbPath, { recursive: true });
+        }
+        // Connect to LanceDB
+        this.db = await lancedb.connect(this.dbPath, {
+            storageOptions: this.lancedbStorageOptions,
+        });
+        const tableNames = await this.db.tableNames();
+        // Check if embedding config changed
+        const meta = await this.loadMeta();
+        const currentModel = this.embeddingProvider.getModelName();
+        const currentDimensions = this.embeddingProvider.getDimensions();
+        const needsRecreate = meta && (meta.model !== currentModel ||
+            meta.provider !== this.embeddingConfig.provider ||
+            meta.dimensions !== currentDimensions);
+        if (needsRecreate) {
+            console.warn('[code-indexer] Embedding config changed, recreating index...');
+            console.warn(`  Previous: model=${meta.model}, provider=${meta.provider}, dimensions=${meta.dimensions}`);
+            console.warn(`  Current:  model=${currentModel}, provider=${this.embeddingConfig.provider}, dimensions=${currentDimensions}`);
+            // Drop tables if they exist
+            if (tableNames.includes('code_chunks')) {
+                await this.db.dropTable('code_chunks');
+            }
+            if (tableNames.includes('code_file_index')) {
+                await this.db.dropTable('code_file_index');
+            }
+            this.chunksTable = null;
+            this.fileIndexTable = null;
+        }
+        // Save current meta
+        await this.saveMeta();
+        // Open existing tables if they exist (and weren't dropped)
+        if (!this.chunksTable && (await this.db.tableNames()).includes('code_chunks')) {
+            this.chunksTable = await this.db.openTable('code_chunks');
+        }
+        if (!this.fileIndexTable && (await this.db.tableNames()).includes('code_file_index')) {
+            this.fileIndexTable = await this.db.openTable('code_file_index');
+        }
+        // Initialize Tree-sitter parser
+        await this.parser.initialize();
+        if (this.graphIndexer) {
+            await this.graphIndexer.initialize();
+        }
+        this.initialized = true;
+        // Auto-create all tables at startup
+        await this.ensureAllTables();
+    }
+    /**
+     * Ensure all code index tables exist with proper schema.
+     * Safe to call multiple times (idempotent).
+     */
+    async ensureAllTables() {
+        if (!this.initialized) {
+            await this.initialize();
+            return; // initialize() already called ensureAllTables()
+        }
+        await this.ensureChunksTable();
+        await this.ensureFileIndexTable();
+        if (this.graphIndexer) {
+            await this.graphIndexer.ensureAllTables();
+        }
+        if (this.treeIndexer) {
+            await this.treeIndexer.ensureAllTables();
+        }
+    }
+    /**
+     * Ensure code_chunks table exists.
+     */
+    async ensureChunksTable() {
+        if (this.chunksTable)
+            return this.chunksTable;
+        const dimensions = this.embeddingProvider.getDimensions();
+        // Create with sample data for schema inference (snake_case for SQL compatibility)
+        const sampleData = [
+            {
+                id: '__init__',
+                vector: new Array(dimensions).fill(0),
+                path: '',
+                language: '',
+                symbol_type: 'function',
+                symbol_name: '',
+                signature: '',
+                parent_symbol: '',
+                scope: '[]', // JSON array
+                content: '',
+                content_normalized: '',
+                start_line: 0,
+                end_line: 0,
+                docstring: '',
+                modified: 0,
+                content_hash: '',
+            },
+        ];
+        this.chunksTable = await this.db.createTable('code_chunks', sampleData, {
+            mode: 'overwrite',
+        });
+        // Delete the sample row
+        await this.chunksTable.delete("id = '__init__'");
+        return this.chunksTable;
+    }
+    /**
+     * Ensure code_file_index table exists.
+     */
+    async ensureFileIndexTable() {
+        if (this.fileIndexTable)
+            return this.fileIndexTable;
+        const sampleData = [
+            {
+                path: '__init__',
+                mtime: 0,
+                content_hash: '',
+                chunk_ids: '[]',
+                language: '',
+                indexed_at: 0,
+            },
+        ];
+        this.fileIndexTable = await this.db.createTable('code_file_index', sampleData, { mode: 'overwrite' });
+        // Delete the sample row
+        await this.fileIndexTable.delete("path = '__init__'");
+        return this.fileIndexTable;
+    }
+    getFtsColumn() {
+        return this.codeFtsConfig.normalizeIdentifiers ? 'content_normalized' : 'content';
+    }
+    async createOrUpdateFtsIndex() {
+        if (!this.codeFtsConfig.enabled) {
+            return;
+        }
+        const table = await this.ensureChunksTable();
+        const count = await table.countRows();
+        if (count === 0) {
+            return;
+        }
+        const columnToIndex = this.getFtsColumn();
+        const indexName = `${columnToIndex}_idx`;
+        const staleIndexName = `${columnToIndex === 'content' ? 'content_normalized' : 'content'}_idx`;
+        try {
+            const indices = await table.listIndices();
+            if (indices.some((index) => index.name === staleIndexName)) {
+                await table.dropIndex(staleIndexName);
+            }
+        }
+        catch (err) {
+            console.warn('[code-indexer] Could not inspect/drop stale FTS index:', err.message);
+        }
+        console.log(`[code-indexer] Creating/updating FTS index on ${columnToIndex} (${count} chunks)...`);
+        try {
+            await table.createIndex(columnToIndex, {
+                config: lancedb.Index.fts({
+                    withPosition: this.codeFtsConfig.withPosition,
+                    baseTokenizer: this.codeFtsConfig.baseTokenizer,
+                    stem: this.codeFtsConfig.stem,
+                    removeStopWords: this.codeFtsConfig.removeStopWords,
+                    ngramMinLength: this.codeFtsConfig.ngramMinLength,
+                    ngramMaxLength: this.codeFtsConfig.ngramMaxLength,
+                    prefixOnly: this.codeFtsConfig.prefixOnly,
+                }),
+                replace: true,
+            });
+            await table.waitForIndex([indexName], 60);
+            console.log('[code-indexer] FTS index created successfully');
+        }
+        catch (err) {
+            console.warn('[code-indexer] Could not create FTS index:', err.message);
+        }
+    }
+    normalizeSearchScores(results) {
+        if (results.length === 0)
+            return [];
+        const values = results.map((r) => r.score);
+        const min = Math.min(...values);
+        const max = Math.max(...values);
+        if (max === min)
+            return values.map(() => 1);
+        return values.map((v) => (v - min) / (max - min));
+    }
+    /**
+     * Get file record from index.
+     */
+    async getFileRecord(filePath) {
+        const table = await this.ensureFileIndexTable();
+        const results = await table
+            .query()
+            .where(`path = '${sanitizePath(filePath)}'`)
+            .toArray();
+        if (results.length === 0)
+            return null;
+        const r = results[0];
+        return {
+            path: r.path,
+            mtime: r.mtime,
+            content_hash: r.content_hash,
+            chunk_ids: r.chunk_ids,
+            language: r.language,
+            indexed_at: r.indexed_at,
+        };
+    }
+    getTreeDeps() {
+        return {
+            getSymbols: async (filePath) => this.getSymbolsForTree(filePath),
+            getFileRecord: async (filePath) => this.getCodeFileRecordForTree(filePath),
+        };
+    }
+    async getCodeFileRecordForTree(filePath) {
+        const record = await this.getFileRecord(filePath);
+        if (!record)
+            return null;
+        return {
+            mtime: record.mtime,
+            content_hash: record.content_hash,
+            language: record.language,
+        };
+    }
+    async getSymbolsForTree(filePath) {
+        const table = await this.ensureChunksTable();
+        const rows = await table
+            .query()
+            .where(`path = '${sanitizePath(filePath)}'`)
+            .toArray();
+        return rows.map((row) => ({
+            id: row.id,
+            path: row.path,
+            language: row.language,
+            symbolType: row.symbol_type,
+            symbolName: row.symbol_name,
+            signature: row.signature || null,
+            parentSymbol: row.parent_symbol || null,
+            scope: JSON.parse(row.scope || '[]'),
+            content: row.content,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            docstring: row.docstring || null,
+            modified: row.modified,
+            contentHash: row.content_hash,
+        }));
+    }
+    /**
+     * Get all indexed file paths.
+     */
+    async getAllIndexedPaths() {
+        const table = await this.ensureFileIndexTable();
+        const results = await table.query().select(['path']).toArray();
+        return new Set(results.map((r) => r.path));
+    }
+    /**
+     * Update file index record.
+     */
+    async updateFileIndex(filePath, mtime, contentHash, chunkIds, language) {
+        const table = await this.ensureFileIndexTable();
+        // Delete existing record if any
+        await table.delete(`path = '${sanitizePath(filePath)}'`);
+        // Insert new record
+        await table.add([
+            {
+                path: filePath,
+                mtime,
+                content_hash: contentHash,
+                chunk_ids: JSON.stringify(chunkIds),
+                language,
+                indexed_at: Date.now(),
+            },
+        ]);
+    }
+    /**
+     * Remove file from index.
+     */
+    async removeFromFileIndex(filePath) {
+        const table = await this.ensureFileIndexTable();
+        await table.delete(`path = '${sanitizePath(filePath)}'`);
+    }
+    /**
+     * Delete chunks by IDs.
+     */
+    async deleteChunks(chunkIds) {
+        if (chunkIds.length === 0)
+            return;
+        const table = await this.ensureChunksTable();
+        for (const id of chunkIds) {
+            await table.delete(`id = '${id}'`);
+        }
+    }
+    /**
+     * Delete all chunks for a file path.
+     */
+    async deleteChunksForPath(filePath) {
+        const table = await this.ensureChunksTable();
+        await table.delete(`path = '${sanitizePath(filePath)}'`);
+    }
+    /**
+     * Index a single code chunk with retry logic.
+     */
+    async indexChunk(chunk) {
+        const table = await this.ensureChunksTable();
+        // Build embedding text
+        const embeddingText = buildEmbeddingText(chunk);
+        // Get embedding with retry
+        let embedding;
+        try {
+            embedding = await withRetry(async () => {
+                const result = await this.embeddingProvider.getEmbedding(embeddingText, 'document');
+                if (isError(result)) {
+                    throw new Error(result.message);
+                }
+                return result;
+            }, this.retryOptions);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return createError('EMBEDDING_ERROR', error.message);
+        }
+        // Check if chunk exists
+        const existing = await table
+            .query()
+            .where(`id = '${chunk.id}'`)
+            .toArray();
+        if (existing.length > 0 && existing[0].content_hash === chunk.contentHash) {
+            return chunk.id; // No changes needed
+        }
+        // Delete existing if present
+        if (existing.length > 0) {
+            await table.delete(`id = '${chunk.id}'`);
+        }
+        // Insert new chunk using snake_case for SQL compatibility
+        const record = toChunkRecord(chunk, embedding, this.codeFtsConfig.normalizeIdentifiers);
+        await table.add([record]);
+        return chunk.id;
+    }
+    /**
+     * Index multiple chunks in batch - much faster than indexChunk() one by one.
+     * Uses batch embedding for efficiency with retry logic.
+     *
+     * @param chunks - Array of chunks to index
+     * @param batchSize - Embedding batch size (default: 32)
+     * @param onEmbeddingProgress - Optional callback for embedding progress
+     * @returns Array of indexed chunk IDs and any errors
+     */
+    async indexChunksBatch(chunks, batchSize = 32, onEmbeddingProgress) {
+        if (chunks.length === 0) {
+            return { chunkIds: [], errors: [] };
+        }
+        const table = await this.ensureChunksTable();
+        const chunkIds = [];
+        const errors = [];
+        // Build embedding texts for all chunks
+        const embeddingTexts = chunks.map((chunk) => buildEmbeddingText(chunk));
+        // Get all embeddings in batch with retry logic
+        let embeddings;
+        try {
+            embeddings = await withRetry(async () => {
+                const result = await this.embeddingProvider.getEmbeddingsBatch(embeddingTexts, batchSize, 'document', onEmbeddingProgress);
+                if (isError(result)) {
+                    throw new Error(result.message);
+                }
+                return result;
+            }, this.retryOptions);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            return { chunkIds: [], errors: [createError('EMBEDDING_ERROR', error.message)] };
+        }
+        // Build records for batch insert (snake_case for SQL compatibility)
+        const records = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            const embedding = embeddings[i];
+            records.push(toChunkRecord(chunk, embedding, this.codeFtsConfig.normalizeIdentifiers));
+            chunkIds.push(chunk.id);
+        }
+        // Batch insert all records
+        if (records.length > 0) {
+            await table.add(records);
+        }
+        return { chunkIds, errors };
+    }
+    /**
+     * Parse a single file and return chunks without indexing.
+     * Used for batch processing.
+     */
+    async parseFile(filePath, options = {}) {
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.rootPath, filePath);
+        const relativePath = path.relative(this.rootPath, absolutePath);
+        try {
+            // Check file size
+            const stat = await fs.stat(absolutePath);
+            const maxSize = options.maxFileSize || this.codeConfig.maxFileSize || 1024 * 1024;
+            if (stat.size > maxSize) {
+                return createError('FILE_TOO_LARGE', `File exceeds max size: ${relativePath}`);
+            }
+            // Read file content
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const fileHash = generateContentHash(content);
+            // Detect language
+            const langKey = this.parser.getLanguageForFile(absolutePath);
+            if (!langKey) {
+                return createError('UNKNOWN_LANGUAGE', `Unknown file type: ${relativePath}`);
+            }
+            // Get extractor
+            const extractor = languageRegistry.getExtractor(langKey);
+            if (!extractor) {
+                return createError('NO_EXTRACTOR', `No extractor for language: ${langKey}`);
+            }
+            // Parse file
+            const tree = await this.parser.parse(content, langKey);
+            try {
+                // Extract symbols
+                const symbolsWithDetails = extractor.extractSymbols(tree, content, relativePath);
+                const symbols = symbolsWithDetails.map((s) => ({
+                    name: s.name,
+                    type: s.type,
+                    startLine: s.startLine,
+                    endLine: s.endLine,
+                    node: s.node,
+                }));
+                // Convert to chunks
+                const minLines = options.minLines || this.codeConfig.chunking?.minLines || 3;
+                const maxLines = options.maxLines || this.codeConfig.chunking?.maxLines || 100;
+                const chunks = symbolsToChunks(symbols, relativePath, content, langKey, stat.mtimeMs, { minLines, maxLines });
+                // Add metadata from extractor
+                // Match by symbolName + startLine since symbolsToChunks filters by minLines
+                const detailsMap = new Map(symbolsWithDetails.map(d => [`${d.name}:${d.startLine}`, d]));
+                for (const chunk of chunks) {
+                    if (chunk.symbolType === 'file')
+                        continue; // Skip file chunks
+                    const details = detailsMap.get(`${chunk.symbolName}:${chunk.startLine}`);
+                    if (details) {
+                        chunk.signature = details.signature;
+                        chunk.docstring = details.docstring;
+                        chunk.parentSymbol = details.parentSymbol;
+                        chunk.scope = details.scope;
+                    }
+                }
+                applyStableChunkIds(chunks);
+                // Add file-level chunk
+                const includeFileChunks = options.includeFileChunks ?? this.codeConfig.chunking?.includeFileChunks ?? true;
+                if (includeFileChunks) {
+                    const fileChunk = createFileChunk(relativePath, content, langKey, stat.mtimeMs);
+                    chunks.unshift(fileChunk);
+                }
+                return { chunks, fileHash, mtime: stat.mtimeMs, language: langKey };
+            }
+            finally {
+                this.parser.deleteTree(tree);
+            }
+        }
+        catch (err) {
+            return createError('PARSE_FILE_ERROR', `Failed to parse ${relativePath}`, {
+                error: err.message,
+            });
+        }
+    }
+    /**
+     * Index a single file with WAL support.
+     */
+    async indexFile(filePath, options = {}, batchId) {
+        await this.initialize();
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.rootPath, filePath);
+        const relativePath = path.relative(this.rootPath, absolutePath);
+        const chunkIds = [];
+        const errors = [];
+        // Write WAL start entry
+        if (this.walEnabled) {
+            await this.wal.start(relativePath, batchId);
+        }
+        try {
+            // Check file size
+            const stat = await fs.stat(absolutePath);
+            const maxSize = options.maxFileSize || this.codeConfig.maxFileSize || 1024 * 1024;
+            if (stat.size > maxSize) {
+                const err = createError('FILE_TOO_LARGE', `File exceeds max size: ${relativePath}`);
+                if (this.walEnabled) {
+                    const retryCount = await this.wal.getRetryCount(relativePath);
+                    await this.wal.fail(relativePath, err.message, retryCount + 1);
+                }
+                return { chunkIds, errors: [err] };
+            }
+            // Read file content
+            const content = await fs.readFile(absolutePath, 'utf-8');
+            const fileHash = generateContentHash(content);
+            // Detect language
+            const langKey = this.parser.getLanguageForFile(absolutePath);
+            if (!langKey) {
+                const err = createError('UNKNOWN_LANGUAGE', `Unknown file type: ${relativePath}`);
+                if (this.walEnabled) {
+                    const retryCount = await this.wal.getRetryCount(relativePath);
+                    await this.wal.fail(relativePath, err.message, retryCount + 1);
+                }
+                return { chunkIds, errors: [err] };
+            }
+            // Get extractor for this language
+            const extractor = languageRegistry.getExtractor(langKey);
+            if (!extractor) {
+                const err = createError('NO_EXTRACTOR', `No extractor for language: ${langKey}`);
+                if (this.walEnabled) {
+                    const retryCount = await this.wal.getRetryCount(relativePath);
+                    await this.wal.fail(relativePath, err.message, retryCount + 1);
+                }
+                return { chunkIds, errors: [err] };
+            }
+            // Parse file
+            const tree = await this.parser.parse(content, langKey);
+            try {
+                // Extract symbols using language-specific extractor
+                const symbolsWithDetails = extractor.extractSymbols(tree, content, relativePath);
+                // Convert to base ExtractedSymbol format for chunker
+                const symbols = symbolsWithDetails.map((s) => ({
+                    name: s.name,
+                    type: s.type,
+                    startLine: s.startLine,
+                    endLine: s.endLine,
+                    node: s.node,
+                }));
+                // Convert symbols to chunks
+                const minLines = options.minLines || this.codeConfig.chunking?.minLines || 3;
+                const maxLines = options.maxLines || this.codeConfig.chunking?.maxLines || 100;
+                const chunks = symbolsToChunks(symbols, relativePath, content, langKey, stat.mtimeMs, { minLines, maxLines });
+                // Add detailed metadata from extractor to chunks
+                // Match by symbolName + startLine since symbolsToChunks filters by minLines
+                const detailsMap = new Map(symbolsWithDetails.map(d => [`${d.name}:${d.startLine}`, d]));
+                for (const chunk of chunks) {
+                    if (chunk.symbolType === 'file')
+                        continue; // Skip file chunks
+                    const details = detailsMap.get(`${chunk.symbolName}:${chunk.startLine}`);
+                    if (details) {
+                        chunk.signature = details.signature;
+                        chunk.docstring = details.docstring;
+                        chunk.parentSymbol = details.parentSymbol;
+                        chunk.scope = details.scope;
+                    }
+                }
+                applyStableChunkIds(chunks);
+                // Optionally add file-level chunk
+                const includeFileChunks = options.includeFileChunks ?? this.codeConfig.chunking?.includeFileChunks ?? true;
+                if (includeFileChunks) {
+                    const fileChunk = createFileChunk(relativePath, content, langKey, stat.mtimeMs);
+                    chunks.unshift(fileChunk);
+                }
+                // Delete old chunks for this file
+                await this.deleteChunksForPath(relativePath);
+                // Index all chunks
+                for (const chunk of chunks) {
+                    const result = await this.indexChunk(chunk);
+                    if (isError(result)) {
+                        errors.push(result);
+                    }
+                    else {
+                        chunkIds.push(result);
+                    }
+                }
+                // Update file index
+                await this.updateFileIndex(relativePath, stat.mtimeMs, fileHash, chunkIds, langKey);
+                if (this.graphIndexer) {
+                    await this.graphIndexer.updateFiles([relativePath]);
+                }
+                if (this.treeIndexer) {
+                    await this.treeIndexer.upsertFile(relativePath, this.getTreeDeps());
+                }
+                // Write WAL done entry
+                if (this.walEnabled) {
+                    await this.wal.done(relativePath, chunkIds.length);
+                }
+            }
+            finally {
+                // Always delete tree to prevent memory leaks
+                this.parser.deleteTree(tree);
+            }
+        }
+        catch (err) {
+            const error = createError('INDEX_FILE_ERROR', `Failed to index ${relativePath}`, {
+                error: err.message,
+            });
+            errors.push(error);
+            // Write WAL fail entry
+            if (this.walEnabled) {
+                const retryCount = await this.wal.getRetryCount(relativePath);
+                await this.wal.fail(relativePath, err.message, retryCount + 1);
+            }
+        }
+        return { chunkIds, errors };
+    }
+    /**
+     * Reindex all files in root path.
+     * Uses batch processing for much faster performance with WAL support.
+     */
+    async reindexAll(options = {}) {
+        await this.initialize();
+        return withIndexLock(this.localStateDir, async () => {
+            const filter = this.createFileFilter(options);
+            const include = options.include || this.codeConfig.include || DEFAULT_INCLUDE;
+            // Find all matching files
+            const patterns = include.map((p) => path.join(this.rootPath, p));
+            let files = [];
+            for (const pattern of patterns) {
+                const matches = await glob(pattern, {
+                    ignore: options.exclude || this.codeConfig.exclude || DEFAULT_EXCLUDE,
+                    nodir: true,
+                });
+                files.push(...matches);
+            }
+            // Deduplicate and filter
+            files = [...new Set(files)].filter(filter);
+            // Generate batch ID for WAL
+            const batchId = crypto.randomUUID();
+            const relativePaths = files.map(f => path.relative(this.rootPath, f));
+            // Write batch start to WAL
+            if (this.walEnabled) {
+                await this.wal.batchStart(batchId, relativePaths);
+            }
+            let indexed = 0;
+            let skipped = 0;
+            let deleted = 0;
+            let failed = 0;
+            const errors = [];
+            // Track current file paths
+            const currentPaths = new Set();
+            const indexedPaths = await this.getAllIndexedPaths();
+            const filesToIndex = [];
+            const pathsToDelete = [];
+            for (const file of files) {
+                const relativePath = path.relative(this.rootPath, file);
+                currentPaths.add(relativePath);
+                // Write file start to WAL
+                if (this.walEnabled) {
+                    await this.wal.start(relativePath, batchId);
+                }
+                try {
+                    const stat = await fs.stat(file);
+                    // Check if file needs reindexing
+                    const existingRecord = await this.getFileRecord(relativePath);
+                    if (existingRecord && existingRecord.mtime === stat.mtimeMs) {
+                        skipped++;
+                        // Mark as done (skipped = no change)
+                        if (this.walEnabled) {
+                            await this.wal.done(relativePath, 0);
+                        }
+                        continue;
+                    }
+                    // Read and check content hash
+                    const content = await fs.readFile(file, 'utf-8');
+                    const fileHash = generateContentHash(content);
+                    if (existingRecord && existingRecord.content_hash === fileHash) {
+                        // Content unchanged, just update mtime
+                        await this.updateFileIndex(relativePath, stat.mtimeMs, fileHash, JSON.parse(existingRecord.chunk_ids), existingRecord.language);
+                        skipped++;
+                        // Mark as done
+                        if (this.walEnabled) {
+                            await this.wal.done(relativePath, 0);
+                        }
+                        continue;
+                    }
+                    // File changed - parse it (but don't index yet)
+                    const parseResult = await this.parseFile(file, options);
+                    if (isError(parseResult)) {
+                        errors.push(parseResult);
+                        failed++;
+                        if (this.walEnabled) {
+                            const retryCount = await this.wal.getRetryCount(relativePath);
+                            await this.wal.fail(relativePath, parseResult.message, retryCount + 1);
+                        }
+                        continue;
+                    }
+                    // Collect old chunks for deletion
+                    if (existingRecord) {
+                        pathsToDelete.push(relativePath);
+                    }
+                    filesToIndex.push({
+                        relativePath,
+                        chunks: parseResult.chunks,
+                        fileHash: parseResult.fileHash,
+                        mtime: parseResult.mtime,
+                        language: parseResult.language,
+                    });
+                }
+                catch (err) {
+                    const error = createError('INDEX_FILE_ERROR', `Failed to parse ${relativePath}`, {
+                        error: err.message,
+                    });
+                    errors.push(error);
+                    failed++;
+                    if (this.walEnabled) {
+                        const retryCount = await this.wal.getRetryCount(relativePath);
+                        await this.wal.fail(relativePath, err.message, retryCount + 1);
+                    }
+                }
+            }
+            // Phase 2: Delete old chunks for files that will be reindexed
+            for (const pathToDelete of pathsToDelete) {
+                await this.deleteChunksForPath(pathToDelete);
+            }
+            // Phase 3: Batch index all chunks
+            if (filesToIndex.length > 0) {
+                // Collect all chunks from all files
+                const allChunks = [];
+                const chunkToFileMap = new Map();
+                for (const fileResult of filesToIndex) {
+                    const startIdx = allChunks.length;
+                    allChunks.push(...fileResult.chunks);
+                    // Map chunk indices to file for later file index update
+                    for (let i = startIdx; i < allChunks.length; i++) {
+                        chunkToFileMap.set(i, fileResult);
+                    }
+                }
+                // Batch index all chunks at once (larger batch = fewer API calls)
+                const batchResult = await this.indexChunksBatch(allChunks, 128);
+                indexed = batchResult.chunkIds.length;
+                errors.push(...batchResult.errors);
+                // Update file indices and write WAL done entries
+                const fileChunkIds = new Map();
+                for (let i = 0; i < batchResult.chunkIds.length; i++) {
+                    const fileResult = chunkToFileMap.get(i);
+                    if (fileResult) {
+                        const ids = fileChunkIds.get(fileResult.relativePath) || [];
+                        ids.push(batchResult.chunkIds[i]);
+                        fileChunkIds.set(fileResult.relativePath, ids);
+                    }
+                }
+                for (const fileResult of filesToIndex) {
+                    const chunkIds = fileChunkIds.get(fileResult.relativePath) || [];
+                    await this.updateFileIndex(fileResult.relativePath, fileResult.mtime, fileResult.fileHash, chunkIds, fileResult.language);
+                    // Write WAL done entry for each file
+                    if (this.walEnabled) {
+                        await this.wal.done(fileResult.relativePath, chunkIds.length);
+                    }
+                }
+            }
+            // Phase 4: Handle deleted files
+            for (const indexedPath of indexedPaths) {
+                if (!currentPaths.has(indexedPath)) {
+                    const record = await this.getFileRecord(indexedPath);
+                    if (record) {
+                        const chunkIds = JSON.parse(record.chunk_ids);
+                        await this.deleteChunks(chunkIds);
+                        await this.removeFromFileIndex(indexedPath);
+                        deleted++;
+                    }
+                }
+            }
+            // Write batch done to WAL
+            if (this.walEnabled) {
+                await this.wal.batchDone(batchId, { indexed, failed });
+                // Compact WAL after successful batch
+                await this.wal.compact();
+            }
+            await this.createOrUpdateFtsIndex();
+            if (this.graphIndexer) {
+                await this.graphIndexer.indexAll();
+            }
+            if (this.treeIndexer) {
+                await this.treeIndexer.buildTree(this.getTreeDeps());
+            }
+            return { indexed, skipped, deleted, errors };
+        });
+    }
+    /**
+     * Reindex all files using unified SyncWal for recovery.
+     * Uses offset-based recovery (deterministic file ordering).
+     *
+     * @param recovery Optional recovery plan from SyncWal
+     * @returns IndexResult with counts
+     */
+    async reindexAllWithSyncWal(recovery) {
+        if (!this.syncWal) {
+            throw new Error('SyncWal not provided - use reindexAll() instead');
+        }
+        await this.initialize();
+        const filter = this.createFileFilter({});
+        const include = this.codeConfig.include || DEFAULT_INCLUDE;
+        // Find all matching files
+        const patterns = include.map((p) => path.join(this.rootPath, p));
+        let files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                ignore: this.codeConfig.exclude || DEFAULT_EXCLUDE,
+                nodir: true,
+            });
+            files.push(...matches);
+        }
+        // Deduplicate, filter, and sort deterministically
+        files = [...new Set(files)].filter(filter).sort((a, b) => a.localeCompare(b));
+        // Compute manifest hash for recovery validation
+        const manifestHash = this.computeManifestHash(files);
+        // Validate recovery plan
+        let skipCount = 0;
+        if (recovery) {
+            if (recovery.manifestHash === manifestHash) {
+                skipCount = recovery.skipCount;
+                console.log(`[code-indexer] Resuming from file ${skipCount}/${files.length}`);
+            }
+            else {
+                // Files changed since crash — full reindex
+                console.warn('[code-indexer] Manifest hash mismatch, starting full reindex');
+            }
+        }
+        // Start task (acquires lock, starts heartbeat)
+        const taskId = await this.syncWal.startTask('code', files.length, manifestHash);
+        let indexed = 0;
+        let skipped = 0;
+        let deleted = 0;
+        const errors = [];
+        // Track current file paths
+        const currentPaths = new Set();
+        const indexedPaths = await this.getAllIndexedPaths();
+        const filesToIndex = [];
+        const pathsToDelete = [];
+        try {
+            for (let i = skipCount; i < files.length; i++) {
+                // Check cancellation
+                if (this.syncWal.isCancelled(taskId)) {
+                    await this.syncWal.cancelTask(taskId);
+                    return { indexed, skipped, deleted, errors };
+                }
+                // Check pause - wait until resumed or cancelled
+                const shouldContinue = await this.syncWal.waitWhilePaused(taskId);
+                if (!shouldContinue) {
+                    // Cancelled while paused
+                    await this.syncWal.cancelTask(taskId);
+                    return { indexed, skipped, deleted, errors };
+                }
+                const file = files[i];
+                const relativePath = path.relative(this.rootPath, file);
+                currentPaths.add(relativePath);
+                try {
+                    const stat = await fs.stat(file);
+                    // Check if file needs reindexing
+                    const existingRecord = await this.getFileRecord(relativePath);
+                    if (existingRecord && existingRecord.mtime === stat.mtimeMs) {
+                        skipped++;
+                        await this.syncWal.fileProcessed(taskId, relativePath, 0, 'updated');
+                        continue;
+                    }
+                    // Read and check content hash
+                    const content = await fs.readFile(file, 'utf-8');
+                    const fileHash = generateContentHash(content);
+                    if (existingRecord && existingRecord.content_hash === fileHash) {
+                        // Content unchanged, just update mtime
+                        await this.updateFileIndex(relativePath, stat.mtimeMs, fileHash, JSON.parse(existingRecord.chunk_ids), existingRecord.language);
+                        skipped++;
+                        await this.syncWal.fileProcessed(taskId, relativePath, 0, 'updated');
+                        continue;
+                    }
+                    // File changed - parse it
+                    const parseResult = await this.parseFile(file, {});
+                    if (isError(parseResult)) {
+                        errors.push(parseResult);
+                        await this.syncWal.fileFailed(taskId, relativePath, parseResult.message, 0);
+                        continue;
+                    }
+                    // Collect old chunks for deletion
+                    if (existingRecord) {
+                        pathsToDelete.push(relativePath);
+                    }
+                    filesToIndex.push({
+                        relativePath,
+                        chunks: parseResult.chunks,
+                        fileHash: parseResult.fileHash,
+                        mtime: parseResult.mtime,
+                        language: parseResult.language,
+                    });
+                }
+                catch (err) {
+                    const error = createError('INDEX_FILE_ERROR', `Failed to parse ${relativePath}`, {
+                        error: err.message,
+                    });
+                    errors.push(error);
+                    await this.syncWal.fileFailed(taskId, relativePath, err.message, 0);
+                }
+            }
+            // Phase 2: Delete old chunks for files that will be reindexed
+            this.syncWal.setPhase('deleting');
+            for (const pathToDelete of pathsToDelete) {
+                await this.deleteChunksForPath(pathToDelete);
+            }
+            // Phase 3: Batch index all chunks
+            this.syncWal.setPhase('indexing');
+            if (filesToIndex.length > 0) {
+                const allChunks = [];
+                const chunkToFileMap = new Map();
+                for (const fileResult of filesToIndex) {
+                    const startIdx = allChunks.length;
+                    allChunks.push(...fileResult.chunks);
+                    for (let i = startIdx; i < allChunks.length; i++) {
+                        chunkToFileMap.set(i, fileResult);
+                    }
+                }
+                // Batch index with embedding progress callback
+                const embeddingProgressCallback = this.syncWal?.getEmbeddingProgressCallback();
+                const batchResult = await this.indexChunksBatch(allChunks, 128, embeddingProgressCallback);
+                indexed = batchResult.chunkIds.length;
+                errors.push(...batchResult.errors);
+                // Update file indices
+                const fileChunkIds = new Map();
+                for (let i = 0; i < batchResult.chunkIds.length; i++) {
+                    const fileResult = chunkToFileMap.get(i);
+                    if (fileResult) {
+                        const ids = fileChunkIds.get(fileResult.relativePath) || [];
+                        ids.push(batchResult.chunkIds[i]);
+                        fileChunkIds.set(fileResult.relativePath, ids);
+                    }
+                }
+                for (const fileResult of filesToIndex) {
+                    const chunkIds = fileChunkIds.get(fileResult.relativePath) || [];
+                    await this.updateFileIndex(fileResult.relativePath, fileResult.mtime, fileResult.fileHash, chunkIds, fileResult.language);
+                    await this.syncWal.fileProcessed(taskId, fileResult.relativePath, chunkIds.length, 'added');
+                }
+            }
+            // Phase 4: Handle deleted files
+            for (const indexedPath of indexedPaths) {
+                if (!currentPaths.has(indexedPath)) {
+                    const record = await this.getFileRecord(indexedPath);
+                    if (record) {
+                        const chunkIds = JSON.parse(record.chunk_ids);
+                        await this.deleteChunks(chunkIds);
+                        await this.removeFromFileIndex(indexedPath);
+                        deleted++;
+                    }
+                }
+            }
+            await this.createOrUpdateFtsIndex();
+            // Run graph/tree indexing (blocking to ensure completion before sync:completed)
+            if (this.graphIndexer) {
+                console.log('[code-indexer] starting graphIndexer.indexAll()');
+                this.syncWal.setPhase('graph');
+                await this.graphIndexer.indexAll(undefined, {
+                    onProgress: (current, total, phase) => {
+                        this.syncWal?.emitSubPhaseProgress(current, total, `graph:${phase}`);
+                    },
+                });
+                console.log('[code-indexer] graphIndexer.indexAll() done');
+            }
+            if (this.treeIndexer) {
+                console.log('[code-indexer] starting treeIndexer.buildTree()');
+                this.syncWal.setPhase('tree');
+                await this.treeIndexer.buildTree(this.getTreeDeps(), {
+                    onProgress: (current, total, phase) => {
+                        this.syncWal?.emitSubPhaseProgress(current, total, `tree:${phase}`);
+                    },
+                });
+                console.log('[code-indexer] treeIndexer.buildTree() done');
+            }
+            // Complete task AFTER all indexing is done
+            await this.syncWal.completeTask(taskId);
+        }
+        catch (err) {
+            // Task failed
+            await this.syncWal.failTask(taskId, err.message);
+            throw err;
+        }
+        return { indexed, skipped, deleted, errors };
+    }
+    async rebuildFtsIndex() {
+        await this.initialize();
+        await this.createOrUpdateFtsIndex();
+    }
+    /**
+     * Set the SyncWal instance for unified recovery.
+     * Should be called when SyncWal is created after CodeIndexer construction.
+     */
+    setSyncWal(syncWal) {
+        this.syncWal = syncWal;
+    }
+    /**
+     * Get the SyncWal instance.
+     */
+    getSyncWal() {
+        return this.syncWal;
+    }
+    /**
+     * Check if SyncWal is configured.
+     */
+    hasSyncWal() {
+        return this.syncWal !== null;
+    }
+    /**
+     * Search code by semantic query.
+     */
+    async search(query, options = {}) {
+        await this.initialize();
+        const { limit = 10, threshold = 0.5, language, symbolTypes, path: pathFilter, rerank = true, } = options;
+        const table = await this.ensureChunksTable();
+        // Check if table has data
+        const count = await table.countRows();
+        if (count === 0) {
+            return [];
+        }
+        // Get query embedding (use 'query' type for Voyage AI asymmetric search)
+        const queryEmbedding = await this.embeddingProvider.getEmbedding(query, 'query');
+        if (isError(queryEmbedding)) {
+            return queryEmbedding;
+        }
+        const useReranking = Boolean(rerank &&
+            this.rerankerProvider &&
+            this.rerankingConfig.enabled &&
+            this.rerankingConfig.provider !== 'none');
+        const fetchLimit = useReranking
+            ? Math.max(this.rerankingConfig.topK, limit)
+            : limit * 2;
+        const vectorThreshold = useReranking
+            ? this.rerankingConfig.prerankThreshold
+            : threshold;
+        // Build search query
+        let searchQuery = table.search(queryEmbedding).limit(fetchLimit);
+        // Apply filters
+        const filters = [];
+        if (language) {
+            const lang = sanitizeIdentifier(language);
+            if (!VALID_LANGUAGES.has(lang)) {
+                return createError('INVALID_LANGUAGE', `Unknown language: ${lang}`);
+            }
+            filters.push(`language = '${lang}'`);
+        }
+        if (symbolTypes && symbolTypes.length > 0) {
+            const validTypes = symbolTypes
+                .map((t) => sanitizeIdentifier(t))
+                .filter((t) => VALID_SYMBOL_TYPES.has(t));
+            if (validTypes.length === 0) {
+                return createError('INVALID_SYMBOL_TYPES', 'No valid symbol types provided');
+            }
+            const types = validTypes.map((t) => `'${t}'`).join(', ');
+            filters.push(`symbol_type IN (${types})`);
+        }
+        if (pathFilter) {
+            const safePath = sanitizePath(pathFilter);
+            filters.push(`path LIKE '${safePath}%'`);
+        }
+        if (filters.length > 0) {
+            searchQuery = searchQuery.where(filters.join(' AND '));
+        }
+        const results = await searchQuery.toArray();
+        // Convert L2 distance to cosine similarity, filter and deduplicate
+        const processed = [];
+        const seenContentHashes = new Set();
+        for (const r of results) {
+            const distance = r._distance;
+            // For normalized vectors: L2^2 = 2(1 - cos_sim)
+            const score = 1 - distance / 2;
+            if (score < vectorThreshold)
+                continue;
+            // Deduplicate by content_hash (same code in file chunk and symbol chunk)
+            const contentHash = r.content_hash;
+            if (seenContentHashes.has(contentHash))
+                continue;
+            seenContentHashes.add(contentHash);
+            const result = fromChunkRecord(r);
+            result.score = score;
+            processed.push(result);
+            if (processed.length >= fetchLimit)
+                break;
+        }
+        if (processed.length === 0) {
+            return [];
+        }
+        if (useReranking && processed.length >= 5 && this.rerankerProvider) {
+            try {
+                if (!this.rerankerProvider.isInitialized()) {
+                    await this.rerankerProvider.initialize();
+                }
+                const documents = processed.map((item) => item.content);
+                const reranked = await this.rerankerProvider.rerank(query, documents, {
+                    topK: limit,
+                });
+                if (!isError(reranked)) {
+                    const rerankedResults = reranked
+                        .filter((rr) => rr.index >= 0 && rr.index < processed.length)
+                        .map((rr) => ({
+                        ...processed[rr.index],
+                        score: rr.score,
+                        _originalScore: processed[rr.index].score,
+                    }))
+                        .filter((result) => result.score >= threshold);
+                    return rerankedResults.slice(0, limit);
+                }
+                console.warn('[code-indexer] Reranking failed, using vector scores:', reranked.message);
+            }
+            catch (error) {
+                console.warn('[code-indexer] Reranking error, falling back to vector scores:', error);
+            }
+        }
+        return processed
+            .filter((result) => result.score >= threshold)
+            .slice(0, limit);
+    }
+    async searchFts(options) {
+        await this.initialize();
+        const query = options.query.trim();
+        if (!query) {
+            return createError('INVALID_QUERY', 'Query must not be empty');
+        }
+        const table = await this.ensureChunksTable();
+        const count = await table.countRows();
+        if (count === 0) {
+            return [];
+        }
+        const limit = options.limit ?? 10;
+        const ftsColumn = this.getFtsColumn();
+        const phraseQuery = options.phraseMatch
+            ? new PhraseQuery(query, ftsColumn, { slop: options.phraseSlop ?? 0 })
+            : null;
+        const fuzzyQuery = options.fuzziness !== undefined
+            ? new MatchQuery(query, ftsColumn, { fuzziness: options.fuzziness })
+            : null;
+        let ftsQuery = query;
+        if (phraseQuery && fuzzyQuery) {
+            ftsQuery = new BooleanQuery([
+                [Occur.Should, phraseQuery],
+                [Occur.Should, fuzzyQuery],
+            ]);
+        }
+        else if (phraseQuery) {
+            ftsQuery = phraseQuery;
+        }
+        else if (fuzzyQuery) {
+            ftsQuery = fuzzyQuery;
+        }
+        let searchQuery = table.search(ftsQuery, 'fts', ftsColumn).limit(limit);
+        const filters = [];
+        if (options.language) {
+            const lang = sanitizeIdentifier(options.language);
+            if (!VALID_LANGUAGES.has(lang)) {
+                return createError('INVALID_LANGUAGE', `Unknown language: ${lang}`);
+            }
+            filters.push(`language = '${lang}'`);
+        }
+        if (options.symbolTypes && options.symbolTypes.length > 0) {
+            const validTypes = options.symbolTypes
+                .map((t) => sanitizeIdentifier(t))
+                .filter((t) => VALID_SYMBOL_TYPES.has(t));
+            if (validTypes.length === 0) {
+                return createError('INVALID_SYMBOL_TYPES', 'No valid symbol types provided');
+            }
+            const types = validTypes.map((t) => `'${t}'`).join(', ');
+            filters.push(`symbol_type IN (${types})`);
+        }
+        const pathFilter = options.path
+            ? buildPathPrefixFilter('path', options.path)
+            : null;
+        const whereClause = combineFilters([...filters, pathFilter]);
+        if (whereClause) {
+            searchQuery = searchQuery.where(whereClause);
+        }
+        const rows = await searchQuery.toArray();
+        const results = [];
+        for (const row of rows) {
+            const result = fromChunkRecord(row);
+            const ftsScore = typeof row._score === 'number' ? row._score : undefined;
+            const fallbackScore = typeof row._distance === 'number'
+                ? 1 - row._distance / 2
+                : 1;
+            result.score = ftsScore ?? fallbackScore;
+            results.push(result);
+        }
+        return results;
+    }
+    async searchHybrid(options) {
+        const query = options.query.trim();
+        if (!query) {
+            return createError('INVALID_QUERY', 'Query must not be empty');
+        }
+        const limit = options.limit ?? 10;
+        const threshold = options.threshold ?? 0.5;
+        const semanticLimit = options.semanticLimit ?? Math.max(limit * 3, 20);
+        const ftsLimit = options.ftsLimit ?? Math.max(limit * 3, 20);
+        const vectorWeight = options.vectorWeight ?? 0.55;
+        const ftsWeight = options.ftsWeight ?? 0.45;
+        const rerankEnabled = options.rerank ?? true;
+        const [semanticResults, ftsResults] = await Promise.all([
+            this.search(query, {
+                limit: semanticLimit,
+                threshold: 0,
+                language: options.language,
+                symbolTypes: options.symbolTypes,
+                path: options.path,
+                rerank: false,
+            }),
+            this.searchFts({
+                query,
+                limit: ftsLimit,
+                fuzziness: options.fuzziness,
+                phraseMatch: options.phraseMatch,
+                phraseSlop: options.phraseSlop,
+                language: options.language,
+                symbolTypes: options.symbolTypes,
+                path: options.path,
+            }),
+        ]);
+        if (isError(semanticResults))
+            return semanticResults;
+        if (isError(ftsResults))
+            return ftsResults;
+        if (semanticResults.length === 0 && ftsResults.length === 0)
+            return [];
+        const semanticNorm = this.normalizeSearchScores(semanticResults);
+        const ftsNorm = this.normalizeSearchScores(ftsResults);
+        const merged = new Map();
+        for (let i = 0; i < semanticResults.length; i++) {
+            const item = semanticResults[i];
+            const existing = merged.get(item.id);
+            if (existing) {
+                existing.vector = Math.max(existing.vector, semanticNorm[i] ?? 0);
+            }
+            else {
+                merged.set(item.id, { item, vector: semanticNorm[i] ?? 0, fts: 0 });
+            }
+        }
+        for (let i = 0; i < ftsResults.length; i++) {
+            const item = ftsResults[i];
+            const existing = merged.get(item.id);
+            if (existing) {
+                existing.fts = Math.max(existing.fts, ftsNorm[i] ?? 0);
+            }
+            else {
+                merged.set(item.id, { item, vector: 0, fts: ftsNorm[i] ?? 0 });
+            }
+        }
+        const fused = Array.from(merged.values())
+            .map(({ item, vector, fts }) => {
+            const overlapBoost = vector > 0 && fts > 0 ? 0.05 : 0;
+            const score = Math.min(1, vectorWeight * vector + ftsWeight * fts + overlapBoost);
+            return { ...item, score };
+        })
+            .sort((a, b) => b.score - a.score);
+        const useReranking = Boolean(rerankEnabled &&
+            this.rerankerProvider &&
+            this.rerankingConfig.enabled &&
+            this.rerankingConfig.provider !== 'none');
+        if (useReranking && fused.length >= 5 && this.rerankerProvider) {
+            try {
+                if (!this.rerankerProvider.isInitialized()) {
+                    await this.rerankerProvider.initialize();
+                }
+                const candidateLimit = Math.max(this.rerankingConfig.topK, limit);
+                const candidates = fused.slice(0, candidateLimit);
+                const reranked = await this.rerankerProvider.rerank(query, candidates.map((c) => c.content), { topK: limit });
+                if (!isError(reranked)) {
+                    return reranked
+                        .filter((rr) => rr.index >= 0 && rr.index < candidates.length)
+                        .map((rr) => ({
+                        ...candidates[rr.index],
+                        score: rr.score,
+                        _originalScore: candidates[rr.index].score,
+                    }))
+                        .filter((result) => result.score >= threshold)
+                        .slice(0, limit);
+                }
+                console.warn('[code-indexer] Hybrid reranking failed, using fused scores:', reranked.message);
+            }
+            catch (error) {
+                console.warn('[code-indexer] Hybrid reranking error, using fused scores:', error);
+            }
+        }
+        return fused
+            .filter((result) => result.score >= threshold)
+            .slice(0, limit);
+    }
+    /**
+     * Find symbols by name pattern (exact match or wildcard).
+     */
+    async findSymbols(name, options = {}) {
+        await this.initialize();
+        const { type, path: pathFilter, limit = 20 } = options;
+        const table = await this.ensureChunksTable();
+        // Check if table has data
+        const count = await table.countRows();
+        if (count === 0) {
+            return [];
+        }
+        // Build filters
+        const filters = [];
+        // Handle wildcard in name
+        if (name.includes('*')) {
+            const sqlPattern = name.replace(/\*/g, '%');
+            filters.push(`symbol_name LIKE '${sanitizePath(sqlPattern)}'`);
+        }
+        else {
+            filters.push(`symbol_name = '${sanitizePath(name)}'`);
+        }
+        if (type && type !== 'all') {
+            const validType = sanitizeIdentifier(type);
+            if (!VALID_SYMBOL_TYPES.has(validType)) {
+                return createError('INVALID_SYMBOL_TYPE', `Unknown symbol type: ${type}`);
+            }
+            filters.push(`symbol_type = '${validType}'`);
+        }
+        if (pathFilter) {
+            // Normalize path separators to match stored paths
+            const normalizedPath = pathFilter.replace(/\\/g, '/');
+            filters.push(`path LIKE '${sanitizePath(normalizedPath)}%'`);
+        }
+        // Query with filters
+        let query = table.query().where(filters.join(' AND '));
+        query = query.limit(limit);
+        const results = await query.toArray();
+        return results.map((r) => fromChunkRecord(r));
+    }
+    /**
+     * Remove a file from the index.
+     */
+    async removeFile(filePath) {
+        await this.initialize();
+        const relativePath = path.isAbsolute(filePath)
+            ? path.relative(this.rootPath, filePath)
+            : filePath;
+        const record = await this.getFileRecord(relativePath);
+        if (record) {
+            const chunkIds = JSON.parse(record.chunk_ids);
+            await this.deleteChunks(chunkIds);
+            await this.removeFromFileIndex(relativePath);
+        }
+        else {
+            // Fallback: delete by path
+            await this.deleteChunksForPath(relativePath);
+        }
+        if (this.graphIndexer) {
+            await this.graphIndexer.removeFile(relativePath);
+        }
+        if (this.treeIndexer) {
+            await this.treeIndexer.removeFile(relativePath);
+        }
+    }
+    /**
+     * Clear all code index data.
+     */
+    async clear() {
+        await this.initialize();
+        if (this.chunksTable) {
+            await this.db.dropTable('code_chunks');
+            this.chunksTable = null;
+        }
+        if (this.fileIndexTable) {
+            await this.db.dropTable('code_file_index');
+            this.fileIndexTable = null;
+        }
+        if (this.graphIndexer) {
+            await this.graphIndexer.clear();
+        }
+        if (this.treeIndexer) {
+            await this.treeIndexer.clear();
+        }
+    }
+    /**
+     * Get index statistics.
+     */
+    async getStats() {
+        await this.initialize();
+        const chunksTable = await this.ensureChunksTable();
+        const fileTable = await this.ensureFileIndexTable();
+        const totalChunks = await chunksTable.countRows();
+        const totalFiles = await fileTable.countRows();
+        // Count by language
+        const fileRecords = await fileTable.query().select(['language']).toArray();
+        const languages = {};
+        for (const r of fileRecords) {
+            const lang = r.language;
+            languages[lang] = (languages[lang] || 0) + 1;
+        }
+        return { totalChunks, totalFiles, languages };
+    }
+    /**
+     * Get set of indexed file paths for quick lookup.
+     */
+    async getIndexedFilePaths() {
+        await this.initialize();
+        const fileTable = await this.ensureFileIndexTable();
+        const records = await fileTable.query().select(['path']).toArray();
+        return new Set(records.map(r => r.path));
+    }
+    /**
+     * Returns true when code graph indexing is configured.
+     */
+    hasGraphIndexer() {
+        return this.graphIndexer !== null;
+    }
+    /**
+     * Returns true when tree indexing is configured.
+     */
+    hasTreeIndexer() {
+        return this.treeIndexer !== null;
+    }
+    /**
+     * Access tree indexer for tree retrieval tools.
+     */
+    getTreeIndexer() {
+        return this.treeIndexer;
+    }
+    /**
+     * Rebuild tree index from existing code index data.
+     * Useful when tree tables are missing/corrupted while code chunks already exist.
+     */
+    async rebuildTreeIndex() {
+        await this.initialize();
+        if (!this.treeIndexer) {
+            throw new Error('Tree index is not enabled');
+        }
+        const stats = await this.treeIndexer.buildTree(this.getTreeDeps());
+        return {
+            totalDirs: stats.totalDirs,
+            totalFiles: stats.totalFiles,
+            maxDepth: stats.maxDepth,
+            buildTimeMs: stats.buildTimeMs,
+        };
+    }
+    /**
+     * Ensure tree index is queryable.
+     * Auto-recovers when root dir is missing or tree has never been indexed.
+     */
+    async ensureTreeIndexReady() {
+        await this.initialize();
+        if (!this.treeIndexer) {
+            throw new Error('Tree index is not enabled');
+        }
+        const [rootDir, freshness] = await Promise.all([
+            this.treeIndexer.getDirByPath(''),
+            Promise.resolve(this.treeIndexer.getFreshnessInfo()),
+        ]);
+        if (!rootDir || freshness.indexed_at === 0) {
+            await this.treeIndexer.buildTree(this.getTreeDeps());
+        }
+    }
+    /**
+     * Prepare graph data in-memory without embedding calls and without graph DB writes.
+     * Useful for fast validation on different codebases.
+     */
+    async codeGraphPrepare(quality = this.codeConfig.graph.quality, options = {}) {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            throw new Error('Code graph indexing is not enabled');
+        }
+        const filter = this.createFileFilter(options);
+        const include = options.include || this.codeConfig.include || DEFAULT_INCLUDE;
+        let files = [];
+        for (const pattern of include.map((p) => path.join(this.rootPath, p))) {
+            const matches = await glob(pattern, {
+                ignore: options.exclude || this.codeConfig.exclude || DEFAULT_EXCLUDE,
+                nodir: true,
+            });
+            files.push(...matches);
+        }
+        files = [...new Set(files)].filter(filter).sort((a, b) => a.localeCompare(b));
+        const chunksByFile = new Map();
+        const parseErrors = [];
+        for (const file of files) {
+            const parseResult = await this.parseFile(file, options);
+            if (isError(parseResult)) {
+                parseErrors.push(parseResult);
+                continue;
+            }
+            const relativePath = path.relative(this.rootPath, file).replace(/\\/g, '/');
+            for (const chunk of parseResult.chunks) {
+                chunk.path = chunk.path.replace(/\\/g, '/');
+            }
+            chunksByFile.set(relativePath, parseResult.chunks);
+        }
+        const prepared = await this.graphIndexer.prepareGraph(quality, chunksByFile);
+        return {
+            ...prepared,
+            parseErrors,
+        };
+    }
+    /**
+     * Build full code graph index.
+     */
+    async codeGraphIndex(quality) {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            throw new Error('Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.indexAll(quality);
+    }
+    /**
+     * Incremental code graph update.
+     */
+    async codeGraphUpdate() {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            throw new Error('Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.incrementalUpdate();
+    }
+    /**
+     * Code graph statistics.
+     */
+    async codeGraphInfo() {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            throw new Error('Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.getStats();
+    }
+    /**
+     * Find references to a symbol using graph edges.
+     */
+    async graphRefs(input) {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            return createError('GRAPH_DISABLED', 'Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.graphRefs(input);
+    }
+    /**
+     * Build callers/callees graph for a symbol.
+     */
+    async graphCalls(input) {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            return createError('GRAPH_DISABLED', 'Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.graphCalls(input);
+    }
+    /**
+     * Resolve import dependency graph for a file.
+     */
+    async graphDeps(input) {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            return createError('GRAPH_DISABLED', 'Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.graphDeps(input);
+    }
+    /**
+     * Build class/interface hierarchy graph.
+     */
+    async graphHierarchy(input) {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            return createError('GRAPH_DISABLED', 'Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.graphHierarchy(input);
+    }
+    /**
+     * Export graph edges as DOT or JSON.
+     */
+    async codeGraphExport(format = 'json') {
+        await this.initialize();
+        if (!this.graphIndexer) {
+            throw new Error('Code graph indexing is not enabled');
+        }
+        return this.graphIndexer.exportGraph(format);
+    }
+    // ========================================
+    // WAL methods
+    // ========================================
+    /**
+     * Get WAL status (pending files, failed files, etc.)
+     */
+    async getWalStatus() {
+        return this.wal.getStatus();
+    }
+    /**
+     * Get recovery plan from legacy WAL.
+     */
+    async getRecoveryPlan() {
+        return this.wal.recover();
+    }
+    /**
+     * Recover from interrupted indexing using WAL.
+     * Re-indexes pending and failed files.
+     *
+     * @param maxRetries - Max retries per file for failed files
+     * @returns Result with counts of recovered files
+     */
+    async recover(maxRetries = 3) {
+        await this.initialize();
+        const plan = await this.wal.recover();
+        let pending = 0;
+        let retried = 0;
+        let failed = 0;
+        const errors = [];
+        // Re-index pending files (interrupted during indexing)
+        for (const filePath of plan.pending) {
+            console.log(`[code-indexer] Recovering pending file: ${filePath}`);
+            const result = await this.indexFile(filePath);
+            if (result.errors.length > 0) {
+                errors.push(...result.errors);
+                failed++;
+            }
+            else {
+                pending++;
+            }
+        }
+        // Retry failed files (if under max retries)
+        for (const failedFile of plan.failed) {
+            if (failedFile.retryCount >= maxRetries) {
+                console.log(`[code-indexer] Skipping ${failedFile.path} (max retries reached: ${failedFile.retryCount})`);
+                failed++;
+                continue;
+            }
+            console.log(`[code-indexer] Retrying failed file: ${failedFile.path} (attempt ${failedFile.retryCount + 1})`);
+            const result = await this.indexFile(failedFile.path);
+            if (result.errors.length > 0) {
+                errors.push(...result.errors);
+                failed++;
+            }
+            else {
+                retried++;
+            }
+        }
+        // Handle incomplete batch
+        if (plan.incompleteBatch && plan.incompleteBatchFiles.length > 0) {
+            console.log(`[code-indexer] Recovering incomplete batch: ${plan.incompleteBatch}`);
+            console.log(`[code-indexer] Files to recover: ${plan.incompleteBatchFiles.length}`);
+            for (const filePath of plan.incompleteBatchFiles) {
+                const result = await this.indexFile(filePath);
+                if (result.errors.length > 0) {
+                    errors.push(...result.errors);
+                    failed++;
+                }
+                else {
+                    pending++;
+                }
+            }
+        }
+        // Compact WAL after recovery
+        await this.wal.compact();
+        const needsTreeReconcile = this.treeIndexer && (plan.pending.length > 0 ||
+            plan.failed.length > 0 ||
+            plan.incompleteBatch !== null);
+        if (needsTreeReconcile && this.treeIndexer) {
+            await this.treeIndexer.reconcileAfterWalRecovery(this.getTreeDeps());
+        }
+        return { pending, retried, failed, errors };
+    }
+    /**
+     * Retry failed files from WAL.
+     *
+     * @param maxRetries - Max total retries per file
+     * @returns Result with counts
+     */
+    async retryFailed(maxRetries = 3) {
+        await this.initialize();
+        const plan = await this.wal.recover();
+        let retried = 0;
+        let skipped = 0;
+        const errors = [];
+        for (const failedFile of plan.failed) {
+            if (failedFile.retryCount >= maxRetries) {
+                console.log(`[code-indexer] Skipping ${failedFile.path} (max retries: ${failedFile.retryCount})`);
+                skipped++;
+                continue;
+            }
+            console.log(`[code-indexer] Retrying: ${failedFile.path} (attempt ${failedFile.retryCount + 1})`);
+            const result = await this.indexFile(failedFile.path);
+            if (result.errors.length > 0) {
+                errors.push(...result.errors);
+            }
+            else {
+                retried++;
+            }
+        }
+        // Compact WAL after retry
+        await this.wal.compact();
+        if (this.treeIndexer && retried > 0) {
+            await this.treeIndexer.reconcileAfterWalRecovery(this.getTreeDeps());
+        }
+        return { retried, skipped, errors };
+    }
+    /**
+     * Compact the WAL file.
+     */
+    async compactWal() {
+        return this.wal.compact();
+    }
+    /**
+     * Clear the WAL file.
+     */
+    async clearWal() {
+        return this.wal.clear();
+    }
+    /**
+     * Check if WAL exists.
+     */
+    walExists() {
+        return this.wal.exists();
+    }
+    /**
+     * Get the root path.
+     */
+    getRootPath() {
+        return this.rootPath;
+    }
+    /**
+     * Get the database path.
+     */
+    getDbPath() {
+        return this.dbPath;
+    }
+}
+// Export withIndexLock for testing
+export { withIndexLock };
+// Factory function
+export function createCodeIndexer(rootPath, dbPath, deps, options) {
+    return new CodeIndexer(rootPath, dbPath, deps, options);
+}
+//# sourceMappingURL=index.js.map