gitnexus 1.6.4-rc.75 → 1.6.4-rc.77

package/dist/core/ingestion/languages/go/range-binding.js

@@ -17,10 +17,10 @@ export function populateGoRangeBindings(parsedFiles, _indexes, ctx) {
         const scopeMap = new Map(parsed.scopes.map((s) => [s.id, s]));
         for (const rangeNode of tree.rootNode.descendantsOfType('for_statement')) {
             const rangeClause = rangeNode.namedChildren.find((c) => c.type === 'range_clause');
-            if (rangeClause === null)
+            if (rangeClause === undefined)
                 continue;
             const left = rangeClause.namedChildren.find((c) => c.type === 'expression_list');
-            if (left === null)
+            if (left === undefined)
                 continue;
             const rangeExpr = rangeClause.namedChildren.find((c, idx) => c.type !== 'expression_list' && idx > rangeClause.namedChildren.indexOf(left));
             if (rangeExpr === undefined)

package/dist/core/ingestion/languages/go/type-binding.js

@@ -38,7 +38,7 @@ export function synthesizeGoTypeBindings(rootNode) {
                 const args = expr.childForFieldName('arguments');
                 if (fn?.type === 'identifier' && fn.text === 'new' && args !== null) {
                     const typeArg = args.namedChildren.find((c) => ['type_identifier', 'qualified_type'].includes(c.type));
-                    if (typeArg !== null) {
+                    if (typeArg !== undefined) {
                         const typeName = extractSimpleTypeNameText(typeArg);
                         const nameNodes = lhs.namedChildren.filter((c) => c.type === 'identifier');
                         if (nameNodes.length > 0) {
@@ -54,11 +54,11 @@ export function synthesizeGoTypeBindings(rootNode) {
                     const sliceOrMap = args.namedChildren.find((c) => 
                     // V1: channel_type not handled — make(chan T) produces no typeBinding.
                     ['slice_type', 'map_type'].includes(c.type));
-                    if (sliceOrMap !== null) {
+                    if (sliceOrMap !== undefined) {
                         let typeName = '';
                         if (sliceOrMap.type === 'slice_type') {
                             const elem = sliceOrMap.namedChildren.find((c) => ['type_identifier', 'qualified_type'].includes(c.type));
-                            if (elem !== null)
+                            if (elem !== undefined)
                                 typeName = extractSimpleTypeNameText(elem);
                         }
                         else if (sliceOrMap.type === 'map_type') {

package/dist/core/lbug/lbug-adapter.d.ts

@@ -119,6 +119,31 @@ export declare const loadCachedEmbeddings: () => Promise<{
  * @param execQuery - Cypher query executor (typically pool-adapter's `executeQuery`)
  */
 export declare const fetchExistingEmbeddingHashes: (execQuery: (cypher: string) => Promise<any[]>) => Promise<Map<string, string> | undefined>;
+/**
+ * Flush the WAL so all pending writes are visible to subsequent readers.
+ *
+ * Best-effort: swallows errors from older LadybugDB versions or schemaless
+ * databases that do not support the CHECKPOINT command.  A no-op when there
+ * is nothing pending, so safe (and cheap) to call unconditionally after any
+ * write path.
+ *
+ * Use this instead of safeClose when the connection must stay open
+ * (e.g. the /api/embed handler that keeps serving queries after flushing).
+ *
+ * @see safeClose — CHECKPOINT + connection/database close
+ */
+export declare const flushWAL: () => Promise<void>;
+/**
+ * Flush the WAL and close the connection and database handles.
+ *
+ * Consolidates the CHECKPOINT + close pattern into a single function so
+ * callers never call conn.close() or db.close() directly (#1376).
+ * An ESLint no-restricted-syntax rule enforces this — see eslint.config.mjs.
+ *
+ * @see flushWAL — CHECKPOINT-only (connection stays open)
+ * @see closeLbug — safeClose + module state reset (full teardown)
+ */
+export declare const safeClose: () => Promise<void>;
 export declare const closeLbug: () => Promise<void>;
 export declare const isLbugReady: () => boolean;
 /**

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

@@ -206,31 +206,7 @@ export const withLbugDb = async (dbPath, operation) => {
             // Close stale connection inside the session lock to prevent race conditions
             // with concurrent operations that might acquire the lock between cleanup steps
             await runWithSessionLock(async () => {
-                // CHECKPOINT before close to flush WAL contents (same rationale as closeLbug)
-                if (conn) {
-                    try {
-                        await conn.query('CHECKPOINT');
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                }
-                try {
-                    if (conn)
-                        await conn.close();
-                }
-                catch {
-                    /* best-effort */
-                }
-                try {
-                    if (db)
-                        await db.close();
-                }
-                catch {
-                    /* best-effort */
-                }
-                conn = null;
-                db = null;
+                await safeClose();
                 currentDbPath = null;
                 ftsLoaded = false;
                 vectorExtensionLoaded = false;
@@ -254,27 +230,7 @@ const ensureLbugInitialized = async (dbPath) => {
 const doInitLbug = async (dbPath) => {
     // Different database requested — close the old one first
     if (conn || db) {
-        // CHECKPOINT before close to flush WAL contents (same rationale as closeLbug)
-        if (conn) {
-            try {
-                await conn.query('CHECKPOINT');
-            }
-            catch {
-                /* ignore — older LadybugDB or schemaless DB may not accept it */
-            }
-        }
-        try {
-            if (conn)
-                await conn.close();
-        }
-        catch { }
-        try {
-            if (db)
-                await db.close();
-        }
-        catch { }
-        conn = null;
-        db = null;
+        await safeClose();
         currentDbPath = null;
         ftsLoaded = false;
         vectorExtensionLoaded = false;
@@ -948,37 +904,64 @@ export const fetchExistingEmbeddingHashes = async (execQuery) => {
         throw err;
     }
 };
-export const closeLbug = async () => {
-    // CHECKPOINT before close so the WAL/.shadow contents are flushed into
-    // the main database file. Without this, LadybugDB 0.16.0's non-blocking
-    // checkpoint thread can outlive the close call and leave sidecar pages
-    // pending on disk, which makes a subsequent read-side open either race
-    // with the WAL replay or trip the database-id check on the sidecars.
-    // This is especially critical after embedding writes, which generate
-    // large amounts of WAL data. CHECKPOINT is a no-op when there's nothing
-    // pending, so it's cheap on the happy path.
-    if (conn) {
-        try {
-            await conn.query('CHECKPOINT');
-        }
-        catch {
-            /* ignore — older LadybugDB or schemaless DB may not accept it */
-        }
+/**
+ * Flush the WAL so all pending writes are visible to subsequent readers.
+ *
+ * Best-effort: swallows errors from older LadybugDB versions or schemaless
+ * databases that do not support the CHECKPOINT command.  A no-op when there
+ * is nothing pending, so safe (and cheap) to call unconditionally after any
+ * write path.
+ *
+ * Use this instead of safeClose when the connection must stay open
+ * (e.g. the /api/embed handler that keeps serving queries after flushing).
+ *
+ * @see safeClose — CHECKPOINT + connection/database close
+ */
+export const flushWAL = async () => {
+    if (!conn)
+        return;
+    try {
+        await conn.query('CHECKPOINT');
     }
+    catch {
+        /* ignore — older LadybugDB or schemaless DB may not accept it */
+    }
+};
+/**
+ * Flush the WAL and close the connection and database handles.
+ *
+ * Consolidates the CHECKPOINT + close pattern into a single function so
+ * callers never call conn.close() or db.close() directly (#1376).
+ * An ESLint no-restricted-syntax rule enforces this — see eslint.config.mjs.
+ *
+ * @see flushWAL — CHECKPOINT-only (connection stays open)
+ * @see closeLbug — safeClose + module state reset (full teardown)
+ */
+export const safeClose = async () => {
+    await flushWAL();
     if (conn) {
         try {
+            // eslint-disable-next-line no-restricted-syntax -- sole authorised close site
             await conn.close();
         }
-        catch { }
+        catch {
+            /* best-effort */
+        }
         conn = null;
     }
     if (db) {
         try {
+            // eslint-disable-next-line no-restricted-syntax -- sole authorised close site
             await db.close();
         }
-        catch { }
+        catch {
+            /* best-effort */
+        }
         db = null;
     }
+};
+export const closeLbug = async () => {
+    await safeClose();
     currentDbPath = null;
     ftsLoaded = false;
     vectorExtensionLoaded = false;

package/dist/server/api.js

@@ -13,7 +13,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { createRequire } from 'node:module';
 import { loadMeta, listRegisteredRepos, getStoragePath } from '../storage/repo-manager.js';
-import { executeQuery, executePrepared, executeWithReusedStatement, streamQuery, closeLbug, withLbugDb, } from '../core/lbug/lbug-adapter.js';
+import { executeQuery, executePrepared, executeWithReusedStatement, streamQuery, flushWAL, closeLbug, withLbugDb, } from '../core/lbug/lbug-adapter.js';
 import { isWriteQuery } from '../core/lbug/pool-adapter.js';
 import { NODE_TABLES } from '../_shared/index.js';
 import { searchFTSFromLbug } from '../core/search/bm25-index.js';
@@ -1508,13 +1508,8 @@ export const createServer = async (port, host = '127.0.0.1') => {
                         // Flush WAL so subsequent /api/search requests see the new
                         // embeddings immediately (#1149). In the CLI path closeLbug()
                         // handles this during process exit, but the server keeps the
-                        // connection open for other routes -- a CHECKPOINT is enough.
-                        try {
-                            await executeQuery('CHECKPOINT');
-                        }
-                        catch {
-                            /* best-effort -- older LadybugDB may not support it */
-                        }
+                        // connection open for other routes — a CHECKPOINT is enough.
+                        await flushWAL();
                     });
                     clearTimeout(embedTimeout);
                     releaseRepoLock(repoLockPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.75",
+  "version": "1.6.4-rc.77",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",