gitnexus 1.6.4-rc.93 → 1.6.4-rc.94

package/dist/core/augmentation/engine.js

@@ -90,7 +90,7 @@ export async function augment(pattern, cwd) {
             await initLbug(repoId, repo.lbugPath);
         }
         // Step 1: BM25 search (fast, no embeddings)
-        const bm25Results = await searchFTSFromLbug(pattern, 10, repoId);
+        const { results: bm25Results } = await searchFTSFromLbug(pattern, 10, repoId);
         if (bm25Results.length === 0)
             return '';
         // Step 2: Map BM25 file results to symbols

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

@@ -10,6 +10,11 @@ export interface BM25SearchResult {
     rank: number;
     nodeIds?: string[];
 }
+export interface FTSSearchResponse {
+    results: BM25SearchResult[];
+    /** True when at least one FTS index query succeeded (index exists). */
+    ftsAvailable: boolean;
+}
 /**
  * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *
@@ -21,4 +26,4 @@ export interface BM25SearchResult {
  * @param repoId - If provided, queries will be routed via the MCP connection pool
  * @returns Ranked search results from FTS indexes
  */
-export declare const searchFTSFromLbug: (query: string, limit?: number, repoId?: string) => Promise<BM25SearchResult[]>;
+export declare const searchFTSFromLbug: (query: string, limit?: number, repoId?: string) => Promise<FTSSearchResponse>;

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

@@ -8,7 +8,8 @@ import { queryFTS } from '../lbug/lbug-adapter.js';
 import { FTS_INDEXES } from './fts-schema.js';
 /**
  * Execute a single FTS query via a custom executor (for MCP connection pool).
- * Returns the same shape as core queryFTS (from LadybugDB adapter).
+ * Returns `null` when the query fails (e.g. FTS index does not exist) so the
+ * caller can distinguish "zero matches" from "index missing".
  */
 async function queryFTSViaExecutor(executor, tableName, indexName, query, limit) {
     // Escape single quotes and backslashes to prevent Cypher injection
@@ -32,7 +33,7 @@ async function queryFTSViaExecutor(executor, tableName, indexName, query, limit)
         });
     }
     catch {
-        return [];
+        return null;
     }
 }
 /**
@@ -48,6 +49,7 @@ async function queryFTSViaExecutor(executor, tableName, indexName, query, limit)
  */
 export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
     const resultsByIndex = [];
+    let queriesSucceeded = 0;
     if (repoId) {
         // Use MCP connection pool via dynamic import
         // IMPORTANT: FTS queries run sequentially to avoid connection contention.
@@ -56,15 +58,27 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
         const { executeQuery } = poolMod;
         const executor = (cypher) => executeQuery(repoId, cypher);
         for (const { table, indexName } of FTS_INDEXES) {
-            resultsByIndex.push(await queryFTSViaExecutor(executor, table, indexName, query, limit));
+            const result = await queryFTSViaExecutor(executor, table, indexName, query, limit);
+            if (result !== null) {
+                queriesSucceeded++;
+                resultsByIndex.push(result);
+            }
         }
     }
     else {
         // Use core lbug adapter (CLI / pipeline context) — also sequential for safety.
         for (const { table, indexName } of FTS_INDEXES) {
-            resultsByIndex.push(await queryFTS(table, indexName, query, limit, false).catch(() => []));
+            try {
+                const result = await queryFTS(table, indexName, query, limit, false);
+                queriesSucceeded++;
+                resultsByIndex.push(result);
+            }
+            catch {
+                // FTS index may not exist — count as failed
+            }
         }
     }
+    const ftsAvailable = queriesSucceeded > 0;
     // Collect all node scores per filePath to track which nodes actually matched
     const fileNodeScores = new Map();
     const addResults = (results) => {
@@ -92,10 +106,13 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
     const sorted = Array.from(merged.values())
         .sort((a, b) => b.score - a.score)
         .slice(0, limit);
-    return sorted.map((r, index) => ({
-        filePath: r.filePath,
-        score: r.score,
-        rank: index + 1,
-        nodeIds: r.nodeIds,
-    }));
+    return {
+        results: sorted.map((r, index) => ({
+            filePath: r.filePath,
+            score: r.score,
+            rank: index + 1,
+            nodeIds: r.nodeIds,
+        })),
+        ftsAvailable,
+    };
 };

package/dist/core/search/hybrid-search.d.ts

@@ -32,9 +32,10 @@ export interface HybridSearchResult {
  */
 export declare const mergeWithRRF: (bm25Results: BM25SearchResult[], semanticResults: SemanticSearchResult[], limit?: number) => HybridSearchResult[];
 /**
- * Check if hybrid search is available
- * LadybugDB FTS is always available once the database is initialized.
- * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
+ * Check if hybrid search is available.
+ * FTS indexes may be missing on read-only MCP connections (see #1403);
+ * callers should inspect `ftsAvailable` from searchFTSFromLbug for
+ * per-query availability. This helper is a coarse gate only.
  */
 export declare const isHybridSearchReady: () => boolean;
 /**

package/dist/core/search/hybrid-search.js

@@ -79,12 +79,13 @@ export const mergeWithRRF = (bm25Results, semanticResults, limit = 10) => {
     return sorted;
 };
 /**
- * Check if hybrid search is available
- * LadybugDB FTS is always available once the database is initialized.
- * Semantic search is optional - hybrid works with just FTS if embeddings aren't ready.
+ * Check if hybrid search is available.
+ * FTS indexes may be missing on read-only MCP connections (see #1403);
+ * callers should inspect `ftsAvailable` from searchFTSFromLbug for
+ * per-query availability. This helper is a coarse gate only.
  */
 export const isHybridSearchReady = () => {
-    return true; // FTS is always available via LadybugDB when DB is open
+    return true; // FTS is attempted on every query; ftsAvailable signals actual availability
 };
 /**
  * Format hybrid results for LLM consumption
@@ -112,7 +113,7 @@ export const formatHybridResults = (results) => {
  */
 export const hybridSearch = async (query, limit, executeQuery, semanticSearch) => {
     // Use LadybugDB FTS for always-fresh BM25 results
-    const bm25Results = await searchFTSFromLbug(query, limit);
+    const { results: bm25Results } = await searchFTSFromLbug(query, limit);
     const semanticResults = await semanticSearch(executeQuery, query, limit);
     return mergeWithRRF(bm25Results, semanticResults, limit);
 };

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

@@ -818,7 +818,7 @@ export class LocalBackend {
             definitions: definitions.slice(0, 20), // cap standalone definitions
             timing,
             ...(!ftsUsed && {
-                warning: 'FTS extension unavailable - keyword search degraded. Run: gitnexus analyze --force to rebuild indexes.',
+                warning: 'FTS indexes missing — keyword search degraded. Run: gitnexus analyze --force to rebuild indexes.',
             }),
         };
     }
@@ -827,15 +827,16 @@ export class LocalBackend {
      */
     async bm25Search(repo, query, limit) {
         const { searchFTSFromLbug } = await import('../../core/search/bm25-index.js');
-        let bm25Results;
+        let ftsResponse;
         try {
-            bm25Results = await searchFTSFromLbug(query, limit, repo.id);
+            ftsResponse = await searchFTSFromLbug(query, limit, repo.id);
         }
         catch (err) {
             logger.error({ err: err.message }, 'GitNexus: BM25/FTS search failed (FTS indexes may not exist) -');
             return { results: [], ftsUsed: false };
         }
-        const ftsUsed = bm25Results.length === 0 || bm25Results[0]?.ftsUsed !== false;
+        const bm25Results = ftsResponse.results;
+        const ftsUsed = ftsResponse.ftsAvailable;
         const results = [];
         for (const bm25Result of bm25Results) {
             const fullPath = bm25Result.filePath;

package/dist/server/api.js

@@ -932,10 +932,11 @@ export const createServer = async (port, host = '127.0.0.1') => {
             const enrich = req.body.enrich !== false; // default true
             const results = await withLbugDb(lbugPath, async () => {
                 let searchResults;
+                let ftsAvailable;
                 if (mode === 'semantic') {
                     const { isEmbedderReady } = await import('../core/embeddings/embedder.js');
                     if (!isEmbedderReady()) {
-                        return [];
+                        return { searchResults: [], ftsAvailable: undefined };
                     }
                     const { semanticSearch: semSearch } = await import('../core/embeddings/embedding-pipeline.js');
                     searchResults = await semSearch(executeQuery, query, limit);
@@ -948,8 +949,9 @@ export const createServer = async (port, host = '127.0.0.1') => {
                     }));
                 }
                 else if (mode === 'bm25') {
-                    searchResults = await searchFTSFromLbug(query, limit);
-                    searchResults = searchResults.map((r, i) => ({
+                    const ftsResponse = await searchFTSFromLbug(query, limit);
+                    ftsAvailable = ftsResponse.ftsAvailable;
+                    searchResults = ftsResponse.results.map((r, i) => ({
                         ...r,
                         rank: i + 1,
                         sources: ['bm25'],
@@ -963,11 +965,13 @@ export const createServer = async (port, host = '127.0.0.1') => {
                         searchResults = await hybridSearch(query, limit, executeQuery, semSearch);
                     }
                     else {
-                        searchResults = await searchFTSFromLbug(query, limit);
+                        const ftsResponse = await searchFTSFromLbug(query, limit);
+                        ftsAvailable = ftsResponse.ftsAvailable;
+                        searchResults = ftsResponse.results;
                     }
                 }
                 if (!enrich)
-                    return searchResults;
+                    return { searchResults, ftsAvailable };
                 // Server-side enrichment: add connections, cluster, processes per result
                 // Uses parameterized queries to prevent Cypher injection via nodeId
                 const validLabel = (label) => NODE_TABLES.includes(label);
@@ -1029,9 +1033,14 @@ export const createServer = async (port, host = '127.0.0.1') => {
                     }
                     return { ...r, ...enrichment };
                 }));
-                return enriched;
+                return { searchResults: enriched, ftsAvailable };
             });
-            res.json({ results });
+            const response = { results: results.searchResults ?? results };
+            if (results.ftsAvailable === false) {
+                response.warning =
+                    'FTS indexes missing — keyword search degraded. Run: gitnexus analyze --force to rebuild indexes.';
+            }
+            res.json(response);
         }
         catch (err) {
             res.status(500).json({ error: err.message || 'Search failed' });

package/package.json

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