gitnexus 1.6.4-rc.91 → 1.6.4-rc.92

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

@@ -32,9 +32,12 @@ import type lbug from '@ladybugdb/core';
  * integer; anything invalid falls back to the default.
  */
 export declare const LBUG_MAX_DB_SIZE: number;
+export declare const WAL_RECOVERY_SUGGESTION = "WAL corruption detected. Run `gitnexus analyze` to rebuild the index.";
+export declare function isWalCorruptionError(err: unknown): boolean;
 type LbugModule = typeof lbug;
 export interface LbugDatabaseOptions {
     readOnly?: boolean;
+    throwOnWalReplayFailure?: boolean;
 }
 export interface LbugConnectionHandle {
     db: lbug.Database;

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

@@ -39,8 +39,22 @@ export const LBUG_MAX_DB_SIZE = (() => {
     }
     return 16 * 1024 * 1024 * 1024;
 })();
+/** Matches WAL corruption errors from the LadybugDB engine. */
+const WAL_CORRUPTION_RE = /corrupt(ed)?\s+wal|invalid\s+wal\s+record|wal.*corrupt|checksum.*wal/i;
+export const WAL_RECOVERY_SUGGESTION = 'WAL corruption detected. Run `gitnexus analyze` to rebuild the index.';
+export function isWalCorruptionError(err) {
+    if (!err)
+        return false;
+    const msg = err instanceof Error ? err.message : String(err);
+    return WAL_CORRUPTION_RE.test(msg);
+}
 export function createLbugDatabase(lbugModule, databasePath, options = {}) {
-    return new lbugModule.Database(databasePath, 0, false, options.readOnly ?? false, LBUG_MAX_DB_SIZE);
+    // .d.ts declares fewer args than the native constructor accepts.
+    return new lbugModule.Database(databasePath, 0, // bufferManagerSize
+    false, // enableCompression (pinned for v0.16.0)
+    options.readOnly ?? false, LBUG_MAX_DB_SIZE, true, // autoCheckpoint
+    -1, // checkpointThreshold
+    options.throwOnWalReplayFailure ?? true, true);
 }
 export async function openLbugConnection(lbugModule, databasePath, options = {}) {
     let db;

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

@@ -17,7 +17,7 @@
 import fs from 'fs/promises';
 import lbug from '@ladybugdb/core';
 import { loadFTSExtension } from './lbug-adapter.js';
-import { createLbugDatabase } from './lbug-config.js';
+import { createLbugDatabase, isWalCorruptionError } from './lbug-config.js';
 const pool = new Map();
 const poolCloseListeners = new Set();
 /**
@@ -51,7 +51,7 @@ let idleTimer = null;
 // @ladybugdb/core), corrupting stdout in the pre-sentinel window. Routing
 // through the leaf breaks that chain.
 export { realStdoutWrite, realStderrWrite, setActiveStdoutWrite } from '../../mcp/stdio-capture.js';
-import { getActiveStdoutWrite } from '../../mcp/stdio-capture.js';
+import { getActiveStdoutWrite, realStderrWrite } from '../../mcp/stdio-capture.js';
 let stdoutSilenceCount = 0;
 /** True while pre-warming connections — prevents watchdog from prematurely restoring stdout */
 let preWarmActive = false;
@@ -203,6 +203,44 @@ const QUERY_TIMEOUT_MS = 30_000;
 const WAITER_TIMEOUT_MS = 15_000;
 const LOCK_RETRY_ATTEMPTS = 3;
 const LOCK_RETRY_DELAY_MS = 2000;
+async function openReadOnlyDatabase(dbPath) {
+    let db;
+    silenceStdout();
+    try {
+        db = createLbugDatabase(lbug, dbPath, {
+            readOnly: true,
+            throwOnWalReplayFailure: false,
+        });
+        await db.init();
+        return db;
+    }
+    catch (err) {
+        if (db)
+            await db.close().catch(() => { });
+        throw err;
+    }
+    finally {
+        restoreStdout();
+    }
+}
+/**
+ * Quarantine the .wal file and retry opening the database.
+ * Used when the initial open fails with a WAL corruption error.
+ */
+async function tryQuarantineAndReopen(dbPath, repoId) {
+    const walPath = dbPath + '.wal';
+    const quarantineName = `${walPath}.corrupt.${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    try {
+        await fs.rename(walPath, quarantineName);
+    }
+    catch {
+        throw new Error(`LadybugDB WAL corruption detected for ${repoId}. ` +
+            `Run \`gitnexus analyze\` to rebuild the index. (quarantine failed)`);
+    }
+    realStderrWrite(`GitNexus: LadybugDB WAL quarantined for ${repoId}; graph may be stale. ` +
+        `Run \`gitnexus analyze\` to rebuild the index.\n`);
+    return await openReadOnlyDatabase(dbPath);
+}
 /** Deduplicates concurrent initLbug calls for the same repoId */
 const initPromises = new Map();
 /**
@@ -256,17 +294,27 @@ async function doInitLbug(repoId, dbPath) {
         // avoids lock conflicts when `gitnexus analyze` is writing.
         let lastError = null;
         for (let attempt = 1; attempt <= LOCK_RETRY_ATTEMPTS; attempt++) {
-            silenceStdout();
             try {
-                const db = createLbugDatabase(lbug, dbPath, { readOnly: true });
-                restoreStdout();
+                const db = await openReadOnlyDatabase(dbPath);
                 shared = { db, refCount: 0, ftsLoaded: false };
                 dbCache.set(dbPath, shared);
                 break;
             }
             catch (err) {
-                restoreStdout();
                 lastError = err instanceof Error ? err : new Error(String(err));
+                if (isWalCorruptionError(lastError)) {
+                    try {
+                        const db = await tryQuarantineAndReopen(dbPath, repoId);
+                        shared = { db, refCount: 0, ftsLoaded: false };
+                        dbCache.set(dbPath, shared);
+                        break;
+                    }
+                    catch (retryErr) {
+                        throw new Error(`LadybugDB WAL corruption detected for ${repoId}. ` +
+                            `Run \`gitnexus analyze\` to rebuild the index. ` +
+                            `(${retryErr instanceof Error ? retryErr.message : String(retryErr)})`);
+                    }
+                }
                 const isLockError = lastError.message.includes('Could not set lock') || lastError.message.includes('lock');
                 if (!isLockError || attempt === LOCK_RETRY_ATTEMPTS)
                     break;

package/dist/mcp/local/local-backend.d.ts

@@ -259,6 +259,7 @@ export declare class LocalBackend {
      * UID-based direct lookup. No cluster in output.
      */
     private context;
+    private _contextImpl;
     /**
      * Legacy explore — kept for backwards compatibility with resources.ts.
      * Routes cluster/process types to direct graph queries.

package/dist/mcp/local/local-backend.js

@@ -8,6 +8,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { initLbug, executeQuery, executeParameterized, closeLbug, isLbugReady, isWriteQuery, } from '../../core/lbug/pool-adapter.js';
+import { isWalCorruptionError, WAL_RECOVERY_SUGGESTION } from '../../core/lbug/lbug-config.js';
 export { isWriteQuery };
 // Embedding imports are lazy (dynamic import) to avoid loading onnxruntime-node
 // at MCP server startup — crashes on unsupported Node ABI versions (#89)
@@ -1022,7 +1023,14 @@ export class LocalBackend {
             return result;
         }
         catch (err) {
-            return { error: err.message || 'Query failed' };
+            const msg = err.message || 'Query failed';
+            if (isWalCorruptionError(err)) {
+                return {
+                    error: msg,
+                    recoverySuggestion: WAL_RECOVERY_SUGGESTION,
+                };
+            }
+            return { error: msg };
         }
     }
     /**
@@ -1389,6 +1397,21 @@ export class LocalBackend {
      * UID-based direct lookup. No cluster in output.
      */
     async context(repo, params) {
+        try {
+            return await this._contextImpl(repo, params);
+        }
+        catch (err) {
+            const msg = (err instanceof Error ? err.message : String(err)) || 'Context query failed';
+            if (isWalCorruptionError(err)) {
+                return {
+                    error: msg,
+                    recoverySuggestion: WAL_RECOVERY_SUGGESTION,
+                };
+            }
+            throw err;
+        }
+    }
+    async _contextImpl(repo, params) {
         await this.ensureInitialized(repo.id);
         const { name, uid, file_path, kind, include_content } = params;
         if (!name && !uid) {
@@ -1990,6 +2013,7 @@ export class LocalBackend {
                 impactedCount: 0,
                 risk: 'UNKNOWN',
                 suggestion: 'The graph query failed — try gitnexus context <symbol> as a fallback',
+                ...(isWalCorruptionError(err) ? { recoverySuggestion: WAL_RECOVERY_SUGGESTION } : {}),
             };
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.4-rc.91",
+  "version": "1.6.4-rc.92",
   "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",