@jafreck/lore 0.3.7 → 0.3.8

package/dist/indexer/stages/{scip-source.js → scip-indexer.js}

@@ -1,19 +1,25 @@
 /**
- * @module indexer/stages/scip-source
+ * @module indexer/stages/scip-indexer
  *
  * Pipeline stage: for SCIP-covered languages, populate `files`, `symbols`,
  * `symbol_refs`, `type_refs`, `symbol_relationships`, and `file_imports`
  * **directly from the SCIP index** — bypassing tree-sitter entirely.
  *
- * This is the SCIP-primary architecture.  SCIP is the source of truth for
- * both the symbol table and the call graph.  For each SCIP document:
+ * This is the single-pass SCIP architecture.  SCIP is the source of truth
+ * for the symbol table, the call graph, **and** enrichment metadata (type
+ * signatures, definition locations).  All data is written in one pass.
+ *
+ * For each SCIP document:
  *
  * 1. **Symbols**: Definition occurrences → `symbols` rows; kinds inferred
  *    from SCIP descriptor suffixes; spans from `enclosing_range`.
+ *    Enrichment columns (`resolved_type_signature`, `resolved_return_type`,
+ *    `definition_uri`, `definition_path`) are populated inline.
  * 2. **Refs**: Non-definition, non-local reference occurrences →
  *    `symbol_refs` rows with both `caller_id` and `callee_id` resolved
  *    using containment (which symbol's span encloses this ref?) and
  *    definition lookup (where is the referenced SCIP symbol defined?).
+ *    Enrichment columns are populated inline from the same SCIP data.
  *
  * SCIP refs are inserted **pre-resolved** with `resolution_method =
  * 'scip_definition'`.  The downstream resolution stage only processes
@@ -23,20 +29,32 @@
  *
  * Same tables as `SourceIndexStage`: `files`, `symbols`, `symbols_fts`,
  * `symbol_refs`, `type_refs`, `symbol_relationships`, `file_imports`.
+ * Additionally populates enrichment columns (type signatures, definition
+ * locations) inline during the same pass.
  *
  * ## Pipeline ordering
  *
  * This stage runs **before** `SourceIndexStage`.  It stores which
- * languages and files it handled in `context.scipSourcedLanguages` and
- * `context.scipSourcedFiles` so the tree-sitter path can skip them.
+ * languages and files it handled in `context.scipSourcedLanguages`,
+ * `context.scipSourcedFiles`, and `context.scipCoveredLanguages` so
+ * `SourceIndexStage` can skip full extraction (but still compute
+ * tree-sitter metrics) and `LspEnrichmentStage` knows not to re-enrich
+ * these languages.
  */
 import * as fs from 'node:fs';
 import * as crypto from 'node:crypto';
+import { tmpdir } from 'node:os';
 import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { fromBinary } from '@bufbuild/protobuf';
 import { IndexSchema, SymbolRole, } from '../../scip/scip_pb.js';
 import { normalizeTypeName } from '../../resolution/call-graph.js';
 import { SCIP_SUPPORTED_LANGUAGES, resolveScipIndexerRegistry } from '../../scip/registry.js';
+import { getLogger } from '../../logger.js';
+import { extractReturnType } from '../../scip/index-reader.js';
+import { getSpecsForLanguage, installScipIndexer } from '../../scip/installer.js';
+import { ensureCompilationDatabase } from '../../scip/compdb.js';
+import { EXT_TO_LANG } from '../../discovery/walker.js';
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { execFile } from 'node:child_process';
@@ -89,6 +107,10 @@ function inferKindFromScipSymbol(scipSymbol, docHint) {
             return 'constant';
         if (docHint.includes('(property)'))
             return 'property';
+        // scip-clang uses term descriptors for C/C++ functions:
+        //   ` $ funcName(hexhash).` — the (hash) indicates a function, not a variable.
+        if (/\([0-9a-f]{8,}\)\.$/.test(scipSymbol))
+            return 'function';
         return 'variable';
     }
     // Meta: ends with :
@@ -110,12 +132,17 @@ function extractNameFromScipSymbol(scipSymbol) {
     let cleaned = scipSymbol.replace(/[.#/:]$/, '');
     // For methods, strip the disambiguator: `name(+1).` → `name`
     cleaned = cleaned.replace(/\(\+?\d*\)$/, '');
+    // scip-clang uses ` $ name(hash)` for C/C++ symbols — strip the hash.
+    // E.g., ` $ parse_analyze_fixedparams(39d222e79bbfb7c0)` → `parse_analyze_fixedparams`
+    cleaned = cleaned.replace(/\([0-9a-f]{8,}\)$/, '');
     // Get the last descriptor's name
     // Descriptors are separated by ., #, /, :, or ()
     const parts = cleaned.split(/[.#/:]/);
     let name = parts[parts.length - 1] || '';
     // Remove backtick escaping
     name = name.replace(/`/g, '');
+    // Strip leading ` $ ` prefix used by scip-clang
+    name = name.replace(/^\s*\$\s*/, '');
     // Handle parameter descriptors like `(paramName)`
     if (name.startsWith('(') && name.endsWith(')')) {
         name = name.slice(1, -1);
@@ -243,11 +270,14 @@ function inferTypeRefKind(sourceLines, refLine, refChar) {
     return 'other';
 }
 // ─── Stage implementation ────────────────────────────────────────────────────
-export class ScipSourceStage {
-    name = 'scip-source';
+export class ScipIndexerStage {
+    name = 'scip-indexer';
     async execute(context, mode) {
         if (!context.scip?.enabled)
             return;
+        // SCIP only runs during baseline builds — never during overlay updates.
+        if (context.layer === 'overlay')
+            return;
         const log = context.log;
         const rootDir = context.walkerConfig.rootDir;
         // In update mode, determine which SCIP-supported languages have changed
@@ -266,19 +296,27 @@ export class ScipSourceStage {
                 }
             }
             if (staleLanguages.size === 0) {
-                log.indexing('scip-source: no SCIP-supported languages in changed files, skipping');
+                log.indexing('scip-indexer: no SCIP-supported languages in changed files, skipping');
                 return;
             }
-            log.indexing('scip-source: stale languages', { languages: [...staleLanguages] });
+            log.indexing('scip-indexer: stale languages', { languages: [...staleLanguages] });
         }
-        // Load SCIP index
-        const indexBuffer = await this.loadScipIndex(context.scip, rootDir, staleLanguages);
-        if (!indexBuffer) {
-            log.indexing('scip-source: no SCIP index available');
+        // Load SCIP indexes (one per indexer that succeeds)
+        const indexBuffers = await this.loadScipIndexes(context.scip, rootDir, staleLanguages);
+        if (indexBuffers.length === 0) {
+            log.indexing('scip-indexer: no SCIP index available');
             return;
         }
-        const scipIndex = fromBinary(IndexSchema, indexBuffer);
-        log.indexing('scip-source: loaded index', {
+        // Parse all SCIP index buffers and combine their documents
+        const allDocuments = [];
+        const allExternalSymbols = [];
+        for (const buf of indexBuffers) {
+            const parsed = fromBinary(IndexSchema, buf);
+            allDocuments.push(...parsed.documents);
+            allExternalSymbols.push(...parsed.externalSymbols);
+        }
+        const scipIndex = { documents: allDocuments, externalSymbols: allExternalSymbols };
+        log.indexing('scip-indexer: loaded index', {
             documents: scipIndex.documents.length,
             externalSymbols: scipIndex.externalSymbols.length,
         });
@@ -294,7 +332,7 @@ export class ScipSourceStage {
             if (loreLang)
                 coveredLanguages.add(loreLang);
         }
-        log.indexing('scip-source: languages covered', { languages: [...coveredLanguages] });
+        log.indexing('scip-indexer: languages covered', { languages: [...coveredLanguages] });
         // Determine the project's SCIP symbol prefix so we can distinguish
         // internal symbols from external ones (stdlib, node_modules, etc.).
         // Internal symbols are those whose SCIP string starts with the same
@@ -350,17 +388,19 @@ export class ScipSourceStage {
         const db = context.db;
         const branch = context.branch;
         // Prepared statements
-        const insertFile = db.prepare(`INSERT INTO files (path, branch, language, size_bytes, last_hash, source)
-       VALUES (?, ?, ?, ?, ?, ?)`);
-        const insertSymbol = db.prepare(`INSERT INTO symbols (file_id, name, kind, start_line, end_line, signature, doc_comment)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`);
-        const insertCallRef = db.prepare(`INSERT INTO symbol_refs (caller_id, file_id, callee_id, callee_name, call_line, call_character, call_kind, resolution_method)
+        const insertFile = db.prepare(`INSERT INTO files (path, branch, language, size_bytes, last_hash, source, layer, generation)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-        const insertTypeRef = db.prepare(`INSERT INTO type_refs (file_id, symbol_id, type_id, type_name, type_name_bare, ref_kind, ref_line, ref_character, resolution_method)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        const insertImport = db.prepare('INSERT INTO file_imports (file_id, raw_import) VALUES (?, ?)');
-        const insertRelationship = db.prepare(`INSERT INTO symbol_relationships (file_id, source_symbol_id, target_symbol_name, relationship_type, line, character, resolution_method)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        const insertSymbol = db.prepare(`INSERT INTO symbols (file_id, name, kind, start_line, end_line, signature, doc_comment, resolved_type_signature, resolved_return_type, definition_uri, definition_path, layer, generation)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertCallRef = db.prepare(`INSERT INTO symbol_refs (caller_id, file_id, callee_id, callee_name, call_line, call_character, call_kind, resolution_method, resolved_type_signature, resolved_return_type, definition_uri, definition_path, definition_line, definition_character, layer, generation)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertTypeRef = db.prepare(`INSERT INTO type_refs (file_id, symbol_id, type_id, type_name, type_name_bare, ref_kind, ref_line, ref_character, resolution_method, resolved_type_signature, definition_uri, definition_path, definition_line, definition_character, layer, generation)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertImport = db.prepare('INSERT INTO file_imports (file_id, raw_import, resolved_id, layer, generation) VALUES (?, ?, ?, ?, ?)');
+        const insertRelationship = db.prepare(`INSERT INTO symbol_relationships (file_id, source_symbol_id, target_symbol_name, relationship_type, line, character, resolution_method, definition_uri, definition_path, definition_line, definition_character, layer, generation)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const layer = context.layer;
+        const generation = context.generation;
         // Global map: SCIP symbol string → Lore numeric symbol ID (across all files)
         const scipToLoreId = new Map();
         // Pass 1: Create files and symbols
@@ -395,7 +435,7 @@ export class ScipSourceStage {
                     db.prepare('DELETE FROM files WHERE id = ?').run(existing.id);
                 }
                 // Insert file
-                const fileInfo = insertFile.run(absPath, branch, loreLang, sizeBytes, hash, source);
+                const fileInfo = insertFile.run(absPath, branch, loreLang, sizeBytes, hash, source, layer, generation);
                 const fileId = Number(fileInfo.lastInsertRowid);
                 fileIdMap.set(absPath, fileId);
                 coveredFiles.add(absPath);
@@ -452,13 +492,18 @@ export class ScipSourceStage {
                         continue;
                     const signature = extractSignatureFromDoc(firstDoc);
                     const docComment = symInfo.documentation.slice(1).join('\n').trim() || null;
-                    const info = insertSymbol.run(fileId, name, kind, defLoc.startLine, defLoc.endLine, signature || null, docComment);
+                    // Compute enrichment data inline (definition + type signature)
+                    const resolvedTypeSig = signature || null;
+                    const resolvedReturnType = extractReturnType(resolvedTypeSig);
+                    const definitionUri = pathToFileURL(absPath).toString();
+                    const info = insertSymbol.run(fileId, name, kind, defLoc.startLine, defLoc.endLine, signature || null, docComment, resolvedTypeSig, resolvedReturnType, definitionUri, absPath, layer, generation);
                     const loreId = Number(info.lastInsertRowid);
                     scipToLoreId.set(symInfo.symbol, loreId);
                 }
                 // Insert imports (from Import-role occurrences)
-                // Prefer the actual import path from source; fall back to SCIP package
-                const seenImports = new Set();
+                // Prefer the actual import path from source; fall back to SCIP package.
+                // Use symbolDefinitions to pre-resolve imports to target file IDs.
+                const seenImports = new Map(); // rawImport → resolved file ID
                 for (const occ of doc.occurrences) {
                     if ((occ.symbolRoles & SymbolRole.Import) !== 0 && occ.symbol) {
                         const importLine = occ.range[0] ?? 0;
@@ -474,9 +519,23 @@ export class ScipSourceStage {
                             const parts = occ.symbol.split(' ');
                             rawImport = parts.length >= 4 ? parts[3] : occ.symbol;
                         }
-                        if (rawImport && !seenImports.has(rawImport)) {
-                            seenImports.add(rawImport);
-                            insertImport.run(fileId, rawImport);
+                        if (!rawImport)
+                            continue;
+                        // Resolve the import's target file via SCIP symbol → definition location
+                        const defLoc = symbolDefinitions.get(occ.symbol);
+                        const resolvedFileId = defLoc ? (fileIdMap.get(defLoc.filePath) ?? null) : null;
+                        if (seenImports.has(rawImport)) {
+                            // If we already inserted this import without a resolved_id,
+                            // upgrade it now that we have one.
+                            if (resolvedFileId && !seenImports.get(rawImport)) {
+                                seenImports.set(rawImport, resolvedFileId);
+                                db.prepare('UPDATE file_imports SET resolved_id = ? WHERE file_id = ? AND raw_import = ?')
+                                    .run(resolvedFileId, fileId, rawImport);
+                            }
+                        }
+                        else {
+                            seenImports.set(rawImport, resolvedFileId);
+                            insertImport.run(fileId, rawImport, resolvedFileId, layer, generation);
                         }
                     }
                 }
@@ -516,7 +575,10 @@ export class ScipSourceStage {
                         // relationships for symbols whose definition is in another file or
                         // external package, so defLoc may be undefined.
                         const defLoc = symbolDefinitions.get(symInfo.symbol);
-                        insertRelationship.run(fileId, sourceId, targetName, relType, defLoc?.line ?? null, defLoc?.character ?? null, targetId ? 'scip_definition' : 'unresolved');
+                        // Resolve the target's definition location for enrichment
+                        const targetDef = symbolDefinitions.get(rel.symbol);
+                        const relDefUri = targetDef ? pathToFileURL(targetDef.filePath).toString() : null;
+                        insertRelationship.run(fileId, sourceId, targetName, relType, defLoc?.line ?? null, defLoc?.character ?? null, targetId ? 'scip_definition' : 'unresolved', relDefUri, targetDef?.filePath ?? null, targetDef?.line ?? null, targetDef?.character ?? null, layer, generation);
                         // If we have both source and target IDs, update the resolved target
                         if (targetId) {
                             db.prepare('UPDATE symbol_relationships SET target_symbol_id = ? WHERE file_id = ? AND source_symbol_id = ? AND target_symbol_name = ? AND relationship_type = ?').run(targetId, fileId, sourceId, targetName, relType);
@@ -526,7 +588,7 @@ export class ScipSourceStage {
             }
         });
         processDocuments();
-        log.indexing('scip-source: symbols inserted', {
+        log.indexing('scip-indexer: symbols inserted', {
             files: fileIdMap.size,
             symbols: scipToLoreId.size,
         });
@@ -655,21 +717,49 @@ export class ScipSourceStage {
                     }
                     if (refKind === 'type') {
                         const typeRefKind = inferTypeRefKind(sourceLines, line, character);
-                        insertTypeRef.run(fileId, callerId, calleeId, calleeName, normalizeTypeName(calleeName), typeRefKind, line, character, method);
-                        typeRefsInserted++;
+                        // Resolve enrichment metadata for the referenced type
+                        const refDef = symbolDefinitions.get(occ.symbol);
+                        const refInfo = symbolInfoMap.get(occ.symbol);
+                        const refSig = refInfo ? extractSignatureFromDoc(refInfo.documentation[0] ?? '') || null : null;
+                        const refDefUri = refDef ? pathToFileURL(refDef.filePath).toString() : null;
+                        try {
+                            insertTypeRef.run(fileId, callerId, calleeId ?? null, calleeName, normalizeTypeName(calleeName), typeRefKind, line, character, method, refSig, refDefUri, refDef?.filePath ?? null, refDef?.line ?? null, refDef?.character ?? null, layer, generation);
+                            typeRefsInserted++;
+                        }
+                        catch {
+                            // FK constraint failure — skip this ref
+                            refsNoCaller++;
+                        }
                     }
                     else {
                         // refKind === 'call'
-                        insertCallRef.run(callerId, fileId, calleeId, calleeName, line, character, 'direct', method);
-                        refsInserted++;
-                        if (isExternal)
-                            refsExternal++;
+                        // Skip if callee can't be resolved — FK constraint requires valid callee_id
+                        if (!calleeId) {
+                            refsNoCaller++;
+                            continue;
+                        }
+                        // Resolve enrichment metadata for the callee
+                        const refDef = symbolDefinitions.get(occ.symbol);
+                        const refInfo = symbolInfoMap.get(occ.symbol);
+                        const refSig = refInfo ? extractSignatureFromDoc(refInfo.documentation[0] ?? '') || null : null;
+                        const refReturnType = extractReturnType(refSig);
+                        const refDefUri = refDef ? pathToFileURL(refDef.filePath).toString() : null;
+                        try {
+                            insertCallRef.run(callerId, fileId, calleeId, calleeName, line, character, 'direct', method, refSig, refReturnType, refDefUri, refDef?.filePath ?? null, refDef?.line ?? null, refDef?.character ?? null, layer, generation);
+                            refsInserted++;
+                            if (isExternal)
+                                refsExternal++;
+                        }
+                        catch {
+                            // FK constraint failure — skip this ref
+                            refsNoCaller++;
+                        }
                     }
                 }
             }
         });
         processRefs();
-        log.indexing('scip-source: refs inserted', {
+        log.indexing('scip-indexer: refs inserted', {
             callRefs: refsInserted,
             typeRefs: typeRefsInserted,
             external: refsExternal,
@@ -680,6 +770,9 @@ export class ScipSourceStage {
         // Communicate coverage to downstream stages
         context.scipSourcedLanguages = coveredLanguages;
         context.scipSourcedFiles = coveredFiles;
+        // Also set scipCoveredLanguages so that LspEnrichmentStage skips
+        // languages already fully enriched by this single SCIP pass.
+        context.scipCoveredLanguages = coveredLanguages;
         // Add SCIP-sourced files to context.files so later stages process them
         for (const doc of scipIndex.documents) {
             const absPath = resolve(rootDir, doc.relativePath);
@@ -693,62 +786,191 @@ export class ScipSourceStage {
         // No persistent resources to clean up
     }
     // ─── SCIP index loading ──────────────────────────────────────────────────
-    async loadScipIndex(settings, rootDir, staleLanguages = null) {
+    async loadScipIndexes(settings, rootDir, staleLanguages = null) {
         // Try pre-computed index directory first
         if (settings.indexDir) {
+            const precomputed = [];
             // When staleLanguages is set, prefer per-language index files so
             // we only load the languages that actually need re-processing.
             if (staleLanguages) {
                 for (const lang of staleLanguages) {
                     const candidate = join(rootDir, settings.indexDir, `${lang}.scip`);
                     if (existsSync(candidate)) {
-                        return readFileSync(candidate);
+                        precomputed.push(readFileSync(candidate));
                     }
                 }
             }
-            const candidates = [
-                join(rootDir, settings.indexDir, 'index.scip'),
-                // Language-specific index files
-                ...['typescript', 'javascript', 'python', 'java', 'rust', 'c', 'cpp', 'csharp', 'ruby', 'php', 'go', 'dart'].map(lang => join(rootDir, settings.indexDir, `${lang}.scip`)),
-            ];
-            for (const candidate of candidates) {
-                if (existsSync(candidate)) {
-                    return readFileSync(candidate);
+            if (precomputed.length === 0) {
+                const candidates = [
+                    join(rootDir, settings.indexDir, 'index.scip'),
+                    ...['typescript', 'javascript', 'python', 'java', 'rust', 'c', 'cpp', 'csharp', 'ruby', 'php', 'go', 'dart'].map(lang => join(rootDir, settings.indexDir, `${lang}.scip`)),
+                ];
+                for (const candidate of candidates) {
+                    if (existsSync(candidate)) {
+                        precomputed.push(readFileSync(candidate));
+                    }
                 }
             }
+            if (precomputed.length > 0)
+                return precomputed;
         }
         // Try running an indexer
-        const resolvedIndexers = resolveScipIndexerRegistry(settings.indexers);
+        let resolvedIndexers = resolveScipIndexerRegistry(settings.indexers);
+        const log = getLogger();
+        // Check if any indexers are available; if not, try auto-installing
+        const requestedLanguages = staleLanguages ?? new Set(Object.keys(resolvedIndexers));
+        const hasAvailable = [...requestedLanguages].some((lang) => resolvedIndexers[lang]?.available);
+        if (!hasAvailable) {
+            const attempted = new Set();
+            for (const lang of requestedLanguages) {
+                for (const spec of getSpecsForLanguage(lang)) {
+                    if (attempted.has(spec.command))
+                        continue;
+                    attempted.add(spec.command);
+                    log.indexing(`scip-indexer: auto-installing ${spec.command} for ${lang}...`);
+                    const result = await installScipIndexer(spec);
+                    if (result.installed) {
+                        log.indexing(`scip-indexer: installed ${spec.command} at ${result.path}`);
+                    }
+                    else {
+                        log.indexing(`scip-indexer: could not install ${spec.command}: ${result.error ?? 'unknown'}`);
+                    }
+                }
+            }
+            // Re-resolve after installation
+            resolvedIndexers = resolveScipIndexerRegistry(settings.indexers);
+        }
+        // Determine which SCIP-supported languages actually exist in the project
+        // so we don't waste time running irrelevant indexers (e.g., scip-go on a C project).
+        const projectLanguages = staleLanguages ?? detectProjectLanguages(resolve(rootDir));
+        // Run all available indexers and merge results — don't stop at the first success.
+        // Group by shared command to avoid running the same indexer twice (e.g., scip-java for java/scala/kotlin).
+        const commandsRun = new Set();
+        const indexBuffers = [];
         for (const [lang, indexer] of Object.entries(resolvedIndexers)) {
             if (!indexer.available)
                 continue;
-            // Per-language staleness: skip indexers for languages that haven't changed.
-            if (staleLanguages && !staleLanguages.has(lang))
+            // Skip languages not present in the project
+            if (!projectLanguages.has(lang))
                 continue;
+            // Don't run the same command twice (e.g., scip-clang for both c and cpp)
+            if (commandsRun.has(indexer.command))
+                continue;
+            commandsRun.add(indexer.command);
             try {
-                const outputPath = join(rootDir, `.lore-scip-${lang}.scip`);
-                const args = indexer.args.map(a => a.replace(/\{output\}/g, outputPath));
+                const outputPath = resolve(rootDir, `.lore-scip-${lang}.scip`);
+                let args = indexer.args.map(a => a.replace(/\{output\}/g, outputPath));
+                const cwd = resolve(rootDir);
+                // For C/C++: ensure a compile_commands.json exists and pass it to scip-clang
+                if ((lang === 'c' || lang === 'cpp') && args.some(a => a.includes('{compdb}'))) {
+                    const compdb = await ensureCompilationDatabase(rootDir, settings.timeoutMs);
+                    if (!compdb.path) {
+                        log.indexing(`scip-indexer: no compile_commands.json for ${lang}, skipping`);
+                        continue;
+                    }
+                    args = args.map(a => a.replace(/\{compdb\}/g, compdb.path));
+                }
+                // For TypeScript: generate a broad tsconfig so scip-typescript
+                // indexes ALL .ts files (including tests), not just those in the
+                // project's tsconfig "include" (which typically excludes tests).
+                let tempTsconfigPath = null;
+                if (lang === 'typescript') {
+                    tempTsconfigPath = createLoreScipTsconfig(rootDir);
+                    if (tempTsconfigPath) {
+                        args.push(tempTsconfigPath);
+                    }
+                }
+                // scip-clang needs a longer timeout for large C projects
+                const indexerTimeout = (lang === 'c' || lang === 'cpp')
+                    ? Math.max(settings.timeoutMs, 600_000)
+                    : settings.timeoutMs;
                 const execFileAsync = promisify(execFile);
-                await execFileAsync(indexer.command, args, {
-                    cwd: rootDir,
-                    timeout: settings.timeoutMs,
-                });
+                const executablePath = indexer.resolvedPath ?? indexer.command;
+                try {
+                    await execFileAsync(executablePath, args, {
+                        cwd,
+                        timeout: indexerTimeout,
+                    });
+                }
+                finally {
+                    if (tempTsconfigPath) {
+                        try {
+                            fs.unlinkSync(tempTsconfigPath);
+                        }
+                        catch { /* best effort */ }
+                    }
+                }
                 // Check for output
-                for (const candidate of [outputPath, join(rootDir, 'index.scip')]) {
+                for (const candidate of [outputPath, resolve(rootDir, 'index.scip')]) {
                     if (existsSync(candidate)) {
                         const data = readFileSync(candidate);
                         try {
                             fs.unlinkSync(candidate);
                         }
                         catch { /* best effort */ }
-                        return data;
+                        indexBuffers.push(data);
+                        break;
                     }
                 }
             }
-            catch {
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                log.indexing(`scip-indexer: indexer failed for ${lang}: ${msg}`);
                 continue;
             }
         }
+        return indexBuffers;
+    }
+}
+// ─── Temporary tsconfig for broad SCIP indexing ─────────────────────────────
+/** Fields that only affect build output, not type-checking or SCIP indexing. */
+const TSCONFIG_BUILD_ONLY_FIELDS = [
+    'outDir', 'rootDir', 'declaration', 'declarationMap', 'declarationDir',
+    'sourceMap', 'inlineSourceMap', 'inlineSources', 'composite',
+    'tsBuildInfoFile', 'emitDeclarationOnly',
+];
+/**
+ * Generate a temporary tsconfig that includes **all** `.ts`/`.tsx` files
+ * in the project, so `scip-typescript` indexes tests and other files
+ * excluded by the project's production tsconfig.
+ *
+ * The file is written to `os.tmpdir()` so the indexed repo is never mutated.
+ * Include/exclude globs use absolute paths rooted at `rootDir` so
+ * `scip-typescript` resolves source files correctly even though the
+ * tsconfig lives elsewhere.
+ *
+ * Strips build-only compiler options (`outDir`, `rootDir`, `declaration`,
+ * etc.) that would conflict with the broad `include` and are irrelevant
+ * for SCIP analysis.  Preserves all type-checking options (`strict`,
+ * `paths`, `baseUrl`, etc.) so SCIP still resolves types correctly.
+ *
+ * Returns the path to the temp file, or `null` if no tsconfig exists.
+ */
+export function createLoreScipTsconfig(rootDir) {
+    const log = getLogger();
+    const tsconfigPath = join(rootDir, 'tsconfig.json');
+    if (!existsSync(tsconfigPath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(tsconfigPath, 'utf8'));
+        const compilerOptions = { ...(raw.compilerOptions ?? {}) };
+        // Strip build-only fields
+        for (const field of TSCONFIG_BUILD_ONLY_FIELDS) {
+            delete compilerOptions[field];
+        }
+        // Use absolute paths so the tsconfig works from tmpdir
+        const absRoot = resolve(rootDir);
+        const loreTsconfig = {
+            compilerOptions,
+            include: [join(absRoot, '**/*.ts'), join(absRoot, '**/*.tsx')],
+            exclude: (raw.exclude ?? ['node_modules']).map((e) => join(absRoot, e)),
+        };
+        const outPath = join(tmpdir(), `lore-scip-${crypto.randomUUID()}.json`);
+        fs.writeFileSync(outPath, JSON.stringify(loreTsconfig, null, 2));
+        log.debug('scip', `generated broad tsconfig for SCIP: ${outPath}`);
+        return outPath;
+    }
+    catch {
         return null;
     }
 }
@@ -769,6 +991,10 @@ function classifyScipReference(scipSymbol) {
     // Method/function: ends with ().  or (+N).  (with disambiguator)
     if (/\(\+?\d*\)\.$/.test(scipSymbol))
         return 'call';
+    // scip-clang C/C++ functions: term descriptors ending with `(hexhash).`
+    // E.g., `$ parse_analyze_fixedparams(39d222e79bbfb7c0).`
+    if (/\([0-9a-f]{8,}\)\.$/.test(scipSymbol))
+        return 'call';
     // Type: ends with #
     if (scipSymbol.endsWith('#'))
         return 'type';
@@ -871,32 +1097,65 @@ const SCIP_LANG_MAP = {
     go: 'go',
     dart: 'dart',
 };
-const EXT_TO_LANG = {
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.js': 'javascript',
-    '.jsx': 'javascript',
-    '.mjs': 'javascript',
-    '.cjs': 'javascript',
-    '.py': 'python',
-    '.java': 'java',
-    '.scala': 'scala',
-    '.sc': 'scala',
-    '.kt': 'kotlin',
-    '.kts': 'kotlin',
-    '.rs': 'rust',
-    '.c': 'c',
-    '.h': 'c',
-    '.cpp': 'cpp',
-    '.cc': 'cpp',
-    '.cxx': 'cpp',
-    '.hpp': 'cpp',
-    '.cs': 'csharp',
-    '.rb': 'ruby',
-    '.php': 'php',
-    '.go': 'go',
-    '.dart': 'dart',
-};
+/**
+ * Quick scan of the project root to detect which SCIP-supported languages
+ * are present.  Checks for telltale file extensions and build files.
+ * Only scans top-level + one directory deep to stay fast.
+ */
+function detectProjectLanguages(rootDir) {
+    const found = new Set();
+    const langIndicators = {
+        typescript: ['tsconfig.json', 'package.json'],
+        python: ['setup.py', 'pyproject.toml', 'requirements.txt'],
+        java: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+        rust: ['Cargo.toml'],
+        c: ['Makefile', 'CMakeLists.txt', 'meson.build', 'configure', 'configure.ac'],
+        cpp: ['CMakeLists.txt', 'meson.build'],
+        csharp: ['.csproj', '.sln'],
+        ruby: ['Gemfile'],
+        go: ['go.mod'],
+        php: ['composer.json'],
+        dart: ['pubspec.yaml'],
+    };
+    // Check for language indicator files at the root
+    for (const [lang, indicators] of Object.entries(langIndicators)) {
+        for (const indicator of indicators) {
+            if (existsSync(join(rootDir, indicator))) {
+                found.add(lang);
+                break;
+            }
+        }
+    }
+    // Quick extension scan: read first-level directory entries
+    try {
+        const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                const ext = entry.name.slice(entry.name.lastIndexOf('.')).toLowerCase();
+                const lang = EXT_TO_LANG[ext];
+                if (lang && SCIP_SUPPORTED_LANGUAGES.has(lang))
+                    found.add(lang);
+            }
+            else if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+                // One level deep
+                try {
+                    const subEntries = fs.readdirSync(join(rootDir, entry.name), { withFileTypes: true });
+                    for (const sub of subEntries.slice(0, 50)) { // Limit to avoid scanning huge dirs
+                        if (sub.isFile()) {
+                            const ext = sub.name.slice(sub.name.lastIndexOf('.')).toLowerCase();
+                            const lang = EXT_TO_LANG[ext];
+                            if (lang && SCIP_SUPPORTED_LANGUAGES.has(lang))
+                                found.add(lang);
+                        }
+                    }
+                }
+                catch { /* ignore permission errors */ }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return found;
+}
 /**
  * Determine the Lore language for a SCIP document.
  *
@@ -921,4 +1180,4 @@ function inferLoreLanguage(scipLanguage, relativePath) {
 // ─── Test-visible helpers ───────────────────────────────────────────────────
 // Exported for unit testing only.  Not part of the public API.
 export { estimateSymbolEndLine as _estimateSymbolEndLine, inferTypeRefKind as _inferTypeRefKind, extractImportPathFromSource as _extractImportPathFromSource, inferKindFromScipSymbol as _inferKindFromScipSymbol, inferLoreLanguage as _inferLoreLanguage, classifyScipReference as _classifyScipReference, extractNameFromScipSymbol as _extractNameFromScipSymbol, };
-//# sourceMappingURL=scip-source.js.map
+//# sourceMappingURL=scip-indexer.js.map