gitnexus 1.6.3-rc.29 → 1.6.3-rc.30

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

@@ -15,6 +15,22 @@
  * from the same Database is the officially supported concurrency pattern.
  */
 import lbug from '@ladybugdb/core';
+/**
+ * Listeners notified when a pool entry is torn down (LRU eviction, idle
+ * timeout, explicit close). Used by upper layers (e.g. the BM25 search
+ * module) to invalidate per-repo caches that must not outlive the pool
+ * entry that produced them.
+ *
+ * Listeners run synchronously inside `closeOne` after the pool entry has
+ * been removed; throwing listeners are isolated so one bad listener does
+ * not prevent others from firing or break teardown.
+ */
+type PoolCloseListener = (repoId: string) => void;
+/**
+ * Subscribe to pool-close events. Returns a disposer that removes the
+ * listener (handy for tests).
+ */
+export declare function addPoolCloseListener(listener: PoolCloseListener): () => void;
 /** Saved real stdout/stderr write — used to silence native module output without race conditions */
 export declare const realStdoutWrite: any;
 export declare const realStderrWrite: any;
@@ -74,3 +90,4 @@ export declare const isLbugReady: (repoId: string) => boolean;
 export declare const CYPHER_WRITE_RE: RegExp;
 /** Check if a Cypher query contains write operations */
 export declare function isWriteQuery(query: string): boolean;
+export {};

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

@@ -17,6 +17,17 @@
 import fs from 'fs/promises';
 import lbug from '@ladybugdb/core';
 const pool = new Map();
+const poolCloseListeners = new Set();
+/**
+ * Subscribe to pool-close events. Returns a disposer that removes the
+ * listener (handy for tests).
+ */
+export function addPoolCloseListener(listener) {
+    poolCloseListeners.add(listener);
+    return () => {
+        poolCloseListeners.delete(listener);
+    };
+}
 const dbCache = new Map();
 /** Max repos in the pool (LRU eviction) */
 const MAX_POOL_SIZE = 5;
@@ -119,6 +130,16 @@ function closeOne(repoId) {
         }
     }
     pool.delete(repoId);
+    // Notify listeners AFTER the pool entry is gone so any cache-invalidation
+    // they perform is consistent with `isLbugReady(repoId) === false`.
+    for (const listener of poolCloseListeners) {
+        try {
+            listener(repoId);
+        }
+        catch {
+            // Isolate listener failures — teardown must complete.
+        }
+    }
 }
 /**
  * Create a new Connection from a repo's Database.

package/dist/core/search/bm25-index.d.ts

@@ -16,6 +16,17 @@ export interface BM25SearchResult {
     rank: number;
     nodeIds?: string[];
 }
+/**
+ * Drop all ensured-FTS cache entries for a given repoId.
+ *
+ * Called from the pool-close listener so that a pool teardown / recreation
+ * forces the next `searchFTSFromLbug` call to re-issue `CREATE_FTS_INDEX`
+ * against the fresh connection rather than trust stale ensure-state from a
+ * previous pool lifetime.
+ *
+ * Exported for tests; the listener wiring is internal.
+ */
+export declare function invalidateEnsuredFTSForRepo(repoId: string): void;
 /**
  * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *

package/dist/core/search/bm25-index.js

@@ -27,8 +27,45 @@ const FTS_INDEXES = [
  * Per-process cache for the MCP pool path: tracks which `(repoId, table)`
  * pairs have been ensured. The CLI/pipeline path gets its own cache inside
  * `lbug-adapter.ts` keyed by table/index, scoped to the singleton connection.
+ *
+ * IMPORTANT: an entry is added ONLY when the index was confirmed to exist
+ * (CREATE_FTS_INDEX succeeded, or failed with `'already exists'`). Other
+ * failures (transient lock errors, missing extension, etc.) leave the key
+ * unset so the next query retries instead of silently caching the failure.
+ *
+ * Entries for a given repoId are invalidated when its pool is closed —
+ * see the `addPoolCloseListener` registration in `searchFTSFromLbug`.
  */
 const ensuredPoolFTS = new Set();
+/**
+ * Drop all ensured-FTS cache entries for a given repoId.
+ *
+ * Called from the pool-close listener so that a pool teardown / recreation
+ * forces the next `searchFTSFromLbug` call to re-issue `CREATE_FTS_INDEX`
+ * against the fresh connection rather than trust stale ensure-state from a
+ * previous pool lifetime.
+ *
+ * Exported for tests; the listener wiring is internal.
+ */
+export function invalidateEnsuredFTSForRepo(repoId) {
+    const prefix = `${repoId}:`;
+    for (const key of ensuredPoolFTS) {
+        if (key.startsWith(prefix))
+            ensuredPoolFTS.delete(key);
+    }
+}
+/**
+ * Tracks whether we've already wired the pool-close listener for this
+ * process. The pool adapter is dynamically imported, so registration
+ * happens lazily on the first MCP-pool-backed FTS query.
+ */
+let poolCloseListenerRegistered = false;
+function registerPoolCloseListenerOnce(addPoolCloseListener) {
+    if (poolCloseListenerRegistered)
+        return;
+    poolCloseListenerRegistered = true;
+    addPoolCloseListener((repoId) => invalidateEnsuredFTSForRepo(repoId));
+}
 async function ensureFTSIndexViaExecutor(executor, repoId, table, indexName, properties) {
     const key = `${repoId}:${table}:${indexName}`;
     if (ensuredPoolFTS.has(key))
@@ -36,17 +73,25 @@ async function ensureFTSIndexViaExecutor(executor, repoId, table, indexName, pro
     const propList = properties.map((p) => `'${p}'`).join(', ');
     try {
         await executor(`CALL CREATE_FTS_INDEX('${table}', '${indexName}', [${propList}], stemmer := 'porter')`);
+        // Index was created successfully — safe to cache.
+        ensuredPoolFTS.add(key);
     }
     catch (e) {
         // 'already exists' is the happy path (index persists on disk between
-        // process invocations) — anything else we swallow because FTS is
-        // best-effort: queryFTS itself returns [] on missing-index errors.
+        // process invocations) — cache it. Anything else is treated as a
+        // transient failure: surface a one-time warning and leave the key
+        // unset so the NEXT query retries rather than silently using a
+        // cached failure (which previously disabled BM25 for the whole
+        // process for that repo).
         const msg = String(e?.message ?? '');
-        if (!msg.includes('already exists')) {
-            // Best-effort — continue without index, queryFTS will fall back to [].
+        if (msg.includes('already exists')) {
+            ensuredPoolFTS.add(key);
+        }
+        else {
+            console.warn(`[gitnexus] FTS index ensure failed for repo "${repoId}" table "${table}" ` +
+                `(index "${indexName}"): ${msg || e}. Will retry on next query.`);
         }
     }
-    ensuredPoolFTS.add(key);
 }
 /**
  * Execute a single FTS query via a custom executor (for MCP connection pool).
@@ -94,7 +139,13 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         // Use MCP connection pool via dynamic import
         // IMPORTANT: FTS queries run sequentially to avoid connection contention.
         // The MCP pool supports multiple connections, but FTS is best run serially.
-        const { executeQuery } = await import('../lbug/pool-adapter.js');
+        const poolMod = await import('../lbug/pool-adapter.js');
+        const { executeQuery, addPoolCloseListener } = poolMod;
+        // Register the pool-close listener lazily on first use so a teardown of
+        // the pool entry (LRU eviction, idle timeout, explicit close) drops the
+        // matching `ensuredPoolFTS` entries. Without this, stale ensure-state
+        // can outlive the pool that produced it.
+        registerPoolCloseListenerOnce(addPoolCloseListener);
         const executor = (cypher) => executeQuery(repoId, cypher);
         // Lazy-create FTS indexes on first query for this repo (analyze no longer
         // creates them up-front, so we ensure them here). Cached per-process.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.3-rc.29",
+  "version": "1.6.3-rc.30",
   "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",