gitnexus 1.6.4-rc.76 → 1.6.4-rc.78

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.76",
+  "version": "1.6.4-rc.78",
   "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",