@jafreck/lore 0.2.3 → 0.2.5

package/dist/indexer/index.js

@@ -19,7 +19,7 @@ import { inferSeededDocNoteKey, buildDocNoteScope } from './docs.js';
 import { ingestGitHistory } from './git-history.js';
 import { ParserPool } from './parser.js';
 import { ImportResolver } from './resolver.js';
-import { buildCallGraph } from './call-graph.js';
+import { resolveSymbolEdges, normalizeTypeName } from './call-graph.js';
 import { isPublicDeclarationSurfaceSymbol, } from './extractors/types.js';
 import { CExtractor } from './extractors/c.js';
 import { RustExtractor } from './extractors/rust.js';
@@ -49,6 +49,7 @@ import { DEFAULT_EMBEDDING_MODEL, buildStructuralEmbeddingText } from './embedde
 import { ingestCoverageReport } from './coverage.js';
 import { refreshTestMappings } from './test-mapper.js';
 import { LspEnrichmentCoordinator } from './lsp/enrichment.js';
+import { getLogger } from '../logger.js';
 // ─── Extractor registry ───────────────────────────────────────────────────────
 const EXTRACTORS = {
     c: new CExtractor(),
@@ -127,13 +128,17 @@ export class IndexBuilder {
      * the database.
      */
     async build() {
+        const log = getLogger();
+        const buildStart = performance.now();
         const db = openDb(this.dbPath);
         const branch = this.resolveBranch();
         const lspCoordinator = this.createLspEnrichmentCoordinator();
+        log.indexing('build started', { dbPath: this.dbPath, branch, rootDir: this.walkerConfig.rootDir });
         try {
             this.saveDocsAutoNotesSetting(db);
             const files = await walkFiles(this.walkerConfig);
             const docs = await walkDocumentationFiles(this.walkerConfig);
+            log.indexing('walk complete', { fileCount: files.length, docCount: docs.length });
             if (lspCoordinator) {
                 const languages = new Set(files.map((file) => file.language));
                 if (this.indexDependencies)
@@ -141,6 +146,9 @@ export class IndexBuilder {
                 await lspCoordinator.start(languages);
             }
             const resumeAt = this.loadBuildCheckpoint(db, branch, files.length);
+            if (resumeAt > 0) {
+                log.indexing('resuming from checkpoint', { resumeAt, totalFiles: files.length });
+            }
             db.transaction(() => {
                 for (let i = resumeAt; i < files.length; i++) {
                     const file = files[i];
@@ -158,24 +166,64 @@ export class IndexBuilder {
                 this.removeStaleDocumentation(db, branch, seenDocPaths);
             })();
             this.saveBuildCheckpoint(db, branch, files.length, files.length);
+            log.indexing('files processed, resolving imports');
             this.resolveImports(db, branch);
             await this.indexDependencyDeclarations(db, lspCoordinator);
-            await this.enrichProjectSymbolsAndCallRefs(db, branch, files, lspCoordinator);
+            await this.enrichProjectRefs(db, branch, files, lspCoordinator);
             refreshTestMappings(db, branch);
-            buildCallGraph(db);
+            resolveSymbolEdges(db);
             this.saveLastKnownHead(db);
             if (this.embedder) {
+                log.indexing('embedding started', { model: this.embeddingModel });
                 await this.embedder.init();
                 await this.embedStructural(db);
                 await this.embedDocumentation(db);
+                log.indexing('embedding complete');
             }
             if (this.history) {
+                log.indexing('git history ingestion started');
                 const historyOptions = typeof this.history === 'object' ? this.history : undefined;
                 await ingestGitHistory(db, this.walkerConfig.rootDir, historyOptions);
                 if (this.embedder) {
                     await this.embedCommitMessages(db);
                 }
+                log.indexing('git history ingestion complete');
+            }
+            // Gather final DB stats for the build summary
+            let totalSymbols = 0;
+            try {
+                totalSymbols = db.prepare('SELECT COUNT(*) AS cnt FROM symbols').get().cnt;
+            }
+            catch { /* table may not exist */ }
+            let totalEdges = 0;
+            try {
+                totalEdges = db.prepare('SELECT COUNT(*) AS cnt FROM symbol_refs').get().cnt;
+            }
+            catch { /* table may not exist */ }
+            let totalDocs = 0;
+            try {
+                totalDocs = db.prepare('SELECT COUNT(*) AS cnt FROM docs').get().cnt;
             }
+            catch { /* table may not exist */ }
+            let commitCount;
+            try {
+                commitCount = db.prepare('SELECT COUNT(*) AS cnt FROM commits').get().cnt;
+            }
+            catch { /* commits table may not exist */ }
+            const dbSizeBytes = fs.existsSync(this.dbPath) ? fs.statSync(this.dbPath).size : undefined;
+            const indexDurationMs = Math.round(performance.now() - buildStart);
+            log.startup('indexing complete', {
+                dbPath: this.dbPath,
+                dbSizeBytes,
+                embeddingModel: this.embeddingModel,
+                embeddingReady: !!this.embedder,
+                totalFiles: files.length,
+                totalSymbols,
+                totalDocs,
+                totalEdges,
+                commitCount,
+                indexDurationMs,
+            });
         }
         finally {
             if (lspCoordinator) {
@@ -195,6 +243,12 @@ export class IndexBuilder {
         const branch = this.resolveBranch();
         const lspCoordinator = this.createLspEnrichmentCoordinator();
         const enrichedFiles = [];
+        /** Symbol IDs whose embeddings should be removed (from deleted/re-processed files). */
+        const staleSymbolIds = [];
+        /** Paths of changed source files — used to look up new file IDs for scoped embedding. */
+        const changedSourcePaths = [];
+        /** Paths of changed doc files — used to look up new doc IDs for scoped embedding. */
+        const changedDocPaths = [];
         try {
             this.saveDocsAutoNotesSetting(db);
             const docs = await walkDocumentationFiles(this.walkerConfig);
@@ -218,6 +272,10 @@ export class IndexBuilder {
                     if (!fs.existsSync(filePath)) {
                         const row = db.prepare('SELECT id FROM files WHERE path = ? AND branch = ?').get(filePath, branch);
                         if (row) {
+                            // Collect symbol IDs for embedding cleanup before cascade-delete removes them.
+                            const symRows = db.prepare('SELECT id FROM symbols WHERE file_id = ?').all(row.id);
+                            for (const s of symRows)
+                                staleSymbolIds.push(s.id);
                             // Null out any resolved_id references pointing to this file
                             db.prepare('UPDATE file_imports SET resolved_id = NULL WHERE resolved_id = ?').run(row.id);
                             db.prepare('DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_id = ?)').run(row.id);
@@ -229,10 +287,18 @@ export class IndexBuilder {
                     const language = detectLanguageForPath(filePath, this.walkerConfig);
                     if (language) {
                         enrichedFiles.push({ path: filePath, language });
+                        changedSourcePaths.push(filePath);
                         // Null out resolved_id references pointing to this file before deletion
                         const existingRow = db.prepare('SELECT id FROM files WHERE path = ? AND branch = ?').get(filePath, branch);
                         if (existingRow) {
+                            // Collect symbol IDs for embedding cleanup before cascade-delete removes them.
+                            const symRows = db.prepare('SELECT id FROM symbols WHERE file_id = ?').all(existingRow.id);
+                            for (const s of symRows)
+                                staleSymbolIds.push(s.id);
                             db.prepare('UPDATE file_imports SET resolved_id = NULL WHERE resolved_id = ?').run(existingRow.id);
+                            db.prepare('UPDATE symbol_refs SET callee_id = NULL WHERE callee_id IN (SELECT id FROM symbols WHERE file_id = ?)').run(existingRow.id);
+                            db.prepare('UPDATE type_refs SET type_id = NULL WHERE type_id IN (SELECT id FROM symbols WHERE file_id = ?)').run(existingRow.id);
+                            db.prepare('UPDATE symbol_relationships SET target_symbol_id = NULL WHERE target_symbol_id IN (SELECT id FROM symbols WHERE file_id = ?)').run(existingRow.id);
                             db.prepare('DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_id = ?)').run(existingRow.id);
                         }
                         // Delete existing rows for this file (cascade handles symbols/imports)
@@ -243,6 +309,7 @@ export class IndexBuilder {
                     if (changedDoc) {
                         this.processDocumentationFile(db, changedDoc, branch);
                         this.upsertSeededDocumentationNote(db, changedDoc, branch);
+                        changedDocPaths.push(filePath);
                     }
                     else {
                         this.deleteDocumentationByPath(db, filePath, branch);
@@ -251,7 +318,7 @@ export class IndexBuilder {
             })();
             this.resolveImports(db, branch);
             await this.indexDependencyDeclarations(db, lspCoordinator);
-            await this.enrichProjectSymbolsAndCallRefs(db, branch, enrichedFiles, lspCoordinator);
+            await this.enrichProjectRefs(db, branch, enrichedFiles, lspCoordinator);
             refreshTestMappings(db, branch);
             if (this.history) {
                 const historyOptions = typeof this.history === 'object' ? this.history : undefined;
@@ -259,13 +326,29 @@ export class IndexBuilder {
             }
             if (this.embedder) {
                 await this.embedder.init();
-                await this.embedStructural(db);
-                await this.embedDocumentation(db);
+                // Clean up orphaned symbol embeddings for symbols that were deleted/replaced.
+                this.deleteSymbolEmbeddings(db, staleSymbolIds);
+                // Resolve the new file IDs for the changed source files.
+                const changedFileIds = [];
+                for (const p of changedSourcePaths) {
+                    const row = db.prepare('SELECT id FROM files WHERE path = ? AND branch = ?').get(p, branch);
+                    if (row)
+                        changedFileIds.push(row.id);
+                }
+                // Resolve the new doc IDs for the changed documentation files.
+                const changedDocIds = [];
+                for (const p of changedDocPaths) {
+                    const row = db.prepare('SELECT id FROM docs WHERE path = ? AND branch = ?').get(p, branch);
+                    if (row)
+                        changedDocIds.push(row.id);
+                }
+                await this.embedStructural(db, changedFileIds);
+                await this.embedDocumentation(db, changedDocIds);
                 if (this.history) {
                     await this.embedCommitMessages(db);
                 }
             }
-            buildCallGraph(db);
+            resolveSymbolEdges(db);
             this.saveLastKnownHead(db);
         }
         finally {
@@ -342,10 +425,18 @@ export class IndexBuilder {
             fileId = existing.id;
             // Remove stale symbols / imports / external deps (also clean up FTS5 index)
             db.prepare(`DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file_id = ?)`).run(fileId);
+            db.prepare('DELETE FROM symbol_relationships WHERE file_id = ?').run(fileId);
+            db.prepare('DELETE FROM type_refs WHERE file_id = ?').run(fileId);
+            // NULL out cross-file FK references that point to symbols in this file
+            db.prepare('UPDATE symbol_refs SET callee_id = NULL WHERE callee_id IN (SELECT id FROM symbols WHERE file_id = ?)').run(fileId);
+            db.prepare('UPDATE type_refs SET type_id = NULL WHERE type_id IN (SELECT id FROM symbols WHERE file_id = ?)').run(fileId);
+            db.prepare('UPDATE symbol_relationships SET target_symbol_id = NULL WHERE target_symbol_id IN (SELECT id FROM symbols WHERE file_id = ?)').run(fileId);
             db.prepare('DELETE FROM symbols WHERE file_id = ?').run(fileId);
             db.prepare('DELETE FROM file_imports WHERE file_id = ?').run(fileId);
             db.prepare('DELETE FROM external_deps WHERE file_id = ?').run(fileId);
             db.prepare('DELETE FROM api_routes WHERE file_id = ?').run(fileId);
+            // Delete stale annotations so cascade-independent re-index doesn't accumulate duplicates.
+            db.prepare('DELETE FROM annotations WHERE file_id = ?').run(fileId);
         }
         else {
             const info = db
@@ -388,14 +479,28 @@ export class IndexBuilder {
             insertImport.run(fileId, imp.source);
         }
         // Insert call refs (callee_id resolved in call-graph phase)
-        const insertCallRef = db.prepare(`INSERT INTO symbol_refs (caller_id, callee_name, call_line)
-       VALUES (?, ?, ?)`);
+        const insertCallRef = db.prepare(`INSERT INTO symbol_refs (caller_id, callee_name, call_line, call_character, call_kind)
+       VALUES (?, ?, ?, ?, ?)`);
         for (const ref of result.callRefs) {
             const callerId = symbolIdMap.get(ref.callerSymbol);
             if (callerId !== undefined) {
-                insertCallRef.run(callerId, ref.calleeRaw, ref.line);
+                insertCallRef.run(callerId, ref.calleeRaw, ref.line, ref.character ?? null, ref.callKind ?? 'direct');
             }
         }
+        // Insert relationships (target_symbol_id resolved in resolveSymbolEdges phase)
+        const insertRelationship = db.prepare(`INSERT INTO symbol_relationships (file_id, source_symbol_id, target_symbol_name, relationship_type, line, character)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+        for (const rel of result.relationships) {
+            const sourceId = symbolIdMap.get(rel.fromSymbol) ?? null;
+            insertRelationship.run(fileId, sourceId, rel.toSymbol, rel.kind, rel.line, rel.character ?? null);
+        }
+        // Insert type refs (type_id resolved in resolveSymbolEdges phase)
+        const insertTypeRef = db.prepare(`INSERT INTO type_refs (file_id, symbol_id, type_name, type_name_bare, ref_kind, ref_line, ref_character)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        for (const ref of result.typeRefs) {
+            const symId = symbolIdMap.get(ref.enclosingSymbol) ?? null;
+            insertTypeRef.run(fileId, symId, ref.typeRaw, normalizeTypeName(ref.typeRaw), ref.refKind, ref.line, ref.character ?? null);
+        }
     }
     processDocumentationFile(db, doc, branch) {
         const existing = db.prepare('SELECT id, content_hash FROM docs WHERE path = ? AND branch = ?').get(doc.path, branch);
@@ -486,6 +591,18 @@ export class IndexBuilder {
             return;
         db.prepare(`DELETE FROM doc_section_embeddings WHERE rowid IN (${sectionIds.map(() => '?').join(', ')})`).run(...sectionIds);
     }
+    /**
+     * Remove orphaned rows from the `symbol_embeddings` vec0 table for symbols
+     * that have been deleted (e.g. file re-processed or removed).
+     */
+    deleteSymbolEmbeddings(db, symbolIds) {
+        if (symbolIds.length === 0)
+            return;
+        const hasEmbeddingsTable = db.prepare("SELECT 1 AS present FROM sqlite_master WHERE type IN ('table', 'virtual table') AND name = 'symbol_embeddings'").get();
+        if (!hasEmbeddingsTable)
+            return;
+        db.prepare(`DELETE FROM symbol_embeddings WHERE rowid IN (${symbolIds.map(() => '?').join(', ')})`).run(...symbolIds);
+    }
     /**
      * Second pass: resolve raw_import strings to file IDs in the
      * `file_imports.resolved_id` column.  Also populates `external_deps` for
@@ -582,7 +699,7 @@ export class IndexBuilder {
         }
         return new LspEnrichmentCoordinator(this.lspSettings, this.walkerConfig.rootDir);
     }
-    async enrichProjectSymbolsAndCallRefs(db, branch, files, lspCoordinator) {
+    async enrichProjectRefs(db, branch, files, lspCoordinator) {
         if (!lspCoordinator || files.length === 0)
             return;
         const selectSymbols = db.prepare(`SELECT s.id, s.name, s.signature, s.start_line
@@ -590,11 +707,21 @@ export class IndexBuilder {
        JOIN files f ON f.id = s.file_id
        WHERE f.path = ? AND f.branch = ?
        ORDER BY s.id`);
-        const selectCallRefs = db.prepare(`SELECT sr.id, sr.call_line
+        const selectCallRefs = db.prepare(`SELECT sr.id, sr.call_line, sr.call_character
        FROM symbol_refs sr
        JOIN symbols s ON s.id = sr.caller_id
        JOIN files f ON f.id = s.file_id
        WHERE f.path = ? AND f.branch = ?
+       ORDER BY sr.id`);
+        const selectTypeRefs = db.prepare(`SELECT tr.id, tr.ref_line, tr.ref_character
+       FROM type_refs tr
+       JOIN files f ON f.id = tr.file_id
+       WHERE f.path = ? AND f.branch = ?
+       ORDER BY tr.id`);
+        const selectRelationships = db.prepare(`SELECT sr.id, sr.line, sr.character
+       FROM symbol_relationships sr
+       JOIN files f ON f.id = sr.file_id
+       WHERE f.path = ? AND f.branch = ? AND sr.line IS NOT NULL
        ORDER BY sr.id`);
         const updateSymbol = db.prepare(`UPDATE symbols
        SET resolved_type_signature = ?, resolved_return_type = ?, definition_uri = ?, definition_path = ?
@@ -602,6 +729,12 @@ export class IndexBuilder {
         const updateSymbolFts = db.prepare('UPDATE symbols_fts SET signature = ? WHERE rowid = ?');
         const updateCallRef = db.prepare(`UPDATE symbol_refs
        SET resolved_type_signature = ?, resolved_return_type = ?, definition_uri = ?, definition_path = ?
+       WHERE id = ?`);
+        const updateTypeRef = db.prepare(`UPDATE type_refs
+       SET resolved_type_signature = ?, definition_uri = ?, definition_path = ?
+       WHERE id = ?`);
+        const updateRelationship = db.prepare(`UPDATE symbol_relationships
+       SET definition_uri = ?, definition_path = ?
        WHERE id = ?`);
         for (const file of files) {
             if (!file || !fs.existsSync(file.path))
@@ -613,46 +746,55 @@ export class IndexBuilder {
             catch {
                 continue;
             }
+            const tagged = [];
             const symbols = selectSymbols.all(file.path, branch);
-            if (symbols.length > 0) {
-                const symbolMetadata = await lspCoordinator.enrich({
-                    filePath: file.path,
-                    language: file.language,
-                    source,
-                    targets: symbols.map((symbol) => ({ line: symbol.start_line, character: 0 })),
-                });
-                for (let i = 0; i < symbols.length; i++) {
-                    const symbol = symbols[i];
-                    if (!symbol)
-                        continue;
-                    const metadata = symbolMetadata[i];
-                    if (!metadata)
-                        continue;
-                    updateSymbol.run(metadata.resolvedTypeSignature, metadata.resolvedReturnType, metadata.definitionUri, metadata.definitionPath, symbol.id);
-                    updateSymbolFts.run(buildStructuralEmbeddingText({
-                        name: symbol.name,
-                        signature: symbol.signature,
-                        resolvedTypeSignature: metadata.resolvedTypeSignature,
-                        resolvedReturnType: metadata.resolvedReturnType,
-                    }), symbol.id);
-                }
+            for (const s of symbols) {
+                tagged.push({ table: 'symbol', rowId: s.id, line: s.start_line, character: 0, name: s.name, signature: s.signature });
             }
             const callRefs = selectCallRefs.all(file.path, branch);
-            if (callRefs.length > 0) {
-                const callRefMetadata = await lspCoordinator.enrich({
-                    filePath: file.path,
-                    language: file.language,
-                    source,
-                    targets: callRefs.map((callRef) => ({ line: callRef.call_line, character: 0 })),
-                });
-                for (let i = 0; i < callRefs.length; i++) {
-                    const callRef = callRefs[i];
-                    if (!callRef)
-                        continue;
-                    const metadata = callRefMetadata[i];
-                    if (!metadata)
-                        continue;
-                    updateCallRef.run(metadata.resolvedTypeSignature, metadata.resolvedReturnType, metadata.definitionUri, metadata.definitionPath, callRef.id);
+            for (const cr of callRefs) {
+                tagged.push({ table: 'callRef', rowId: cr.id, line: cr.call_line, character: cr.call_character ?? 0 });
+            }
+            const typeRefs = selectTypeRefs.all(file.path, branch);
+            for (const tr of typeRefs) {
+                tagged.push({ table: 'typeRef', rowId: tr.id, line: tr.ref_line, character: tr.ref_character ?? 0 });
+            }
+            const relationships = selectRelationships.all(file.path, branch);
+            for (const r of relationships) {
+                tagged.push({ table: 'relationship', rowId: r.id, line: r.line, character: r.character ?? 0 });
+            }
+            if (tagged.length === 0)
+                continue;
+            const metadata = await lspCoordinator.enrich({
+                filePath: file.path,
+                language: file.language,
+                source,
+                targets: tagged.map(t => ({ line: t.line, character: t.character })),
+            });
+            for (let i = 0; i < tagged.length; i++) {
+                const tag = tagged[i];
+                const m = metadata[i];
+                if (!m)
+                    continue;
+                switch (tag.table) {
+                    case 'symbol':
+                        updateSymbol.run(m.resolvedTypeSignature, m.resolvedReturnType, m.definitionUri, m.definitionPath, tag.rowId);
+                        updateSymbolFts.run(buildStructuralEmbeddingText({
+                            name: tag.name,
+                            signature: tag.signature ?? null,
+                            resolvedTypeSignature: m.resolvedTypeSignature,
+                            resolvedReturnType: m.resolvedReturnType,
+                        }), tag.rowId);
+                        break;
+                    case 'callRef':
+                        updateCallRef.run(m.resolvedTypeSignature, m.resolvedReturnType, m.definitionUri, m.definitionPath, tag.rowId);
+                        break;
+                    case 'typeRef':
+                        updateTypeRef.run(m.resolvedTypeSignature, m.definitionUri, m.definitionPath, tag.rowId);
+                        break;
+                    case 'relationship':
+                        updateRelationship.run(m.definitionUri, m.definitionPath, tag.rowId);
+                        break;
                 }
             }
         }
@@ -785,20 +927,31 @@ export class IndexBuilder {
      *
      * Also stores the embedding model name and dims in `lore_meta` and
      * creates the vec0 tables if they don't exist yet.
+     *
+     * @param fileIds  When provided, only embed symbols belonging to these file
+     *                 IDs (incremental mode). When omitted, embeds all symbols
+     *                 (full-build mode).
      */
-    async embedStructural(db) {
+    async embedStructural(db, fileIds) {
         const embedder = this.embedder;
         setLoreMeta(db, 'embedding_model', embedder.modelName);
         setLoreMeta(db, 'embedding_dims', String(embedder.dims));
         createVec0Tables(db, embedder.dims);
-        // Fetch all symbols that have structural text to embed.
-        const symbols = db
-            .prepare(`SELECT id, name, signature, resolved_type_signature, resolved_return_type
-         FROM symbols
-         WHERE signature IS NOT NULL
-            OR resolved_type_signature IS NOT NULL
-            OR resolved_return_type IS NOT NULL`)
-            .all();
+        // Build the query — scoped to specific files when doing an incremental update.
+        const baseQuery = `SELECT id, name, signature, resolved_type_signature, resolved_return_type
+       FROM symbols
+       WHERE (signature IS NOT NULL
+          OR resolved_type_signature IS NOT NULL
+          OR resolved_return_type IS NOT NULL)`;
+        let symbols;
+        if (fileIds && fileIds.length > 0) {
+            symbols = db
+                .prepare(`${baseQuery} AND file_id IN (${fileIds.map(() => '?').join(', ')})`)
+                .all(...fileIds);
+        }
+        else {
+            symbols = db.prepare(baseQuery).all();
+        }
         const insertEmbed = db.prepare('INSERT OR REPLACE INTO symbol_embeddings(rowid, embedding) VALUES (CAST(? AS INTEGER), json(?))');
         for (let i = 0; i < symbols.length; i += EMBED_BATCH_SIZE) {
             const batch = symbols.slice(i, i + EMBED_BATCH_SIZE);
@@ -818,16 +971,33 @@ export class IndexBuilder {
             })();
         }
     }
-    async embedDocumentation(db) {
+    /**
+     * Embed documentation sections in batches and persist results to
+     * the `doc_section_embeddings` vec0 virtual table.
+     *
+     * @param docIds  When provided, only embed sections belonging to these
+     *                doc IDs (incremental mode). When omitted, embeds all
+     *                sections (full-build mode).
+     */
+    async embedDocumentation(db, docIds) {
         const embedder = this.embedder;
         db.exec(`
       CREATE VIRTUAL TABLE IF NOT EXISTS doc_section_embeddings USING vec0(
         embedding FLOAT[${embedder.dims}]
       );
     `);
-        const sections = db.prepare(`SELECT id, title, content
-       FROM doc_sections
-       ORDER BY id`).all();
+        let sections;
+        if (docIds && docIds.length > 0) {
+            sections = db.prepare(`SELECT id, title, content
+         FROM doc_sections
+         WHERE doc_id IN (${docIds.map(() => '?').join(', ')})
+         ORDER BY id`).all(...docIds);
+        }
+        else {
+            sections = db.prepare(`SELECT id, title, content
+         FROM doc_sections
+         ORDER BY id`).all();
+        }
         if (sections.length === 0)
             return;
         const insertEmbed = db.prepare('INSERT OR REPLACE INTO doc_section_embeddings(rowid, embedding) VALUES (CAST(? AS INTEGER), json(?))');
@@ -845,12 +1015,21 @@ export class IndexBuilder {
             })();
         }
     }
+    /**
+     * Embed commit messages that haven't been embedded yet.
+     *
+     * Uses a `LEFT JOIN` against `commit_embeddings` to skip commits whose
+     * embeddings already exist, so only newly-ingested commits are processed.
+     */
     async embedCommitMessages(db) {
         const embedder = this.embedder;
-        const commits = db.prepare(`SELECT rowid, message
-       FROM commits
-       WHERE length(trim(message)) > 0
-       ORDER BY rowid`).all();
+        // Only embed commits that don't already have an embedding row.
+        const commits = db.prepare(`SELECT c.rowid, c.message
+       FROM commits c
+       LEFT JOIN commit_embeddings ce ON ce.rowid = c.rowid
+       WHERE length(trim(c.message)) > 0
+         AND ce.rowid IS NULL
+       ORDER BY c.rowid`).all();
         if (commits.length === 0)
             return;
         const insertEmbed = db.prepare('INSERT OR REPLACE INTO commit_embeddings(rowid, embedding) VALUES (CAST(? AS INTEGER), json(?))');