gitnexus 1.6.5-rc.2 → 1.6.5-rc.21

package/dist/core/lbug/lbug-adapter.js

@@ -167,6 +167,65 @@ const runWithSessionLock = async (operation) => {
     }
 };
 const normalizeCopyPath = (filePath) => filePath.replace(/\\/g, '/');
+const closeQueryResult = async (result) => {
+    try {
+        await result.close();
+    }
+    catch {
+        // Best-effort cleanup only.
+    }
+};
+const drainQueryResult = async (queryResult) => {
+    const results = Array.isArray(queryResult) ? queryResult : [queryResult];
+    let firstError;
+    let hasError = false;
+    for (const result of results) {
+        try {
+            await result.getAll();
+        }
+        catch (err) {
+            if (!hasError) {
+                firstError = err;
+                hasError = true;
+            }
+        }
+        finally {
+            await closeQueryResult(result);
+        }
+    }
+    if (hasError)
+        throw firstError;
+};
+const readQueryRows = async (queryResult) => {
+    const results = Array.isArray(queryResult) ? queryResult : [queryResult];
+    let rows = [];
+    let firstError;
+    let hasError = false;
+    for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        try {
+            const resultRows = await result.getAll();
+            if (i === 0)
+                rows = resultRows;
+        }
+        catch (err) {
+            if (!hasError) {
+                firstError = err;
+                hasError = true;
+            }
+        }
+        finally {
+            await closeQueryResult(result);
+        }
+    }
+    if (hasError)
+        throw firstError;
+    return rows;
+};
+const queryAndDrain = async (targetConn, cypher) => {
+    const queryResult = await targetConn.query(cypher);
+    await drainQueryResult(queryResult);
+};
 export const initLbug = async (dbPath) => {
     return runWithSessionLock(() => ensureLbugInitialized(dbPath));
 };
@@ -262,7 +321,7 @@ const doInitLbug = async (dbPath) => {
     conn = opened.conn;
     for (const schemaQuery of SCHEMA_QUERIES) {
         try {
-            await conn.query(schemaQuery);
+            await queryAndDrain(conn, schemaQuery);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -312,12 +371,12 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
         const normalizedPath = normalizeCopyPath(csvPath);
         const copyQuery = getCopyQuery(table, normalizedPath);
         try {
-            await conn.query(copyQuery);
+            await queryAndDrain(conn, copyQuery);
         }
         catch (err) {
             try {
                 const retryQuery = copyQuery.replace('auto_detect=false)', 'auto_detect=false, IGNORE_ERRORS=true)');
-                await conn.query(retryQuery);
+                await queryAndDrain(conn, retryQuery);
             }
             catch (retryErr) {
                 const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
@@ -350,12 +409,12 @@ export const loadGraphToLbug = async (graph, repoPath, storagePath, onProgress)
                 log(`Loading edges: ${pairIdx}/${relsByPairMeta.size} types (${fromLabel} -> ${toLabel})`);
             }
             try {
-                await conn.query(copyQuery);
+                await queryAndDrain(conn, copyQuery);
             }
             catch (err) {
                 try {
                     const retryQuery = copyQuery.replace('auto_detect=false)', 'auto_detect=false, IGNORE_ERRORS=true)');
-                    await conn.query(retryQuery);
+                    await queryAndDrain(conn, retryQuery);
                 }
                 catch (retryErr) {
                     const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
@@ -475,7 +534,7 @@ const fallbackRelationshipInserts = async (validRelLines, validTables, getNodeLa
             const confidence = parseFloat(confidenceStr) || 1.0;
             const step = parseInt(stepStr) || 0;
             const esc = (s) => s.replace(/'/g, "''").replace(/\\/g, '\\\\').replace(/\n/g, '\\n').replace(/\r/g, '\\r');
-            await conn.query(`
+            await queryAndDrain(conn, `
         MATCH (a:${escapeLabel(fromLabel)} {id: '${esc(fromId)}' }),
               (b:${escapeLabel(toLabel)} {id: '${esc(toId)}' })
         CREATE (a)-[:${REL_TABLE_NAME} {type: '${esc(relType)}', confidence: ${confidence}, reason: '${esc(reason)}', step: ${step}}]->(b)
@@ -589,7 +648,7 @@ export const insertNodeToLbug = async (label, properties, dbPath) => {
         if (targetDbPath) {
             const tempHandle = await openLbugConnection(lbug, targetDbPath);
             try {
-                await tempHandle.conn.query(query);
+                await queryAndDrain(tempHandle.conn, query);
                 return true;
             }
             finally {
@@ -598,7 +657,7 @@ export const insertNodeToLbug = async (label, properties, dbPath) => {
         }
         else if (conn) {
             // Use existing persistent connection (when called from analyze)
-            await conn.query(query);
+            await queryAndDrain(conn, query);
             return true;
         }
         return false;
@@ -667,7 +726,7 @@ export const batchInsertNodesToLbug = async (nodes, dbPath) => {
                         : '';
                     query = `MERGE (n:${t} {id: ${escapeValue(properties.id)}}) SET n.name = ${escapeValue(properties.name)}, n.filePath = ${escapeValue(properties.filePath)}, n.startLine = ${properties.startLine || 0}, n.endLine = ${properties.endLine || 0}, n.content = ${escapeValue(properties.content || '')}${descPart}`;
                 }
-                await tempConn.query(query);
+                await queryAndDrain(tempConn, query);
                 inserted++;
             }
             catch (e) {
@@ -686,19 +745,17 @@ export const executeQuery = async (cypher) => {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     const queryResult = await conn.query(cypher);
-    // LadybugDB uses getAll() instead of hasNext()/getNext()
-    // Query returns QueryResult for single queries, QueryResult[] for multi-statement
-    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-    const rows = await result.getAll();
-    return rows;
+    return await readQueryRows(queryResult);
 };
 export const streamQuery = async (cypher, onRow) => {
     if (!conn) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     const queryResult = await conn.query(cypher);
-    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+    const results = Array.isArray(queryResult) ? queryResult : [queryResult];
+    const result = results[0];
     let rowCount = 0;
+    let streamError;
     try {
         while (await result.hasNext()) {
             const row = await result.getNext();
@@ -707,12 +764,17 @@ export const streamQuery = async (cypher, onRow) => {
         }
         return rowCount;
     }
+    catch (err) {
+        streamError = err;
+        throw err;
+    }
     finally {
         try {
-            await result.close();
+            await drainQueryResult(results);
         }
-        catch {
-            // Best-effort cleanup only.
+        catch (err) {
+            if (streamError === undefined)
+                throw err;
         }
     }
 };
@@ -730,8 +792,7 @@ export const executePrepared = async (cypher, params) => {
         throw new Error(`Prepare failed: ${errMsg}`);
     }
     const queryResult = await conn.execute(stmt, params);
-    const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-    return await result.getAll();
+    return await readQueryRows(queryResult);
 };
 export const executeWithReusedStatement = async (cypher, paramsList) => {
     if (!conn) {
@@ -749,7 +810,7 @@ export const executeWithReusedStatement = async (cypher, paramsList) => {
         }
         try {
             for (const params of subBatch) {
-                await conn.execute(stmt, params);
+                await drainQueryResult(await conn.execute(stmt, params));
             }
         }
         catch (e) {
@@ -767,8 +828,7 @@ export const getLbugStats = async () => {
     for (const tableName of NODE_TABLES) {
         try {
             const queryResult = await conn.query(`MATCH (n:${escapeTableName(tableName)}) RETURN count(n) AS cnt`);
-            const nodeResult = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-            const nodeRows = await nodeResult.getAll();
+            const nodeRows = await readQueryRows(queryResult);
             if (nodeRows.length > 0) {
                 totalNodes += Number(nodeRows[0]?.cnt ?? nodeRows[0]?.[0] ?? 0);
             }
@@ -780,8 +840,7 @@ export const getLbugStats = async () => {
     let totalEdges = 0;
     try {
         const queryResult = await conn.query(`MATCH ()-[r:${REL_TABLE_NAME}]->() RETURN count(r) AS cnt`);
-        const edgeResult = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-        const edgeRows = await edgeResult.getAll();
+        const edgeRows = await readQueryRows(queryResult);
         if (edgeRows.length > 0) {
             totalEdges = Number(edgeRows[0]?.cnt ?? edgeRows[0]?.[0] ?? 0);
         }
@@ -810,8 +869,7 @@ export const loadCachedEmbeddings = async () => {
         // If the query fails (column missing), we return empty cache to force a full rebuild.
         try {
             const check = await conn.query(`MATCH (e:${EMBEDDING_TABLE_NAME}) RETURN e.nodeId AS nodeId, e.chunkIndex AS chunkIndex LIMIT 1`);
-            const checkResult = Array.isArray(check) ? check[0] : check;
-            await checkResult.getAll();
+            await readQueryRows(check);
         }
         catch {
             return { embeddingNodeIds: new Set(), embeddings: [] };
@@ -833,8 +891,7 @@ export const loadCachedEmbeddings = async () => {
                 throw err;
             }
         }
-        const result = Array.isArray(rows) ? rows[0] : rows;
-        for (const row of await result.getAll()) {
+        for (const row of await readQueryRows(rows)) {
             const nodeId = String(row.nodeId ?? row[0] ?? '');
             if (!nodeId)
                 continue;
@@ -938,7 +995,8 @@ export const flushWAL = async () => {
     if (!conn)
         return;
     try {
-        await conn.query('CHECKPOINT');
+        const checkpointResult = await conn.query('CHECKPOINT');
+        await drainQueryResult(checkpointResult);
     }
     catch {
         /* ignore — older LadybugDB or schemaless DB may not accept it */
@@ -1036,12 +1094,11 @@ export const deleteNodesForFile = async (filePath, dbPath) => {
                 // First count how many we'll delete
                 const tn = escapeTableName(tableName);
                 const countResult = await targetConn.query(`MATCH (n:${tn}) WHERE n.filePath = '${escapedPath}' RETURN count(n) AS cnt`);
-                const result = Array.isArray(countResult) ? countResult[0] : countResult;
-                const rows = await result.getAll();
+                const rows = await readQueryRows(countResult);
                 const count = Number(rows[0]?.cnt ?? rows[0]?.[0] ?? 0);
                 if (count > 0) {
                     // Delete nodes (and implicitly their relationships via DETACH)
-                    await targetConn.query(`MATCH (n:${tn}) WHERE n.filePath = '${escapedPath}' DETACH DELETE n`);
+                    await queryAndDrain(targetConn, `MATCH (n:${tn}) WHERE n.filePath = '${escapedPath}' DETACH DELETE n`);
                     deletedNodes += count;
                 }
             }
@@ -1051,7 +1108,7 @@ export const deleteNodesForFile = async (filePath, dbPath) => {
         }
         // Also delete any embeddings for nodes in this file
         try {
-            await targetConn.query(`MATCH (e:${EMBEDDING_TABLE_NAME}) WHERE e.nodeId STARTS WITH '${escapedPath}' DELETE e`);
+            await queryAndDrain(targetConn, `MATCH (e:${EMBEDDING_TABLE_NAME}) WHERE e.nodeId STARTS WITH '${escapedPath}' DELETE e`);
         }
         catch {
             // Embedding table may not exist or nodeId format may differ
@@ -1065,6 +1122,76 @@ export const deleteNodesForFile = async (filePath, dbPath) => {
     }
 };
 export const getEmbeddingTableName = () => EMBEDDING_TABLE_NAME;
+/**
+ * Return the distinct repo-relative paths of files that import
+ * `targetFilePath` according to the IMPORTS edges currently in the
+ * DB. Used by the incremental writeback path to expand the
+ * "files-to-rewrite" set so that files importing a changed file get
+ * their edges (which may have been refined by cross-file resolution)
+ * re-emitted, rather than left stale in the DB.
+ *
+ * The DB query reads the *previous* run's state — pre-pipeline, before
+ * any nodes are deleted — so the returned importers are "files that
+ * USED TO import the target". That's the right set to invalidate:
+ * those are the files whose edges in the DB might no longer match
+ * what cross-file resolution produces given the changed file's new
+ * exports.
+ */
+export const queryImporters = async (targetFilePath) => {
+    if (!conn) {
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
+    }
+    const escaped = targetFilePath.replace(/'/g, "''");
+    const cypher = `
+    MATCH (a)-[r:${REL_TABLE_NAME}]->(b)
+    WHERE r.type = 'IMPORTS' AND b.filePath = '${escaped}'
+    RETURN DISTINCT a.filePath AS importer
+  `;
+    try {
+        const queryResult = await conn.query(cypher);
+        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
+        const rows = await result.getAll();
+        const out = [];
+        for (const row of rows) {
+            const v = row.importer;
+            if (typeof v === 'string' && v.length > 0)
+                out.push(v);
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+};
+/**
+ * Drop every Community and Process node (and their MEMBER_OF /
+ * STEP_IN_PROCESS edges via DETACH DELETE). Used at the start of an
+ * incremental run so the communities and processes phases regenerate
+ * them from scratch on the merged graph — required for the
+ * "Leiden runs on the FULL graph" correctness invariant.
+ */
+export const deleteAllCommunitiesAndProcesses = async () => {
+    if (!conn) {
+        throw new Error('LadybugDB not initialized. Call initLbug first.');
+    }
+    let nodesDeleted = 0;
+    for (const label of ['Community', 'Process']) {
+        try {
+            const countResult = await conn.query(`MATCH (n:${label}) RETURN count(n) AS cnt`);
+            const result = Array.isArray(countResult) ? countResult[0] : countResult;
+            const rows = await result.getAll();
+            const count = Number(rows[0]?.cnt ?? rows[0]?.[0] ?? 0);
+            if (count > 0) {
+                await conn.query(`MATCH (n:${label}) DETACH DELETE n`);
+                nodesDeleted += count;
+            }
+        }
+        catch {
+            // Table may not exist yet on a freshly-initialized DB — fine.
+        }
+    }
+    return { nodesDeleted };
+};
 // ============================================================================
 // Full-Text Search (FTS) Functions
 // ============================================================================
@@ -1088,7 +1215,7 @@ export const loadFTSExtension = async (targetConn, opts = {}) => {
     if (!c) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
-    const loaded = await extensionManager.ensure((sql) => c.query(sql), 'fts', 'FTS', opts);
+    const loaded = await extensionManager.ensure((sql) => queryAndDrain(c, sql), 'fts', 'FTS', opts);
     if (loaded && useModuleState)
         ftsLoaded = true;
     return loaded;
@@ -1102,13 +1229,21 @@ export const loadVectorExtension = async (targetConn, opts = {}) => {
     const useModuleState = targetConn === undefined;
     if (useModuleState && vectorExtensionLoaded)
         return true;
+    // INSTALL VECTOR crashes with SIGSEGV on Windows: the KuzuDB native extension
+    // installer has an unhandled error path on Windows that raises a fatal signal
+    // that JS try/catch cannot intercept. Skip loading — vector/embedding search
+    // is unavailable but all graph index queries still work. Do NOT set
+    // vectorExtensionLoaded here: the flag means "successfully loaded", and a
+    // subsequent call would otherwise short-circuit to `return true` at the top.
+    if (process.platform === 'win32')
+        return false;
     if (!isVectorExtensionSupportedByPlatform())
         return false;
     const c = targetConn ?? conn;
     if (!c) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
-    const loaded = await extensionManager.ensure((sql) => c.query(sql), 'VECTOR', 'VECTOR', opts);
+    const loaded = await extensionManager.ensure((sql) => queryAndDrain(c, sql), 'VECTOR', 'VECTOR', opts);
     if (loaded && useModuleState)
         vectorExtensionLoaded = true;
     return loaded;
@@ -1133,7 +1268,7 @@ export const createFTSIndex = async (tableName, indexName, properties, stemmer =
     const propList = properties.map((p) => `'${p}'`).join(', ');
     const query = `CALL CREATE_FTS_INDEX('${tableName}', '${indexName}', [${propList}], stemmer := '${stemmer}')`;
     try {
-        await conn.query(query);
+        await queryAndDrain(conn, query);
         ensuredFTSIndexes.add(key);
     }
     catch (e) {
@@ -1202,8 +1337,7 @@ export const queryFTS = async (tableName, indexName, query, limit = 20, conjunct
   `;
     try {
         const queryResult = await conn.query(cypher);
-        const result = Array.isArray(queryResult) ? queryResult[0] : queryResult;
-        const rows = await result.getAll();
+        const rows = await readQueryRows(queryResult);
         return rows.map((row) => {
             const node = row.node || row[0] || {};
             const score = row.score ?? row[1] ?? 0;
@@ -1232,7 +1366,7 @@ export const dropFTSIndex = async (tableName, indexName) => {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
     try {
-        await conn.query(`CALL DROP_FTS_INDEX('${tableName}', '${indexName}')`);
+        await queryAndDrain(conn, `CALL DROP_FTS_INDEX('${tableName}', '${indexName}')`);
     }
     catch {
         // Index may not exist

package/dist/core/lbug/pool-adapter.js

@@ -348,7 +348,18 @@ async function doInitLbug(repoId, dbPath) {
     // install; analyze owns extension installation. If LOAD fails, search
     // features degrade gracefully and the user-facing query path proceeds.
     if (!shared.ftsLoaded) {
-        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        // Windows guard: LOAD EXTENSION fts crashes with SIGSEGV on Windows when
+        // the FTS extension binary is not installed locally (@ladybugdb/core native
+        // bug — the extension loader hits an unhandled error path that signals SIGSEGV
+        // rather than throwing a JS exception, so try/catch cannot protect here).
+        // Skip the load on Windows; bm25-index.js catches the resulting Kuzu catalog
+        // errors and returns empty BM25 results gracefully. Graph queries are unaffected.
+        if (process.platform === 'win32') {
+            shared.ftsLoaded = true;
+        }
+        else {
+            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        }
     }
     // Register pool entry only after all connections are pre-warmed and FTS is
     // loaded.  Concurrent executeQuery calls see either "not initialized"
@@ -404,8 +415,14 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     // Load FTS extension if not already loaded on this Database.
     // policy: 'load-only' — same contract as initLbug above; the read pool
     // must not block on a network install during query execution.
+    // Windows guard: same SIGSEGV risk as doInitLbug above — skip on Windows.
     if (!shared.ftsLoaded) {
-        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        if (process.platform === 'win32') {
+            shared.ftsLoaded = true;
+        }
+        else {
+            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
+        }
     }
     pool.set(repoId, {
         db: existingDb,

package/dist/core/run-analyze.d.ts

@@ -42,6 +42,8 @@ export interface AnalyzeOptions {
     skipAgentsMd?: boolean;
     /** Omit volatile symbol/relationship counts from AGENTS.md and CLAUDE.md. */
     noStats?: boolean;
+    /** Skip installing standard GitNexus skill files to .claude/skills/gitnexus/. */
+    skipSkills?: boolean;
     /**
      * User-provided alias for the registry `name` (#829). When set,
      * forwarded to `registerRepo` so the indexed repo is stored under