devsmind-mcp 2.4.0 → 4.0.0

package/dist/cli/runner.js

@@ -36,6 +36,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeHttpRequest = makeHttpRequest;
+exports.sleep = sleep;
+exports.throttleRpm = throttleRpm;
+exports.getAccessTokenFromServiceAccount = getAccessTokenFromServiceAccount;
+exports.getVertexTokenCached = getVertexTokenCached;
 exports.runBackgroundIndexing = runBackgroundIndexing;
 exports.runBackgroundReindexing = runBackgroundReindexing;
 const fs = __importStar(require("fs"));
@@ -48,9 +53,12 @@ const database_1 = require("../db/database");
 const indexer_1 = require("../db/indexer");
 const scanner_1 = require("../utils/scanner");
 const config_1 = require("../utils/config");
-const json_1 = require("../utils/json");
 const ast_1 = require("../utils/ast");
 const edges_1 = require("../db/edges");
+const extract_agent_1 = require("./extract-agent");
+const describe_1 = require("./describe");
+/** Exported for reuse by `src/cli/llm-client.ts` (the `devsmind describe` backfill) — plain
+ * request/response, nothing indexing-specific about it. */
 function makeHttpRequest(urlStr, method, headers, body) {
     return new Promise((resolve, reject) => {
         const isHttps = urlStr.startsWith('https');
@@ -93,8 +101,10 @@ function sleep(ms) {
 }
 // ── LLM request pacing ───────────────────────────────────────────────────
 // Off by default — requests fire as fast as possible and 429s are handled by
-// the retry/backoff in extractNodesFromCode. Pass --rpm to proactively space
-// out requests and stay under a known quota instead of reacting after the fact.
+// the retry/backoff in sendConversationTurnWithRetry (llm-client.ts). Pass --rpm to
+// proactively space out requests and stay under a known quota instead of reacting after the fact.
+// Module-global on purpose: `devsmind describe` shares this same pacing budget with indexing
+// if both were ever run in the same process, which is the correct behavior (one shared quota).
 let lastLlmCallAt = 0;
 async function throttleRpm(rpm) {
     if (!rpm || rpm <= 0)
@@ -270,22 +280,6 @@ class ProgressDisplay {
         console.log(`  ${checkmark} ${summary}  \x1B[90m(total: ${fmtMs(elapsed)}, avg: ${avg > 0 ? fmtMs(avg) : '—'}/item)\x1B[0m`);
     }
 }
-// Build standard taxonomy prompt text
-const TAXONOMY_PROMPT = `
-Choose node types from this taxonomy:
-- UNIVERSAL: function | method | class | abstract_class | interface | type_alias | enum | constant | variable | module | namespace | decorator
-- NESTJS: nest_module | nest_controller | nest_service | nest_provider | nest_guard | nest_interceptor | nest_pipe | nest_filter | nest_decorator | nest_middleware | nest_gateway | nest_resolver | nest_schema | nest_dto
-- EXPRESS/FASTIFY: route_handler | middleware | router
-- SPRING (Java): spring_controller | spring_service | spring_repository | spring_component | spring_bean | spring_config | spring_entity
-- DJANGO/FASTAPI: django_view | django_model | django_serializer | django_form | django_signal | fastapi_router | fastapi_dependency
-- GO: go_handler | go_middleware | go_struct | go_interface | go_func
-- RUST: rust_struct | rust_impl | rust_trait | rust_enum | rust_fn | rust_macro
-- REACT/NEXTJS: react_component | react_hook | react_context | react_hoc | react_page | next_page | next_layout | next_api_route | next_server_action
-- ORM: prisma_model | typeorm_entity | mongoose_model | sqlalchemy_model
-- REST/API/GRAPHQL: api_endpoint | rest_controller | graphql_resolver | graphql_query | graphql_mutation | graphql_schema
-- CLI: cli_command | cli_option
-- UTILITY: util_function | helper | validator | formatter
-`;
 // ── Vertex AI Authentication & Helper Functions ───────────────────────────
 function base64UrlEncode(obj) {
     return Buffer.from(JSON.stringify(obj))
@@ -374,237 +368,6 @@ async function getVertexTokenCached(saData) {
     vertexTokenExpiry = Date.now() + 3600 * 1000;
     return token;
 }
-async function extractWithVertex(model, token, projectId, location, filePath, code) {
-    const url = `https://${location}-aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:generateContent`;
-    const systemPrompt = `You are a codebase indexing assistant. Your job is to analyze the source code file provided and extract all code structures (functions, methods, classes, controllers, services, interfaces, schema models, types) defined in the file.
-Return ONLY a valid JSON object matching the schema:
-{
-  "nodes": [
-    { 
-      "node_id": "fully_qualified_identifier (e.g. Class.method or function)", 
-      "name": "display_name", 
-      "type": "type_from_taxonomy", 
-      "signature": "param/return signature (optional)",
-      "code_snapshot": "the exact full source code block of this entity"
-    }
-  ]
-}
-${TAXONOMY_PROMPT}
-CRITICAL RULES:
-1. ONLY extract code structures defined in the file. Do NOT extract imports or third-party libraries as nodes.
-2. For each node, extract its exact code snippet as "code_snapshot".
-3. DO NOT wrap JSON in markdown blocks (e.g. no \`\`\`json). Return raw JSON.
-4. Be highly precise and return an empty JSON object if no code constructs are found.`;
-    const payload = {
-        contents: [
-            {
-                role: 'user',
-                parts: [
-                    {
-                        text: `File path: ${filePath}\n\nCode:\n${code}`
-                    }
-                ]
-            }
-        ],
-        systemInstruction: {
-            parts: [
-                {
-                    text: systemPrompt
-                }
-            ]
-        },
-        generationConfig: {
-            responseMimeType: 'application/json'
-        }
-    };
-    const responseText = await makeHttpRequest(url, 'POST', {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${token}`
-    }, JSON.stringify(payload));
-    const parsed = (0, json_1.safeJsonParse)(responseText, {});
-    const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
-    if (!text) {
-        return {};
-    }
-    return (0, json_1.safeJsonParse)(text, {});
-}
-async function extractWithGemini(model, key, filePath, code) {
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${key}`;
-    const systemPrompt = `You are a codebase indexing assistant. Your job is to analyze the source code file provided and extract all code structures (functions, methods, classes, controllers, services, interfaces, schema models, types) defined in the file.
-Return ONLY a valid JSON object matching the schema:
-{
-  "nodes": [
-    { 
-      "node_id": "fully_qualified_identifier (e.g. Class.method or function)", 
-      "name": "display_name", 
-      "type": "type_from_taxonomy", 
-      "signature": "param/return signature (optional)",
-      "code_snapshot": "the exact full source code block of this entity"
-    }
-  ]
-}
-${TAXONOMY_PROMPT}
-CRITICAL RULES:
-1. ONLY extract code structures defined in the file. Do NOT extract imports or third-party libraries as nodes.
-2. For each node, extract its exact code snippet as "code_snapshot".
-3. DO NOT wrap JSON in markdown blocks (e.g. no \`\`\`json). Return raw JSON.
-4. Be highly precise and return an empty JSON object if no code constructs are found.`;
-    const payload = {
-        contents: [
-            {
-                parts: [
-                    {
-                        text: `File path: ${filePath}\n\nCode:\n${code}`
-                    }
-                ]
-            }
-        ],
-        systemInstruction: {
-            parts: [
-                {
-                    text: systemPrompt
-                }
-            ]
-        },
-        generationConfig: {
-            responseMimeType: 'application/json'
-        }
-    };
-    const responseText = await makeHttpRequest(url, 'POST', { 'Content-Type': 'application/json' }, JSON.stringify(payload));
-    const parsed = (0, json_1.safeJsonParse)(responseText, {});
-    const text = parsed.candidates?.[0]?.content?.parts?.[0]?.text;
-    if (!text) {
-        return {};
-    }
-    return (0, json_1.safeJsonParse)(text, {});
-}
-async function extractWithOllama(url, model, filePath, code) {
-    const endpoint = `${url.replace(/\/$/, '')}/api/chat`;
-    const systemPrompt = `You are a codebase indexing assistant. Analyze this source code file and extract code structures (functions, classes, methods, endpoints).
-Return ONLY a valid JSON object matching the schema:
-{
-  "nodes": [
-    { 
-      "node_id": "unique_string (e.g. Class.method or function)", 
-      "name": "display_name", 
-      "type": "type_from_taxonomy", 
-      "signature": "param/return signature (optional)",
-      "code_snapshot": "the exact full source code block of this entity"
-    }
-  ]
-}
-${TAXONOMY_PROMPT}
-CRITICAL RULES:
-1. ONLY extract constructs defined in this file. Do NOT extract third-party libraries or imports.
-2. For each node, extract its exact code snippet as "code_snapshot".
-3. Return a clean, valid JSON object.`;
-    const userPrompt = `File path: ${filePath}\n\nCode:\n${code}`;
-    const payload = {
-        model,
-        messages: [
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: userPrompt }
-        ],
-        stream: false,
-        format: 'json'
-    };
-    const responseText = await makeHttpRequest(endpoint, 'POST', { 'Content-Type': 'application/json' }, JSON.stringify(payload));
-    const parsed = (0, json_1.safeJsonParse)(responseText, {});
-    const text = parsed.message?.content;
-    if (!text) {
-        return {};
-    }
-    return (0, json_1.safeJsonParse)(text, {});
-}
-async function extractNodesFromCode(provider, modelName, key, url, filePath, code, getVertexToken, vertexProjectId, vertexLocation, progress, chunkSize, chunkOverlap, rpm) {
-    // Chunking is opt-in: with no --chunk-size, the whole file always goes in one call.
-    const maxLines = chunkSize;
-    const overlap = chunkOverlap ?? 50;
-    const lines = code.split('\n');
-    const executeExtraction = async (codeChunk) => {
-        let retries = 5;
-        let backoffMs = 10000;
-        while (retries > 0) {
-            try {
-                await throttleRpm(rpm);
-                if (provider === 'gemini') {
-                    return await extractWithGemini(modelName, key, filePath, codeChunk);
-                }
-                else if (provider === 'vertex') {
-                    const token = await getVertexToken();
-                    return await extractWithVertex(modelName, token, vertexProjectId, vertexLocation, filePath, codeChunk);
-                }
-                else {
-                    return await extractWithOllama(url, modelName, filePath, codeChunk);
-                }
-            }
-            catch (err) {
-                retries--;
-                if (retries === 0) {
-                    throw err;
-                }
-                const errMsg = err.message;
-                if (errMsg.includes('429')) {
-                    progress.updateStatus(`Rate limited (429). Retrying in ${backoffMs / 1000}s...`);
-                    await sleep(backoffMs);
-                    backoffMs *= 2;
-                }
-                else {
-                    progress.updateStatus(`API error. Retrying in 2s...`);
-                    await sleep(2000);
-                }
-            }
-        }
-        return {};
-    };
-    if (!maxLines || lines.length <= maxLines) {
-        return await executeExtraction(code);
-    }
-    const relPath = path.relative(process.cwd(), filePath);
-    progress.log(`\x1B[90m[${relPath}] Large file (${lines.length} lines) - parsing in chunks to prevent LLM output truncation...\x1B[0m`);
-    const chunks = [];
-    let start = 0;
-    // Guard against overlap >= chunkSize, which would make the step <= 0 and loop forever.
-    const step = Math.max(1, maxLines - overlap);
-    while (start < lines.length) {
-        const end = Math.min(start + maxLines, lines.length);
-        chunks.push(lines.slice(start, end).join('\n'));
-        if (end === lines.length)
-            break;
-        start += step;
-    }
-    const seenNodeIds = new Map();
-    for (let i = 0; i < chunks.length; i++) {
-        progress.updateStatus(`Sending chunk ${i + 1}/${chunks.length} to AI…`);
-        const chunkCode = chunks[i];
-        try {
-            const chunkResult = await executeExtraction(chunkCode);
-            if (chunkResult.nodes && Array.isArray(chunkResult.nodes)) {
-                for (const node of chunkResult.nodes) {
-                    if (!node.node_id)
-                        continue;
-                    const existing = seenNodeIds.get(node.node_id);
-                    if (!existing || (node.code_snapshot && (!existing.code_snapshot || node.code_snapshot.length > existing.code_snapshot.length))) {
-                        seenNodeIds.set(node.node_id, node);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            progress.log(`\x1B[31mError extracting chunk ${i + 1}/${chunks.length}: ${err.message}\x1B[0m`);
-            throw err;
-        }
-        if (i < chunks.length - 1) {
-            if (provider === 'gemini' || provider === 'vertex') {
-                await sleep(1500);
-            }
-            else {
-                await sleep(100);
-            }
-        }
-    }
-    return { nodes: Array.from(seenNodeIds.values()) };
-}
 async function runBackgroundIndexing(opts) {
     const resolvedDevmind = path.resolve(opts.devmindPath);
     const chunkSize = opts.chunkSize;
@@ -613,6 +376,13 @@ async function runBackgroundIndexing(opts) {
     const nodesOnly = !!opts.nodesOnly;
     const edgesOnly = !!opts.edgesOnly;
     const rpm = opts.rpm;
+    // Phase 3 (description backfill) is MANDATORY on a full run (neither --nodes-only nor
+    // --edges-only) — Phase 1/2 never write a description, so skipping it would leave a "finished"
+    // index that's not actually searchable by search_nodes' description-weighted BM25/vector layers.
+    // On --nodes-only it's an optional extra pass on top of the structure-only extraction, gated by
+    // --describe, since --nodes-only exists specifically for a fast partial run. --edges-only never
+    // resolves credentials or creates nodes, so it's never eligible (also rejected upfront in index.ts).
+    const shouldDescribe = edgesOnly ? false : (nodesOnly ? !!opts.describe : true);
     // Repo scoping: restrict the whole operation to the named repos. Standalone-only.
     const scopedRepos = opts.repos && opts.repos.length ? opts.repos : null;
     const inScope = (nodeId) => !scopedRepos || scopedRepos.some(r => nodeId.startsWith(`{${r}}/`));
@@ -663,7 +433,13 @@ async function runBackgroundIndexing(opts) {
     console.log(`   Brain directory : ${resolvedDevmind}`);
     console.log(`   Provider        : ${opts.provider}`);
     console.log(`   Connections     : local AST resolution (always)`);
-    console.log(`   Chunking        : ${chunkSize ? `${chunkSize} lines (overlap: ${chunkOverlap ?? 50})` : 'off — whole file per call'}`);
+    console.log(`   Extraction      : deterministic AST enumeration + agentic curation of ambiguous candidates only`);
+    console.log(`   Describe        : ${edgesOnly ? 'n/a (--edges-only never creates nodes)'
+        : nodesOnly ? (shouldDescribe ? 'enabled via --describe — Phase 3 will backfill descriptions after extraction' : 'disabled (pass --describe to also backfill descriptions after this --nodes-only run)')
+            : 'mandatory for a full run — Phase 3 will backfill descriptions after indexing'}`);
+    if (chunkSize) {
+        console.log(`   ⚠ --chunk-size is ignored — extraction is per-candidate now (AST-enumerated), not whole-file-to-an-LLM, so chunking a huge file no longer applies.`);
+    }
     console.log(`   Rate limit      : ${rpm ? `${rpm} req/min` : 'unthrottled'}`);
     let modelName = opts.model || '';
     let vertexSaData = null;
@@ -720,13 +496,18 @@ async function runBackgroundIndexing(opts) {
         }
         console.log(`   Model           : ${modelName}`);
     }
-    const getVertexToken = async () => {
-        if (vertexToken)
-            return vertexToken;
-        if (vertexSaData) {
-            return await getVertexTokenCached(vertexSaData);
-        }
-        throw new Error('No Vertex credentials available');
+    // Built once here from whatever the provider-specific block above resolved — the ONE place
+    // per-file extraction needs credentials from, instead of threading five separate params
+    // through every call the way `extractNodesFromCode` used to.
+    const llmCreds = {
+        provider: opts.provider,
+        model: modelName,
+        apiKey: opts.key,
+        vertexSaData: vertexSaData || undefined,
+        vertexToken: vertexToken || undefined,
+        vertexProjectId,
+        vertexLocation,
+        url: opts.url
     };
     // 1. Open DB
     const dbFile = path.join(resolvedDevmind, 'brain.db');
@@ -759,18 +540,23 @@ async function runBackgroundIndexing(opts) {
     if (edgesOnly) {
         // All nodes stay in the candidate pool (targets can live in any repo/file), but when
         // scoped we only rebuild edges ORIGINATING from the named repos' nodes.
-        const allNodes = db.listNodes();
-        if (allNodes.length === 0) {
+        const rawNodes = db.listNodes();
+        if (rawNodes.length === 0) {
             console.error('❌ Error: --edges-only requires nodes to already exist. Run without --edges-only first (or with --nodes-only) to extract nodes.');
             db.close();
             process.exit(1);
         }
-        const existingNodes = scopedRepos ? allNodes.filter(n => inScope(n.id)) : allNodes;
+        const existingNodes = scopedRepos ? rawNodes.filter(n => inScope(n.id)) : rawNodes;
         if (existingNodes.length === 0) {
             console.error(`❌ Error: no nodes found for repo(s): ${scopedRepos?.join(', ')}. Extract nodes first.`);
             db.close();
             process.exit(1);
         }
+        // Deterministic alias detection (RTK Query hook names, etc.) over this batch's files, BEFORE
+        // the candidate pool is fetched, so the resolver below sees any freshly-attached aliases in
+        // this SAME run rather than needing a second pass.
+        (0, edges_1.applyDeterministicAliases)(db, existingNodes.map(n => n.id));
+        const allNodes = db.listNodes();
         let edgePad = (0, indexer_1.readScratchpad)(resolvedDevmind, padFile);
         let resumeIndex = 0;
         // Scoped runs never resume the shared scratchpad (its counts describe a different set).
@@ -898,10 +684,13 @@ async function runBackgroundIndexing(opts) {
                 continue;
             }
             const fileLines = code.split('\n').length;
-            progress.updateStatus(`Reading ${fileLines} lines — sending to AI…`);
+            progress.updateStatus(`Enumerating candidates deterministically…`);
             let result = {};
             try {
-                result = await extractNodesFromCode(opts.provider, modelName, opts.key, opts.url, fileObj.absolutePath, code, getVertexToken, vertexProjectId, vertexLocation, progress, chunkSize, chunkOverlap, rpm);
+                result = await (0, extract_agent_1.extractFileWithCuration)(llmCreds, fileObj.absolutePath, {
+                    rpm,
+                    onLog: (line) => progress.log(line)
+                });
             }
             catch (err) {
                 progress.finishPhase(`Paused — API error. Run again to resume.`);
@@ -993,10 +782,15 @@ async function runBackgroundIndexing(opts) {
     // PHASE 2: AI CONNECTION RESOLUTION / LINKING
     // =========================================================================
     if (pad.phase === 2 && !nodesOnly) {
-        const allNodes = db.listNodes();
-        const allNodeIds = allNodes.map(n => n.id);
+        const rawNodes = db.listNodes();
         // Candidates are always all nodes; when scoped we only (re)build edges from the
         // named repos' nodes and clear just those first so we don't wipe other repos' edges.
+        const activeNodesForAlias = scopedRepos ? rawNodes.filter(n => inScope(n.id)) : rawNodes;
+        // Deterministic alias detection (RTK Query hook names, etc.) BEFORE the candidate pool is
+        // fetched, so the resolver below sees any freshly-attached aliases in this SAME run.
+        (0, edges_1.applyDeterministicAliases)(db, activeNodesForAlias.map(n => n.id));
+        const allNodes = db.listNodes();
+        const allNodeIds = allNodes.map(n => n.id);
         const activeNodes = scopedRepos ? allNodes.filter(n => inScope(n.id)) : allNodes;
         const resumeIndex = pad.nodes_done || 0;
         if (scopedRepos && resumeIndex === 0) {
@@ -1037,6 +831,16 @@ async function runBackgroundIndexing(opts) {
         progress.finishPhase(`Phase 2 done — ${pad.connections_created} connection(s) linked across ${pad.nodes_total} node(s)`);
         (0, edges_1.finalizeMissingNodes)(resolvedDevmind, db, missingRefs);
     }
+    // =========================================================================
+    // PHASE 3: DESCRIPTION BACKFILL — mandatory on a full run, optional (--describe) on --nodes-only
+    // =========================================================================
+    let describeResult = null;
+    if (shouldDescribe) {
+        console.log(`\n${'═'.repeat(60)}`);
+        console.log(` Phase 3: Description Backfill`);
+        console.log(`${'═'.repeat(60)}\n`);
+        describeResult = await (0, describe_1.describePendingNodes)(db, llmCreds, { batchSize: opts.describeBatchSize, rpm });
+    }
     // Mark indexing session as fully complete
     pad.status = 'complete';
     pad.updated_at = new Date().toISOString();
@@ -1047,7 +851,10 @@ async function runBackgroundIndexing(opts) {
     console.log('\x1B[1m\x1B[32m  ✔ Indexing complete!\x1B[0m');
     console.log(`  ├─ Files indexed  : \x1B[33m${pad.files_done}\x1B[0m`);
     console.log(`  ├─ Nodes created  : \x1B[33m${pad.nodes_created}\x1B[0m`);
-    console.log(`  └─ Connections    : \x1B[33m${pad.connections_created}\x1B[0m`);
+    console.log(describeResult ? `  ├─ Connections    : \x1B[33m${pad.connections_created}\x1B[0m` : `  └─ Connections    : \x1B[33m${pad.connections_created}\x1B[0m`);
+    if (describeResult) {
+        console.log(`  └─ Described      : \x1B[33m${describeResult.described}\x1B[0m/${describeResult.pending}${describeResult.failed ? ` (${describeResult.failed} failed — re-run with --describe to retry)` : ''}`);
+    }
     console.log('');
 }
 async function runBackgroundReindexing(opts) {
@@ -1060,7 +867,10 @@ async function runBackgroundReindexing(opts) {
     console.log(`   Brain directory : ${resolvedDevmind}`);
     console.log(`   Provider        : ${opts.provider}`);
     console.log(`   Connections     : local AST resolution (always)`);
-    console.log(`   Chunking        : ${chunkSize ? `${chunkSize} lines (overlap: ${chunkOverlap ?? 50})` : 'off — whole file per call'}`);
+    console.log(`   Extraction      : deterministic AST enumeration + agentic curation of ambiguous candidates only`);
+    if (chunkSize) {
+        console.log(`   ⚠ --chunk-size is ignored — extraction is per-candidate now (AST-enumerated), not whole-file-to-an-LLM, so chunking a huge file no longer applies.`);
+    }
     console.log(`   Rate limit      : ${rpm ? `${rpm} req/min` : 'unthrottled'}`);
     let modelName = opts.model || '';
     let vertexSaData = null;
@@ -1112,13 +922,15 @@ async function runBackgroundReindexing(opts) {
         modelName = modelName || 'qwen2.5-coder';
         opts.url = opts.url || 'http://localhost:11434';
     }
-    const getVertexToken = async () => {
-        if (vertexToken)
-            return vertexToken;
-        if (vertexSaData) {
-            return await getVertexTokenCached(vertexSaData);
-        }
-        throw new Error('No Vertex credentials available');
+    const llmCreds = {
+        provider: opts.provider,
+        model: modelName,
+        apiKey: opts.key,
+        vertexSaData: vertexSaData || undefined,
+        vertexToken: vertexToken || undefined,
+        vertexProjectId,
+        vertexLocation,
+        url: opts.url
     };
     console.log(`   Model           : ${modelName}`);
     // 1. Open DB
@@ -1219,10 +1031,13 @@ async function runBackgroundReindexing(opts) {
             continue;
         }
         const fileLines = code.split('\n').length;
-        progress.updateStatus(`Reading ${fileLines} lines — sending to AI…`);
+        progress.updateStatus(`Enumerating candidates deterministically…`);
         let result = {};
         try {
-            result = await extractNodesFromCode(opts.provider, modelName, opts.key, opts.url, fileObj.absolutePath, code, getVertexToken, vertexProjectId, vertexLocation, progress, chunkSize, chunkOverlap, rpm);
+            result = await (0, extract_agent_1.extractFileWithCuration)(llmCreds, fileObj.absolutePath, {
+                rpm,
+                onLog: (line) => progress.log(line)
+            });
         }
         catch (err) {
             if (fillGaps) {
@@ -1291,6 +1106,8 @@ async function runBackgroundReindexing(opts) {
         // re-resolving the new nodes' own outbound edges isn't enough. This is local AST
         // resolution (no LLM calls), so rebuilding it across the whole graph is cheap and
         // safe to repeat.
+        const rawNodesForAlias = db.listNodes();
+        (0, edges_1.applyDeterministicAliases)(db, rawNodesForAlias.map(n => n.id));
         const activeNodes = db.listNodes();
         const allNodeIds = new Set(activeNodes.map(n => n.id));
         console.log('\n🧹 Clearing existing connections for a full rebuild...');
@@ -1332,6 +1149,7 @@ async function runBackgroundReindexing(opts) {
     }
     // Phase 2: Resolving connections for modified nodes
     if (newOrUpdatedNodeIds.length > 0) {
+        (0, edges_1.applyDeterministicAliases)(db, newOrUpdatedNodeIds);
         const activeNodes = db.listNodes();
         const allNodeIds = activeNodes.map(n => n.id);
         progress.startPhase(2, 'Incremental Connection Resolution', newOrUpdatedNodeIds.length, 0);