grepmind-core 0.1.0-alpha

package/dist/indexer/code/tree/index.js

@@ -0,0 +1,1146 @@
+import * as lancedb from '@lancedb/lancedb';
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import commonAncestorPath from 'common-ancestor-path';
+import { createError, isError } from '../../../types.js';
+import { TreeBuilder } from './builder.js';
+import { TreeContextExpander } from './context.js';
+import { computeFileCentroid, topKeySymbols } from './embedding.js';
+import { generateTreeId } from './id.js';
+import { RepoMapCache, TreeCache } from './cache.js';
+import { generateRepoMap } from './repomap.js';
+function sanitizeSql(value) {
+    return value.replace(/'/g, "''");
+}
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+function pathDir(filePath) {
+    const dir = path.dirname(filePath);
+    return dir === '.' ? '' : normalizePath(dir);
+}
+function pathBase(filePath) {
+    return path.basename(filePath);
+}
+function pathExt(filePath) {
+    return path.extname(filePath).replace('.', '').toLowerCase();
+}
+function toNumberVector(value) {
+    if (!value)
+        return undefined;
+    const sanitize = (arr) => {
+        const out = arr.map((x) => {
+            const n = Number(x);
+            return Number.isFinite(n) ? n : 0;
+        });
+        return out.length > 0 ? out : undefined;
+    };
+    if (Array.isArray(value)) {
+        return sanitize(value);
+    }
+    if (ArrayBuffer.isView(value) && Symbol.iterator in value) {
+        return sanitize(Array.from(value));
+    }
+    if (typeof value === 'object') {
+        const vectorLike = value;
+        if (typeof vectorLike.length === 'number' && typeof vectorLike.get === 'function') {
+            const out = [];
+            for (let i = 0; i < vectorLike.length; i++) {
+                const n = Number(vectorLike.get(i));
+                out.push(Number.isFinite(n) ? n : 0);
+            }
+            return out.length > 0 ? out : undefined;
+        }
+    }
+    return undefined;
+}
+function parseDirRecord(row) {
+    return {
+        id: row.id,
+        path: row.path,
+        name: row.name,
+        parent_id: (row.parent_id || '') || null,
+        depth: row.depth,
+        file_count: row.file_count,
+        dir_count: row.dir_count,
+        total_files: row.total_files,
+        total_symbols: row.total_symbols,
+        modified: row.modified,
+        indexed_at: row.indexed_at,
+    };
+}
+function parseFileRecord(row) {
+    return {
+        id: row.id,
+        previous_id: row.previous_id || undefined,
+        path: row.path,
+        name: row.name,
+        dir_id: row.dir_id,
+        ext: row.ext,
+        language: row.language,
+        size: row.size,
+        content_hash: row.content_hash,
+        symbol_count: row.symbol_count,
+        import_count: row.import_count,
+        export_count: row.export_count,
+        modified: row.modified,
+        indexed_at: row.indexed_at,
+        vector: toNumberVector(row.vector),
+        key_symbols: row.key_symbols || '[]',
+        import_specs: row.import_specs || '[]',
+    };
+}
+export class TreeIndexer {
+    db = null;
+    treeDirsTable = null;
+    treeFilesTable = null;
+    codeChunksTable = null;
+    codeFileIndexTable = null;
+    initialized = false;
+    rootPath;
+    dbPath;
+    localStateDir;
+    treeConfig;
+    embeddingProvider;
+    embeddingDimensions;
+    lancedbStorageOptions;
+    dirCache = new TreeCache(1000, 60_000);
+    fileCache = new TreeCache(1000, 60_000);
+    repoMapCache = new RepoMapCache(10);
+    metaPath;
+    meta = {
+        dirty: false,
+        indexVersion: 0,
+        updatedAt: 0,
+        indexedAt: 0,
+    };
+    constructor(rootPath, dbPath, embeddingProvider, embeddingDimensions, treeConfig, options = {}) {
+        this.rootPath = path.resolve(rootPath);
+        this.dbPath = dbPath;
+        this.localStateDir = options.localStateDir ?? dbPath;
+        this.treeConfig = treeConfig;
+        this.embeddingProvider = embeddingProvider;
+        this.embeddingDimensions = embeddingDimensions;
+        this.lancedbStorageOptions = options.lancedbStorageOptions;
+        this.metaPath = path.join(this.localStateDir, 'tree_meta.json');
+    }
+    getRootDirId() {
+        return generateTreeId('');
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        const isRemoteDbPath = /^[a-z][a-z0-9+.-]*:\/\//i.test(this.dbPath);
+        if (!isRemoteDbPath) {
+            await fs.mkdir(this.dbPath, { recursive: true });
+        }
+        await fs.mkdir(this.localStateDir, { recursive: true });
+        this.db = await lancedb.connect(this.dbPath, {
+            storageOptions: this.lancedbStorageOptions,
+        });
+        const tableNames = await this.db.tableNames();
+        if (tableNames.includes('tree_dirs')) {
+            this.treeDirsTable = await this.db.openTable('tree_dirs');
+        }
+        if (tableNames.includes('tree_files')) {
+            this.treeFilesTable = await this.db.openTable('tree_files');
+        }
+        if (tableNames.includes('code_chunks')) {
+            this.codeChunksTable = await this.db.openTable('code_chunks');
+        }
+        if (tableNames.includes('code_file_index')) {
+            this.codeFileIndexTable = await this.db.openTable('code_file_index');
+        }
+        this.meta = await this.loadMeta();
+        this.initialized = true;
+        await this.ensureAllTables();
+    }
+    async ensureAllTables() {
+        if (!this.initialized) {
+            await this.initialize();
+            return;
+        }
+        await this.ensureTreeDirsTable();
+        await this.ensureTreeFilesTable();
+    }
+    async ensureTreeDirsTable() {
+        if (this.treeDirsTable)
+            return this.treeDirsTable;
+        const sampleData = [
+            {
+                id: '__init__',
+                path: '',
+                name: '',
+                parent_id: '',
+                depth: 0,
+                file_count: 0,
+                dir_count: 0,
+                total_files: 0,
+                total_symbols: 0,
+                modified: 0,
+                indexed_at: 0,
+            },
+        ];
+        this.treeDirsTable = await this.db.createTable('tree_dirs', sampleData, { mode: 'overwrite' });
+        await this.treeDirsTable.delete("id = '__init__'");
+        return this.treeDirsTable;
+    }
+    async ensureTreeFilesTable() {
+        if (this.treeFilesTable)
+            return this.treeFilesTable;
+        const sampleData = [
+            {
+                id: '__init__',
+                previous_id: '',
+                path: '',
+                name: '',
+                dir_id: '',
+                ext: '',
+                language: '',
+                size: 0,
+                content_hash: '',
+                symbol_count: 0,
+                import_count: 0,
+                export_count: 0,
+                modified: 0,
+                indexed_at: 0,
+                vector: new Array(this.embeddingDimensions).fill(0),
+                key_symbols: '[]',
+                import_specs: '[]',
+            },
+        ];
+        this.treeFilesTable = await this.db.createTable('tree_files', sampleData, { mode: 'overwrite' });
+        await this.treeFilesTable.delete("id = '__init__'");
+        return this.treeFilesTable;
+    }
+    async loadMeta() {
+        if (!existsSync(this.metaPath)) {
+            return {
+                dirty: false,
+                indexVersion: 0,
+                updatedAt: 0,
+                indexedAt: 0,
+            };
+        }
+        try {
+            const content = await fs.readFile(this.metaPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            return {
+                dirty: Boolean(parsed.dirty),
+                indexVersion: Number.isFinite(parsed.indexVersion) ? parsed.indexVersion : 0,
+                updatedAt: Number.isFinite(parsed.updatedAt) ? parsed.updatedAt : 0,
+                indexedAt: Number.isFinite(parsed.indexedAt) ? parsed.indexedAt : 0,
+            };
+        }
+        catch {
+            return {
+                dirty: false,
+                indexVersion: 0,
+                updatedAt: 0,
+                indexedAt: 0,
+            };
+        }
+    }
+    async saveMeta() {
+        await fs.writeFile(this.metaPath, JSON.stringify(this.meta, null, 2), 'utf-8');
+    }
+    async setDirty(dirty) {
+        this.meta.dirty = dirty;
+        this.meta.updatedAt = Date.now();
+        await this.saveMeta();
+    }
+    async touchTreeVersion() {
+        this.meta.indexVersion += 1;
+        this.meta.indexedAt = Date.now();
+        this.meta.updatedAt = this.meta.indexedAt;
+        this.repoMapCache.incrementVersion();
+        await this.saveMeta();
+    }
+    getFreshnessInfo() {
+        const indexedAt = this.meta.indexedAt;
+        const isStale = this.meta.dirty || indexedAt === 0 || (Date.now() - indexedAt > this.treeConfig.staleAfterMs);
+        return {
+            indexVersion: this.meta.indexVersion,
+            indexed_at: indexedAt,
+            isStale,
+            staleReason: this.meta.dirty ? 'wal_recovery_pending' : (isStale ? 'unknown' : undefined),
+        };
+    }
+    async ensureCodeChunksTable() {
+        if (this.codeChunksTable)
+            return this.codeChunksTable;
+        const names = await this.db.tableNames();
+        if (!names.includes('code_chunks'))
+            return null;
+        this.codeChunksTable = await this.db.openTable('code_chunks');
+        return this.codeChunksTable;
+    }
+    async ensureCodeFileIndexTable() {
+        if (this.codeFileIndexTable)
+            return this.codeFileIndexTable;
+        const names = await this.db.tableNames();
+        if (!names.includes('code_file_index'))
+            return null;
+        this.codeFileIndexTable = await this.db.openTable('code_file_index');
+        return this.codeFileIndexTable;
+    }
+    async listIndexedPaths() {
+        const table = await this.ensureCodeFileIndexTable();
+        if (!table)
+            return [];
+        const rows = await table.query().select(['path']).toArray();
+        return rows.map((row) => normalizePath(row.path));
+    }
+    async upsertDir(dir, indexedAt) {
+        const table = await this.ensureTreeDirsTable();
+        await table.delete(`id = '${sanitizeSql(dir.id)}'`);
+        await table.add([
+            {
+                id: dir.id,
+                path: dir.path,
+                name: dir.name,
+                parent_id: dir.parent_id ?? '',
+                depth: dir.depth,
+                file_count: dir.file_count,
+                dir_count: dir.dir_count,
+                total_files: dir.total_files,
+                total_symbols: dir.total_symbols,
+                modified: dir.modified,
+                indexed_at: indexedAt,
+            },
+        ]);
+        this.dirCache.set(dir.id, { ...dir, indexed_at: indexedAt });
+    }
+    async upsertTreeFile(file) {
+        const table = await this.ensureTreeFilesTable();
+        await table.delete(`id = '${sanitizeSql(file.id)}'`);
+        await table.add([
+            {
+                id: file.id,
+                previous_id: file.previous_id ?? '',
+                path: file.path,
+                name: file.name,
+                dir_id: file.dir_id,
+                ext: file.ext,
+                language: file.language,
+                size: file.size,
+                content_hash: file.content_hash,
+                symbol_count: file.symbol_count,
+                import_count: file.import_count,
+                export_count: file.export_count,
+                modified: file.modified,
+                indexed_at: file.indexed_at,
+                vector: file.vector ?? new Array(this.embeddingDimensions).fill(0),
+                key_symbols: file.key_symbols ?? '[]',
+                import_specs: file.import_specs ?? '[]',
+            },
+        ]);
+        this.fileCache.set(file.id, file);
+    }
+    async ensureDirChain(dirPath) {
+        const normalizedDirPath = normalizePath(dirPath);
+        const parts = normalizedDirPath.split('/').filter(Boolean);
+        let current = '';
+        const now = Date.now();
+        const rootId = this.getRootDirId();
+        const rootExists = await this.getDirById(rootId);
+        if (!rootExists) {
+            await this.upsertDir({
+                id: rootId,
+                path: '',
+                name: '',
+                parent_id: null,
+                depth: 0,
+                file_count: 0,
+                dir_count: 0,
+                total_files: 0,
+                total_symbols: 0,
+                modified: 0,
+            }, now);
+        }
+        for (let i = 0; i < parts.length; i++) {
+            current = current ? `${current}/${parts[i]}` : parts[i];
+            const id = generateTreeId(current);
+            const existing = await this.getDirById(id);
+            if (existing)
+                continue;
+            const parentPath = i === 0 ? '' : parts.slice(0, i).join('/');
+            await this.upsertDir({
+                id,
+                path: current,
+                name: parts[i],
+                parent_id: generateTreeId(parentPath),
+                depth: i + 1,
+                file_count: 0,
+                dir_count: 0,
+                total_files: 0,
+                total_symbols: 0,
+                modified: 0,
+            }, now);
+        }
+    }
+    async loadBuildFile(pathValue, deps) {
+        const relativePath = normalizePath(pathValue);
+        const [record, symbols] = await Promise.all([
+            deps.getFileRecord(relativePath),
+            deps.getSymbols(relativePath),
+        ]);
+        if (!record)
+            return null;
+        const size = symbols.reduce((sum, symbol) => sum + Buffer.byteLength(symbol.content, 'utf-8'), 0);
+        const symbolCount = symbols.filter((symbol) => symbol.symbolType !== 'file').length;
+        return {
+            path: relativePath,
+            language: record.language,
+            content_hash: record.content_hash,
+            modified: record.mtime,
+            size,
+            symbol_count: symbolCount,
+            import_count: 0,
+            export_count: 0,
+        };
+    }
+    async buildTree(deps, options = {}) {
+        const { onProgress } = options;
+        await this.initialize();
+        await this.setDirty(true);
+        const indexedPaths = await this.listIndexedPaths();
+        const buildInputs = [];
+        // Phase 1: Loading files
+        for (let i = 0; i < indexedPaths.length; i++) {
+            const item = await this.loadBuildFile(indexedPaths[i], deps);
+            if (item)
+                buildInputs.push(item);
+            onProgress?.(i + 1, indexedPaths.length, 'loading');
+        }
+        // Phase 2: Building tree structure
+        onProgress?.(0, 1, 'building');
+        const builder = new TreeBuilder(this.rootPath);
+        const build = await builder.build(buildInputs);
+        onProgress?.(1, 1, 'building');
+        const dirsTable = await this.ensureTreeDirsTable();
+        const filesTable = await this.ensureTreeFilesTable();
+        await dirsTable.delete("id != '__never__'");
+        await filesTable.delete("id != '__never__'");
+        // Phase 3: Indexing dirs and files
+        const totalItems = build.dirs.length + build.files.length;
+        let processed = 0;
+        const indexedAt = Date.now();
+        for (const dir of build.dirs) {
+            await this.upsertDir(dir, indexedAt);
+            processed++;
+            onProgress?.(processed, totalItems, 'indexing');
+        }
+        // Phase 3b: Indexing files with embeddings
+        for (let i = 0; i < build.files.length; i++) {
+            const file = build.files[i];
+            const symbols = await deps.getSymbols(file.path);
+            const enriched = await this.enrichFileEmbedding(file, symbols);
+            await this.upsertTreeFile(enriched);
+            processed++;
+            // Report as indexing for dirs, embedding for files (includes vector computation)
+            onProgress?.(processed, totalItems, this.treeConfig.embedFiles ? 'embedding' : 'indexing');
+        }
+        // Phase 4: Rebuilding directory stats
+        onProgress?.(0, build.dirs.length, 'stats');
+        await this.rebuildDirStats();
+        onProgress?.(build.dirs.length, build.dirs.length, 'stats');
+        await this.touchTreeVersion();
+        await this.setDirty(false);
+        return {
+            totalDirs: build.stats.totalDirs,
+            totalFiles: build.stats.total_files,
+            maxDepth: build.stats.maxDepth,
+            buildTimeMs: build.stats.buildTimeMs,
+        };
+    }
+    async enrichFileEmbedding(file, symbols) {
+        if (!this.treeConfig.embedFiles) {
+            return {
+                ...file,
+                key_symbols: JSON.stringify(topKeySymbols(symbols, 5)),
+            };
+        }
+        const symbolsWithVectors = await this.getSymbolVectors(file.path);
+        const vector = computeFileCentroid(symbolsWithVectors.map((s) => ({ vector: s.vector, type: s.type })));
+        return {
+            ...file,
+            vector: vector.length > 0 ? vector : undefined,
+            key_symbols: JSON.stringify(topKeySymbols(symbols, 5)),
+        };
+    }
+    async getSymbolVectors(filePath) {
+        const table = await this.ensureCodeChunksTable();
+        if (!table)
+            return [];
+        const rows = await table
+            .query()
+            .where(`path = '${sanitizeSql(filePath)}'`)
+            .select(['vector', 'symbol_type'])
+            .toArray();
+        const vectors = [];
+        for (const row of rows) {
+            const vector = toNumberVector(row.vector);
+            if (!vector || vector.length === 0)
+                continue;
+            const type = row.symbol_type;
+            vectors.push({ vector, type });
+        }
+        return vectors;
+    }
+    async upsertFile(filePath, deps) {
+        await this.initialize();
+        await this.setDirty(true);
+        const normalized = normalizePath(filePath);
+        const [record, symbols] = await Promise.all([
+            deps.getFileRecord(normalized),
+            deps.getSymbols(normalized),
+        ]);
+        if (!record) {
+            await this.setDirty(false);
+            return;
+        }
+        const dirPath = pathDir(normalized);
+        await this.ensureDirChain(dirPath);
+        const file = {
+            id: generateTreeId(normalized),
+            path: normalized,
+            name: pathBase(normalized),
+            dir_id: generateTreeId(dirPath),
+            ext: pathExt(normalized),
+            language: record.language,
+            size: symbols.reduce((sum, symbol) => sum + Buffer.byteLength(symbol.content, 'utf-8'), 0),
+            content_hash: record.content_hash,
+            symbol_count: symbols.filter((symbol) => symbol.symbolType !== 'file').length,
+            import_count: 0,
+            export_count: 0,
+            modified: record.mtime,
+            indexed_at: Date.now(),
+            key_symbols: '[]',
+            import_specs: '[]',
+        };
+        const enriched = await this.enrichFileEmbedding(file, symbols);
+        await this.upsertTreeFile(enriched);
+        await this.rebuildDirStats();
+        await this.touchTreeVersion();
+        await this.setDirty(false);
+    }
+    async removeFile(filePath) {
+        await this.initialize();
+        await this.setDirty(true);
+        const normalized = normalizePath(filePath);
+        const fileId = generateTreeId(normalized);
+        const table = await this.ensureTreeFilesTable();
+        await table.delete(`id = '${sanitizeSql(fileId)}'`);
+        this.fileCache.delete(fileId);
+        await this.rebuildDirStats();
+        await this.touchTreeVersion();
+        await this.setDirty(false);
+    }
+    async handleFileBatch(changes, deps) {
+        await this.initialize();
+        const result = {
+            success: 0,
+            failed: 0,
+            warnings: [],
+        };
+        await this.setDirty(true);
+        for (const deleted of changes.deleted) {
+            try {
+                await this.removeFile(deleted);
+                result.success += 1;
+            }
+            catch (error) {
+                result.failed += 1;
+                result.warnings.push(`remove failed: ${deleted}: ${error.message}`);
+            }
+        }
+        for (const upsert of changes.addedOrUpdated) {
+            try {
+                await this.upsertFile(upsert, deps);
+                result.success += 1;
+            }
+            catch (error) {
+                result.failed += 1;
+                result.warnings.push(`upsert failed: ${upsert}: ${error.message}`);
+            }
+        }
+        await this.setDirty(false);
+        return result;
+    }
+    async reconcileAfterWalRecovery(deps) {
+        await this.buildTree(deps);
+    }
+    async rebuildDirStats() {
+        await this.initialize();
+        const dirsTable = await this.ensureTreeDirsTable();
+        const filesTable = await this.ensureTreeFilesTable();
+        const dirRows = await dirsTable.query().toArray();
+        const fileRows = await filesTable.query().toArray();
+        const dirs = new Map();
+        for (const row of dirRows) {
+            const dir = parseDirRecord(row);
+            dirs.set(dir.id, dir);
+        }
+        const files = fileRows.map((row) => parseFileRecord(row));
+        const childrenByParent = new Map();
+        for (const dir of dirs.values()) {
+            if (!dir.parent_id)
+                continue;
+            const arr = childrenByParent.get(dir.parent_id) ?? [];
+            arr.push(dir);
+            childrenByParent.set(dir.parent_id, arr);
+        }
+        for (const dir of dirs.values()) {
+            dir.file_count = 0;
+            dir.dir_count = (childrenByParent.get(dir.id) ?? []).length;
+            dir.total_files = 0;
+            dir.total_symbols = 0;
+            dir.modified = 0;
+        }
+        for (const file of files) {
+            const dir = dirs.get(file.dir_id);
+            if (!dir)
+                continue;
+            dir.file_count += 1;
+            dir.total_symbols += file.symbol_count;
+            dir.modified = Math.max(dir.modified, file.modified);
+        }
+        const sortedDirs = [...dirs.values()].sort((a, b) => b.depth - a.depth);
+        for (const dir of sortedDirs) {
+            dir.total_files = dir.file_count;
+            for (const child of childrenByParent.get(dir.id) ?? []) {
+                dir.total_files += child.total_files;
+                dir.total_symbols += child.total_symbols;
+                dir.modified = Math.max(dir.modified, child.modified);
+            }
+        }
+        const indexedAt = Date.now();
+        for (const dir of dirs.values()) {
+            await this.upsertDir(dir, indexedAt);
+        }
+    }
+    async getDirById(id) {
+        await this.initialize();
+        const cached = this.dirCache.get(id);
+        if (cached)
+            return cached;
+        const table = await this.ensureTreeDirsTable();
+        const rows = await table.query().where(`id = '${sanitizeSql(id)}'`).toArray();
+        if (rows.length === 0)
+            return null;
+        const dir = parseDirRecord(rows[0]);
+        this.dirCache.set(id, dir);
+        return dir;
+    }
+    async getFileById(id) {
+        await this.initialize();
+        const cached = this.fileCache.get(id);
+        if (cached)
+            return cached;
+        const table = await this.ensureTreeFilesTable();
+        const rows = await table.query().where(`id = '${sanitizeSql(id)}'`).toArray();
+        if (rows.length === 0)
+            return null;
+        const file = parseFileRecord(rows[0]);
+        this.fileCache.set(id, file);
+        return file;
+    }
+    async getDirByPath(dirPath) {
+        await this.initialize();
+        const normalized = normalizePath(dirPath);
+        const id = generateTreeId(normalized);
+        return this.getDirById(id);
+    }
+    async getFileByPath(filePath) {
+        await this.initialize();
+        const normalized = normalizePath(filePath);
+        const id = generateTreeId(normalized);
+        return this.getFileById(id);
+    }
+    async getChildren(dir_id, options = {}) {
+        await this.initialize();
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const sortBy = options.sort_by ?? 'name';
+        const sortOrder = options.sort_order ?? 'asc';
+        const dirsTable = await this.ensureTreeDirsTable();
+        const filesTable = await this.ensureTreeFilesTable();
+        const dirRows = await dirsTable
+            .query()
+            .where(`parent_id = '${sanitizeSql(dir_id)}'`)
+            .toArray();
+        const fileRows = await filesTable
+            .query()
+            .where(`dir_id = '${sanitizeSql(dir_id)}'`)
+            .toArray();
+        const dirs = dirRows.map(parseDirRecord);
+        const files = fileRows.map(parseFileRecord);
+        const sortedDirs = [...dirs].sort((a, b) => {
+            if (sortBy === 'modified') {
+                return sortOrder === 'asc' ? a.modified - b.modified : b.modified - a.modified;
+            }
+            return sortOrder === 'asc'
+                ? a.name.localeCompare(b.name)
+                : b.name.localeCompare(a.name);
+        });
+        const sortedFiles = [...files].sort((a, b) => {
+            if (sortBy === 'modified') {
+                return sortOrder === 'asc' ? a.modified - b.modified : b.modified - a.modified;
+            }
+            if (sortBy === 'size') {
+                return sortOrder === 'asc' ? a.size - b.size : b.size - a.size;
+            }
+            return sortOrder === 'asc'
+                ? a.name.localeCompare(b.name)
+                : b.name.localeCompare(a.name);
+        });
+        return {
+            dirs: sortedDirs.slice(offset, offset + limit),
+            files: sortedFiles.slice(offset, offset + limit),
+            total: {
+                dirs: dirs.length,
+                files: files.length,
+            },
+        };
+    }
+    async getAncestors(nodeId) {
+        await this.initialize();
+        const file = await this.getFileById(nodeId);
+        let currentDirId = file ? file.dir_id : nodeId;
+        const ancestors = [];
+        while (currentDirId) {
+            const dir = await this.getDirById(currentDirId);
+            if (!dir)
+                break;
+            ancestors.push(dir);
+            currentDirId = dir.parent_id;
+        }
+        return ancestors;
+    }
+    async getAncestorIds(nodeId) {
+        const ancestors = await this.getAncestors(nodeId);
+        return ancestors.map((item) => item.id);
+    }
+    async getSiblings(nodeId, options = {}) {
+        await this.initialize();
+        const limit = options.limit ?? 100;
+        const offset = options.offset ?? 0;
+        const file = await this.getFileById(nodeId);
+        if (file) {
+            const children = await this.getChildren(file.dir_id, {
+                limit: 10_000,
+                offset: 0,
+                sort_by: 'name',
+                sort_order: 'asc',
+            });
+            const siblingFiles = children.files.filter((entry) => entry.id !== file.id);
+            return {
+                dirs: children.dirs,
+                files: siblingFiles.slice(offset, offset + limit),
+                total: {
+                    dirs: children.total.dirs,
+                    files: siblingFiles.length,
+                },
+            };
+        }
+        const dir = await this.getDirById(nodeId);
+        if (!dir || !dir.parent_id) {
+            return {
+                dirs: [],
+                files: [],
+                total: { dirs: 0, files: 0 },
+            };
+        }
+        const children = await this.getChildren(dir.parent_id, {
+            limit: 10_000,
+            offset: 0,
+            sort_by: 'name',
+            sort_order: 'asc',
+        });
+        const siblingDirs = children.dirs.filter((entry) => entry.id !== dir.id);
+        return {
+            dirs: siblingDirs.slice(offset, offset + limit),
+            files: children.files.slice(offset, offset + limit),
+            total: {
+                dirs: siblingDirs.length,
+                files: children.total.files,
+            },
+        };
+    }
+    async getSymbolsInFile(fileId, options = {}) {
+        await this.initialize();
+        const file = await this.getFileById(fileId);
+        if (!file) {
+            return { symbols: [], total: 0 };
+        }
+        const table = await this.ensureCodeChunksTable();
+        if (!table) {
+            return { symbols: [], total: 0 };
+        }
+        const rows = await table
+            .query()
+            .where(`path = '${sanitizeSql(file.path)}'`)
+            .toArray();
+        let symbols = 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,
+        }));
+        if (options.types && options.types.length > 0) {
+            const set = new Set(options.types);
+            symbols = symbols.filter((symbol) => set.has(symbol.symbolType));
+        }
+        const total = symbols.length;
+        const offset = options.offset ?? 0;
+        const limit = options.limit ?? 100;
+        return {
+            symbols: symbols.slice(offset, offset + limit),
+            total,
+        };
+    }
+    async getSymbolsInDir(dir_id, options = {}) {
+        await this.initialize();
+        const dir = await this.getDirById(dir_id);
+        if (!dir)
+            return { symbols: [], total: 0, truncated: false };
+        const recursive = options.recursive ?? false;
+        const maxFiles = options.maxFiles ?? 100;
+        const filesTable = await this.ensureTreeFilesTable();
+        let rows;
+        if (recursive) {
+            const prefix = dir.path === '' ? '' : `${dir.path}/`;
+            const where = dir.path === ''
+                ? "path != '__never__'"
+                : `path LIKE '${sanitizeSql(prefix)}%'`;
+            rows = await filesTable.query().where(where).select(['id']).toArray();
+        }
+        else {
+            rows = await filesTable.query().where(`dir_id = '${sanitizeSql(dir.id)}'`).select(['id']).toArray();
+        }
+        const fileIds = rows.map((row) => row.id);
+        const truncated = fileIds.length > maxFiles;
+        const selectedIds = fileIds.slice(0, maxFiles);
+        const symbols = [];
+        for (const fileId of selectedIds) {
+            const fileSymbols = await this.getSymbolsInFile(fileId, {
+                types: options.types,
+                limit: options.limit ?? 100,
+            });
+            symbols.push(...fileSymbols.symbols);
+        }
+        return {
+            symbols,
+            total: symbols.length,
+            truncated,
+        };
+    }
+    async searchFiles(query, options = {}) {
+        await this.initialize();
+        const table = await this.ensureTreeFilesTable();
+        const count = await table.countRows();
+        if (count === 0) {
+            return {
+                items: [],
+                freshness: this.getFreshnessInfo(),
+                budget: {
+                    estimatedTokens: 0,
+                    budgetTokens: options.budgetTokens ?? this.treeConfig.retrievalBudgetTokens,
+                    truncated: false,
+                },
+            };
+        }
+        const queryEmbedding = await this.embeddingProvider.getEmbedding(query, 'query');
+        if (isError(queryEmbedding)) {
+            return createError('TREE_SEARCH_EMBEDDING_ERROR', queryEmbedding.message);
+        }
+        const limit = options.limit ?? 20;
+        const threshold = options.threshold ?? 0.4;
+        let search = table.search(queryEmbedding).limit(limit * 3);
+        if (options.dir_id) {
+            search = search.where(`dir_id = '${sanitizeSql(options.dir_id)}'`);
+        }
+        const rows = await search.toArray();
+        const files = [];
+        for (const row of rows) {
+            const score = 1 - (row._distance / 2);
+            if (score < threshold)
+                continue;
+            files.push(parseFileRecord(row));
+            if (files.length >= limit)
+                break;
+        }
+        const budgetTokens = options.budgetTokens ?? this.treeConfig.retrievalBudgetTokens;
+        const estimatedTokens = Math.ceil(files.reduce((sum, file) => sum + file.path.length + (file.key_symbols?.length ?? 0) + 12, 0) / 4);
+        return {
+            items: files,
+            freshness: this.getFreshnessInfo(),
+            budget: {
+                estimatedTokens,
+                budgetTokens,
+                truncated: estimatedTokens > budgetTokens,
+                truncationReason: estimatedTokens > budgetTokens ? 'token_budget' : undefined,
+            },
+        };
+    }
+    async getFileContext(seedPaths, options = {}) {
+        const expander = new TreeContextExpander(this);
+        return expander.expand(seedPaths, {
+            budgetTokens: options.budgetTokens ?? this.treeConfig.retrievalBudgetTokens,
+            ancestorLevels: options.ancestorLevels,
+            includeSiblings: options.includeSiblings,
+            maxFilesPerDir: options.maxFilesPerDir,
+            includeFreshness: options.includeFreshness,
+        });
+    }
+    async generateRepoMap(options = {}) {
+        await this.initialize();
+        const cacheKey = this.repoMapCache.makeKey('repomap', JSON.stringify(options));
+        const cached = this.repoMapCache.get(cacheKey);
+        if (cached) {
+            return {
+                text: cached,
+                freshness: this.getFreshnessInfo(),
+                budget: {
+                    estimatedTokens: Math.ceil(cached.length / 4),
+                    budgetTokens: options.budgetTokens ?? this.treeConfig.retrievalBudgetTokens,
+                    truncated: cached.includes('[truncated:'),
+                },
+            };
+        }
+        const result = await generateRepoMap(this, {
+            maxDepth: options.maxDepth ?? this.treeConfig.repoMapMaxDepth,
+            maxSymbolsPerFile: options.maxSymbolsPerFile ?? this.treeConfig.repoMapMaxSymbols,
+            maxFilesPerDir: options.maxFilesPerDir,
+            dirId: options.dirId,
+            sort_by: options.sort_by,
+            includeSignatures: options.includeSignatures,
+            budgetTokens: options.budgetTokens ?? this.treeConfig.retrievalBudgetTokens,
+        });
+        this.repoMapCache.set(cacheKey, result.text);
+        return result;
+    }
+    /**
+     * Get tree with symbols for semantic search results.
+     * Finds files by query, groups them by directory, and includes symbols.
+     */
+    async getTreeWithSymbols(options) {
+        await this.initialize();
+        // Clamp parameters to safe bounds
+        const limit = Math.min(Math.max(options.limit ?? 20, 1), 100);
+        const symbolsPerFile = Math.min(Math.max(options.symbolsPerFile ?? 3, 1), 20);
+        const maxSiblingsFiles = Math.min(Math.max(options.maxSiblingsFiles ?? 5, 0), 50);
+        const includeFileContext = options.includeFileContext ?? true;
+        // 1. Semantic search for files
+        let dirId;
+        if (options.dirPath) {
+            const dir = await this.getDirByPath(options.dirPath);
+            if (dir) {
+                dirId = dir.id;
+            }
+        }
+        const searchResult = await this.searchFiles(options.query, {
+            limit,
+            threshold: options.threshold,
+            dir_id: dirId,
+        });
+        if (isError(searchResult)) {
+            return { ok: false, error: searchResult.message };
+        }
+        const matchedFiles = searchResult.items;
+        if (matchedFiles.length === 0) {
+            return {
+                ok: true,
+                root: '',
+                groups: {},
+                orderedDirs: [],
+                matchedFiles: 0,
+                totalSymbols: 0,
+            };
+        }
+        // 2. Find LCA of all matched paths
+        const filePaths = matchedFiles.map((f) => f.path);
+        const lca = filePaths.length === 1
+            ? path.dirname(filePaths[0])
+            : commonAncestorPath(...filePaths) ?? '';
+        // 3. Group matched files by directory (relative to LCA)
+        const matchedByDir = {};
+        for (const file of matchedFiles) {
+            const relDir = path.relative(lca, path.dirname(file.path)) || '.';
+            const normalizedDir = relDir.replace(/\\/g, '/');
+            (matchedByDir[normalizedDir] ??= []).push(file);
+        }
+        // 4. Batch fetch symbols for matched files
+        const symbols = await this.batchGetSymbols(filePaths, { limit: symbolsPerFile });
+        // 5. Batch fetch file context (docstrings) for matched files
+        const fileContexts = includeFileContext
+            ? await this.batchGetFileContext(filePaths)
+            : {};
+        // 6. Batch fetch siblings for each directory
+        const groups = {};
+        for (const [relDir, files] of Object.entries(matchedByDir)) {
+            // Get parent directory ID
+            const absDir = relDir === '.' ? lca : path.join(lca, relDir).replace(/\\/g, '/');
+            const parentDir = await this.getDirByPath(absDir);
+            // Build matched file entries
+            const fileEntries = [];
+            for (const file of files.sort((a, b) => a.name.localeCompare(b.name))) {
+                fileEntries.push({
+                    name: file.name,
+                    matched: true,
+                    fileContext: fileContexts[file.path],
+                    symbols: symbols[file.path] ?? [],
+                });
+            }
+            // Get sibling files (non-matched files in same directory)
+            let truncatedFiles = 0;
+            if (parentDir && maxSiblingsFiles > 0) {
+                const children = await this.getChildren(parentDir.id, {
+                    limit: 10000,
+                    sort_by: 'name',
+                    sort_order: 'asc',
+                });
+                const matchedNames = new Set(files.map((f) => f.name));
+                const siblings = children.files.filter((f) => !matchedNames.has(f.name));
+                if (siblings.length > maxSiblingsFiles) {
+                    truncatedFiles = siblings.length - maxSiblingsFiles;
+                }
+                for (const sibling of siblings.slice(0, maxSiblingsFiles)) {
+                    fileEntries.push({
+                        name: sibling.name,
+                        matched: false,
+                    });
+                }
+            }
+            groups[relDir] = {
+                files: fileEntries,
+                truncatedFiles: truncatedFiles > 0 ? truncatedFiles : undefined,
+            };
+        }
+        // Sort directories for stable output order
+        const orderedDirs = Object.keys(groups).sort((a, b) => a.localeCompare(b));
+        // Calculate total symbols
+        const totalSymbols = Object.values(symbols).reduce((sum, fileSymbols) => sum + fileSymbols.length, 0);
+        return {
+            ok: true,
+            root: lca,
+            groups,
+            orderedDirs,
+            matchedFiles: matchedFiles.length,
+            totalSymbols,
+        };
+    }
+    /**
+     * Batch fetch symbols for multiple files from code_chunks table.
+     */
+    async batchGetSymbols(paths, options) {
+        if (paths.length === 0)
+            return {};
+        const table = await this.ensureCodeChunksTable();
+        if (!table)
+            return {};
+        // Query all symbols for the given paths
+        const placeholders = paths.map((p) => `'${sanitizeSql(p)}'`).join(',');
+        const rows = await table
+            .query()
+            .where(`path IN (${placeholders}) AND symbol_type IN ('class', 'interface', 'function', 'method', 'type')`)
+            .toArray();
+        // Group by path and apply limit per file
+        const result = {};
+        // Sort rows by priority: class > interface > function > method > type
+        const typeOrder = {
+            class: 1,
+            interface: 2,
+            function: 3,
+            method: 4,
+            type: 5,
+        };
+        const sortedRows = rows.sort((a, b) => {
+            const pathCompare = a.path.localeCompare(b.path);
+            if (pathCompare !== 0)
+                return pathCompare;
+            return (typeOrder[a.symbol_type] ?? 99) - (typeOrder[b.symbol_type] ?? 99);
+        });
+        for (const row of sortedRows) {
+            const filePath = row.path;
+            const fileSymbols = result[filePath] ?? [];
+            if (fileSymbols.length >= options.limit)
+                continue;
+            const symbolType = row.symbol_type;
+            const validTypes = ['class', 'function', 'method', 'interface', 'type'];
+            if (!validTypes.includes(symbolType))
+                continue;
+            fileSymbols.push({
+                name: row.symbol_name,
+                type: symbolType,
+                signature: row.signature || undefined,
+                description: row.docstring
+                    ? row.docstring.split('\n')[0].trim() || undefined
+                    : undefined,
+            });
+            result[filePath] = fileSymbols;
+        }
+        return result;
+    }
+    /**
+     * Batch fetch file context (file-level docstrings) for multiple files.
+     */
+    async batchGetFileContext(paths) {
+        if (paths.length === 0)
+            return {};
+        const table = await this.ensureCodeChunksTable();
+        if (!table)
+            return {};
+        const placeholders = paths.map((p) => `'${sanitizeSql(p)}'`).join(',');
+        const rows = await table
+            .query()
+            .where(`path IN (${placeholders}) AND symbol_type = 'file' AND docstring IS NOT NULL`)
+            .select(['path', 'docstring'])
+            .toArray();
+        const result = {};
+        for (const row of rows) {
+            const docstring = row.docstring;
+            if (docstring && docstring.trim()) {
+                result[row.path] = docstring.trim();
+            }
+        }
+        return result;
+    }
+    async clear() {
+        await this.initialize();
+        if (this.treeDirsTable) {
+            await this.db.dropTable('tree_dirs');
+            this.treeDirsTable = null;
+        }
+        if (this.treeFilesTable) {
+            await this.db.dropTable('tree_files');
+            this.treeFilesTable = null;
+        }
+        // Reset references to external tables (owned by codeIndexer)
+        this.codeChunksTable = null;
+        this.codeFileIndexTable = null;
+        this.dirCache.clear();
+        this.fileCache.clear();
+        this.repoMapCache.clear();
+        this.meta = {
+            dirty: false,
+            indexVersion: 0,
+            updatedAt: Date.now(),
+            indexedAt: 0,
+        };
+        await this.saveMeta();
+    }
+}
+//# sourceMappingURL=index.js.map