gitnexus 1.6.13-rc.67 → 1.6.13-rc.68

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

@@ -893,9 +893,10 @@ export declare const buildFtsQueryCypher: (tableName: string, indexName: string,
  * @param query - Search query string
  * @param limit - Maximum results
  * @param conjunctive - If true, all terms must match (AND); if false, any term matches (OR)
+ * @param missingIndex - Preserve the empty-result default, or propagate missing indexes for diagnostics
  * @returns Array of { node properties, score }
  */
-export declare const queryFTS: (tableName: string, indexName: string, query: string, limit?: number, conjunctive?: boolean) => Promise<Array<{
+export declare const queryFTS: (tableName: string, indexName: string, query: string, limit?: number, conjunctive?: boolean, missingIndex?: 'empty' | 'throw') => Promise<Array<{
     nodeId: string;
     name: string;
     filePath: string;

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

@@ -3504,9 +3504,10 @@ export const buildFtsQueryCypher = (tableName, indexName, limit, conjunctive = f
  * @param query - Search query string
  * @param limit - Maximum results
  * @param conjunctive - If true, all terms must match (AND); if false, any term matches (OR)
+ * @param missingIndex - Preserve the empty-result default, or propagate missing indexes for diagnostics
  * @returns Array of { node properties, score }
  */
-export const queryFTS = async (tableName, indexName, query, limit = 20, conjunctive = false) => {
+export const queryFTS = async (tableName, indexName, query, limit = 20, conjunctive = false, missingIndex = 'empty') => {
     if (!conn) {
         throw new Error('LadybugDB not initialized. Call initLbug first.');
     }
@@ -3532,7 +3533,7 @@ export const queryFTS = async (tableName, indexName, query, limit = 20, conjunct
         // NEW-6 — this used to be a bare `.includes('does not exist')` check
         // that could not tell the two apart).
         const message = e instanceof Error ? e.message : String(e);
-        if (classifyFtsQueryError(message) === 'missing-index') {
+        if (missingIndex === 'empty' && classifyFtsQueryError(message) === 'missing-index') {
             return [];
         }
         throw e;

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

@@ -29,6 +29,8 @@ export interface FTSSearchResponse {
      * which only does so when every table failed).
      */
     nonBenignErrors?: string[];
+    /** Configured table.index names that could not be queried because their index is missing. */
+    missingIndexes?: string[];
 }
 /**
  * Search using LadybugDB's built-in FTS (fresh, reads from disk)

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

@@ -86,6 +86,7 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId, disabledReaso
     const resultsByIndex = [];
     let queriesSucceeded = 0;
     const nonBenignErrors = [];
+    const missingIndexes = [];
     const ftsExtension = getExtensionCapabilities().find((c) => c.name === 'fts');
     if (ftsExtension && !ftsExtension.loaded) {
         // tri-review NEW-4 (applies to BOTH the MCP pool path and the CLI/pipeline
@@ -114,26 +115,32 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId, disabledReaso
                 queriesSucceeded++;
                 resultsByIndex.push(outcome.rows);
             }
-            else if (!outcome.benign) {
+            else if (outcome.benign) {
+                missingIndexes.push(`${table}.${indexName}`);
+            }
+            else {
                 nonBenignErrors.push(redactPaths(outcome.message ?? 'Unknown FTS query error'));
             }
         }
     }
     else {
         // Use core lbug adapter (CLI / pipeline context) — also sequential for safety.
-        // tri-review Residual-1: `queryFTS` itself only swallows a genuinely-missing
-        // index (via the SAME classifyFtsQueryError this module re-exports); a
-        // missing-table or real query error rethrows here — track it the same way
-        // the MCP pool path does instead of a bare `catch {}` that dropped it.
+        // Opt into missing-index propagation so absent indexes cannot masquerade
+        // as successful zero-match queries. Keep core/pool classification identical.
         for (const { table, indexName } of FTS_INDEXES) {
             try {
-                const result = await queryFTS(table, indexName, searchQuery, limit, false);
+                const result = await queryFTS(table, indexName, searchQuery, limit, false, 'throw');
                 queriesSucceeded++;
                 resultsByIndex.push(result);
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
-                nonBenignErrors.push(redactPaths(message));
+                if (classifyFtsQueryError(message) === 'missing-index') {
+                    missingIndexes.push(`${table}.${indexName}`);
+                }
+                else {
+                    nonBenignErrors.push(redactPaths(message));
+                }
             }
         }
     }
@@ -174,5 +181,6 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId, disabledReaso
         })),
         ftsAvailable,
         ...(nonBenignErrors.length > 0 && { nonBenignErrors }),
+        ...(missingIndexes.length > 0 && { missingIndexes }),
     };
 };

package/dist/core/search/fts-indexes.d.ts

@@ -48,15 +48,12 @@ export interface FtsWarningContext {
  */
 export declare const ftsDegradedWarning: (context?: FtsWarningContext, disabledReason?: FtsDisabledReason) => string;
 /**
- * Warning for when the FTS extension is loaded and indexes exist, but every
- * configured table's query failed for a real, non-benign reason (timeout,
- * connection reset, native fault) — as opposed to `ftsDegradedWarning`'s
- * missing-index case. `--repair-fts` will not fix a query/connection error,
- * so this deliberately does NOT suggest it: reusing the missing-index
- * message here would reproduce, for this cause, the exact misleading
- * "run --repair-fts" guidance #2767 itself was about (tri-review NEW-1).
+ * Warning when no FTS query succeeded and at least one failed for a real,
+ * non-benign reason (timeout, connection reset, native fault). `--repair-fts`
+ * will not fix those errors. If indexes are also missing, the caller composes
+ * their repair guidance separately; do not deny that additional failure cause.
  */
-export declare const ftsQueryFailedWarning: (context: FtsWarningContext) => string;
+export declare const ftsQueryFailedWarning: (context: FtsWarningContext, hasMissingIndexes?: boolean) => string;
 export declare const SUPPORTED_FTS_STEMMERS: ReadonlySet<string>;
 export interface CreateSearchFTSIndexesOptions {
     indexes?: readonly FTSIndexDefinition[];

package/dist/core/search/fts-indexes.js

@@ -72,18 +72,17 @@ export const ftsDegradedWarning = (context, disabledReason) => {
         suffix);
 };
 /**
- * Warning for when the FTS extension is loaded and indexes exist, but every
- * configured table's query failed for a real, non-benign reason (timeout,
- * connection reset, native fault) — as opposed to `ftsDegradedWarning`'s
- * missing-index case. `--repair-fts` will not fix a query/connection error,
- * so this deliberately does NOT suggest it: reusing the missing-index
- * message here would reproduce, for this cause, the exact misleading
- * "run --repair-fts" guidance #2767 itself was about (tri-review NEW-1).
+ * Warning when no FTS query succeeded and at least one failed for a real,
+ * non-benign reason (timeout, connection reset, native fault). `--repair-fts`
+ * will not fix those errors. If indexes are also missing, the caller composes
+ * their repair guidance separately; do not deny that additional failure cause.
  */
-export const ftsQueryFailedWarning = (context) => 'FTS keyword search failed — every configured index query returned an error' +
+export const ftsQueryFailedWarning = (context, hasMissingIndexes = false) => 'FTS keyword search failed — every configured index query returned an error' +
     (context.lastErrorRedacted ? ` (${context.lastErrorRedacted})` : '') +
-    '; results do not include keyword matches. This is not a missing-index ' +
-    'condition — see server logs for details.' +
+    '; results do not include keyword matches. ' +
+    (hasMissingIndexes
+        ? 'See server logs for query error details.'
+        : 'This is not a missing-index condition — see server logs for details.') +
     ` (resolved: ${formatResolvedSuffix(context)})`;
 // Stemmers shipped by the LadybugDB FTS extension. Mirrors the lowercase token
 // set in the extension bundled with @ladybugdb/core 0.18.x (see package.json).

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

@@ -2413,6 +2413,7 @@ export class LocalBackend {
         // regardless of whether OTHER tables succeeded — previously a real error
         // on N-1 of N tables while one succeeded left zero diagnostic trail.
         const ftsQueryErrors = bm25SearchResult?.nonBenignErrors;
+        const ftsMissingIndexes = bm25SearchResult?.missingIndexes;
         if (ftsQueryErrors) {
             // tri-review NEW-5: these strings are already classified non-benign by
             // classifyFtsQueryError — do NOT route them through logQueryError,
@@ -2847,12 +2848,11 @@ export class LocalBackend {
                 branch: repo.branch,
                 indexedAt: this.lastObservedPoolState.get(repo.lbugPath)?.indexedAt ?? repo.indexedAt,
             };
-            // tri-review NEW-1: every table failing for a REAL error (timeout,
-            // connection reset) is not a missing-index condition — `ftsDegradedWarning`'s
-            // "run --repair-fts" headline won't fix it. Route to a dedicated message
-            // instead of burying the real cause as a trailing suffix on bad advice.
+            // Real errors (timeout, connection reset) need their own diagnosis.
+            // When some indexes are also missing, preserve both causes and append
+            // their repair guidance below even though no FTS query succeeded.
             warnings.push(ftsQueryErrors
-                ? ftsQueryFailedWarning({ ...warningContext, lastErrorRedacted: ftsQueryErrors[0] })
+                ? ftsQueryFailedWarning({ ...warningContext, lastErrorRedacted: ftsQueryErrors[0] }, !!ftsMissingIndexes?.length)
                 : ftsDegradedWarning(warningContext, ftsDisabledReason));
         }
         else if (ftsQueryErrors) {
@@ -2863,6 +2863,10 @@ export class LocalBackend {
             // that convention instead of only logging server-side.
             warnings.push(`FTS keyword search partially failed — ${ftsQueryErrors.length} of the configured indexes hit a query error and were skipped; results may be missing matches from those node types (see server logs).`);
         }
+        if (ftsMissingIndexes?.length && (ftsUsed || ftsQueryErrors)) {
+            warnings.push(`FTS keyword search is incomplete: missing configured indexes (${ftsMissingIndexes.join(', ')}). ` +
+                'Results may be missing matches from those node types. Run `gitnexus analyze --repair-fts`.');
+        }
         // #2331: a CJK query against a server process resolving
         // GITNEXUS_FTS_CJK_SEGMENTATION to 'none' silently misses sub-phrase
         // matches with no other signal — this is the only place an agent driving
@@ -2979,7 +2983,7 @@ export class LocalBackend {
         // #2767: a partial FTS failure (some tables ok, one or more real errors)
         // is as much a "results may be incomplete" signal as enrichmentDegraded —
         // flag it the same way rather than only via the warning string.
-        const ftsPartial = ftsUsed && !!ftsQueryErrors;
+        const ftsPartial = ftsUsed && (!!ftsQueryErrors || !!ftsMissingIndexes?.length);
         return {
             processes,
             process_symbols,
@@ -3023,6 +3027,7 @@ export class LocalBackend {
         const bm25Results = ftsResponse?.results ?? [];
         const ftsUsed = ftsResponse?.ftsAvailable ?? false;
         const nonBenignErrors = ftsResponse?.nonBenignErrors;
+        const missingIndexes = ftsResponse?.missingIndexes;
         const results = [];
         for (const bm25Result of bm25Results) {
             const fullPath = bm25Result.filePath;
@@ -3087,7 +3092,12 @@ export class LocalBackend {
                 });
             }
         }
-        return { results, ftsUsed, ...(nonBenignErrors && { nonBenignErrors }) };
+        return {
+            results,
+            ftsUsed,
+            ...(nonBenignErrors && { nonBenignErrors }),
+            ...(missingIndexes && { missingIndexes }),
+        };
     }
     /**
      * Keyword-only indexes are the default. Do not put this on `query.warning`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.67",
+  "version": "1.6.13-rc.68",
   "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",