gitnexus 1.6.13-rc.80 → 1.6.13-rc.81

package/dist/core/run-analyze.js

@@ -1035,18 +1035,33 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, c
                     ? (table, indexName) => log(`FTS: ready ${table}.${indexName}`)
                     : undefined,
             });
-            const missing = await verifySearchFTSIndexes(executeQuery, ftsIndexes);
-            if (missing.length > 0) {
-                // #2889: name WHY each index is missing when the build itself said so.
-                // Repair now rebuilds every table it can before reporting, so the tables
-                // absent from this list were genuinely repaired even on a failed run —
-                // previously the first failure aborted the sweep and the message could
-                // only ever list "missing", never a reason. Same sentence the analyze
-                // degrade path prints, so one failure does not read two ways.
-                const reasons = repairFailures.length > 0
-                    ? ` ${summarizeFtsIndexBuildFailures(repairFailures, ftsIndexes)}.`
-                    : '';
-                throw new Error(`FTS repair failed - missing indexes after rebuild: ${missing.join(', ')}.${reasons} ` +
+            const catalogDiagnostics = [];
+            let missing = [];
+            let catalogError;
+            try {
+                missing = await verifySearchFTSIndexes(executeQuery, ftsIndexes, (diagnostic) => {
+                    catalogDiagnostics.push(diagnostic.message);
+                });
+            }
+            catch (error) {
+                // An unreadable catalog is unknown, not proof of missing indexes.
+                // Keep earlier native build errors when this read also fails.
+                catalogError = error instanceof Error ? error.message : String(error);
+            }
+            if (repairFailures.length > 0 || missing.length > 0 || catalogError !== undefined) {
+                // A failed DROP may leave a valid old catalog entry. Its presence must
+                // not certify that this repair succeeded or clear the recovery marker.
+                const reasons = [
+                    missing.length > 0 ? `missing indexes after rebuild: ${missing.join(', ')}` : '',
+                    repairFailures.length > 0
+                        ? summarizeFtsIndexBuildFailures(repairFailures, ftsIndexes)
+                        : missing.length > 0
+                            ? 'no build error was returned'
+                            : '',
+                    ...catalogDiagnostics,
+                    catalogError !== undefined ? `catalog verification failed: ${catalogError}` : '',
+                ].filter(Boolean);
+                throw new Error(`FTS repair failed - ${reasons.join('. ')}. ` +
                     'Run `gitnexus analyze --force` to perform a full graph+FTS rebuild; ' +
                     'if that also fails, verify FTS extension availability via `gitnexus doctor`.');
             }

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

@@ -159,7 +159,18 @@ export declare function createSearchFTSIndexes(options?: CreateSearchFTSIndexesO
  * {@link redactPaths} first, the same rule the query-side warnings follow.
  */
 export declare const summarizeFtsIndexBuildFailures: (failures: readonly FtsIndexBuildFailure[], indexes?: readonly FTSIndexDefinition[]) => string;
-export declare function verifySearchFTSIndexes(executeQuery: (cypher: string) => Promise<unknown[]>, indexes?: readonly FTSIndexDefinition[]): Promise<string[]>;
+/** Bounded catalog evidence for CLI/log diagnostics, never source or index definitions. */
+export interface FtsIndexVerificationDiagnostic {
+    table: string;
+    indexName: string;
+    message: string;
+}
+/**
+ * Return missing or invalid configured indexes. An optional callback receives
+ * bounded evidence from the same catalog read; a failed read still throws and
+ * proves neither presence nor absence.
+ */
+export declare function verifySearchFTSIndexes(executeQuery: (cypher: string) => Promise<unknown[]>, indexes?: readonly FTSIndexDefinition[], onMismatch?: (diagnostic: FtsIndexVerificationDiagnostic) => void): Promise<string[]>;
 /**
  * Why an FTS build failed, so the caller can react correctly (#2658):
  *

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

@@ -1,4 +1,4 @@
-import { createFTSIndex, dropFTSIndex, indexRowName, indexRowTable, resolveGateRows, DEFAULT_FTS_STEMMER, } from '../lbug/lbug-adapter.js';
+import { createFTSIndex, dropFTSIndex, indexRowName, indexRowTable, indexRowType, resolveGateRows, DEFAULT_FTS_STEMMER, } from '../lbug/lbug-adapter.js';
 import { getFtsCapability } from '../lbug/extension-loader.js';
 import { FTS_DISABLED_MESSAGE } from './fts-policy.js';
 import { classifyExtensionLoadError, usesClassifiedLoadRemedy, } from '../lbug/extension-load-error.js';
@@ -312,38 +312,65 @@ export async function createSearchFTSIndexes(options) {
  */
 export const summarizeFtsIndexBuildFailures = (failures, indexes = FTS_INDEXES) => `FTS index build failed for ${failures.length} of ${indexes.length} tables: ` +
     failures.map((f) => `${f.table}.${f.indexName} (${f.error})`).join(', ');
-export async function verifySearchFTSIndexes(executeQuery, indexes = FTS_INDEXES) {
+const boundCatalogText = (text, limit) => text.length > limit ? `${text.slice(0, limit - 14)}… [truncated]` : text;
+const catalogFieldEvidence = (value) => typeof value === 'string'
+    ? JSON.stringify(boundCatalogText(value, 80))
+    : value === undefined
+        ? '<missing>'
+        : `<invalid ${value === null ? 'null' : typeof value}>`;
+const catalogPropertiesEvidence = (value) => {
+    if (!Array.isArray(value))
+        return `<invalid properties: ${catalogFieldEvidence(value)}>`;
+    return (`[${value.slice(0, 8).map(catalogFieldEvidence).join(', ')}]` +
+        (value.length > 8 ? ` (${value.length - 8} properties truncated)` : ''));
+};
+/**
+ * Return missing or invalid configured indexes. An optional callback receives
+ * bounded evidence from the same catalog read; a failed read still throws and
+ * proves neither presence nor absence.
+ */
+export async function verifySearchFTSIndexes(executeQuery, indexes = FTS_INDEXES, onMismatch) {
     // Read the catalog once and check each configured index both EXISTS and
     // covers its expected columns. A queryability-only probe (CALL QUERY_FTS_INDEX
     // ... catch) is not enough: a stale `name+content`-only index left on a
     // pre-#2299 DB stays queryable yet silently misses `description`, so the probe
     // would pass while doc-comment search is still broken (#2299). SHOW_INDEXES
     // exposes `property_names` (STRING[]) per index, so we assert coverage directly.
-    const rows = await executeQuery('CALL SHOW_INDEXES() RETURN *');
-    const propsByIndex = new Map();
-    for (const row of rows) {
-        if (typeof row !== 'object' || row === null)
-            continue;
-        const record = row;
-        const indexName = indexRowName(record);
-        // LADYBUGDB-CONTRACT: `property_names` is the one SHOW_INDEXES column with a
-        // single reader, so it has no shared accessor — see {@link IndexCatalogRow}
-        // in lbug-adapter.ts for the full column list and the re-validation rule.
-        // Unlike the gates, an unreadable shape here is safe: it reports the index as
-        // not covering its columns, i.e. "missing", which degrades keyword search
-        // loudly rather than passing a broken index off as verified.
-        const propertyNames = record.property_names;
-        if (typeof indexName !== 'string' || !Array.isArray(propertyNames))
-            continue;
-        propsByIndex.set(indexName, propertyNames.filter((p) => typeof p === 'string'));
-    }
+    const rows = (await executeQuery('CALL SHOW_INDEXES() RETURN *')).filter((row) => typeof row === 'object' && row !== null);
     const missing = [];
     for (const { table, indexName, properties } of indexes) {
-        const actual = propsByIndex.get(indexName);
-        // Absent from the catalog, or present but not covering every expected column.
-        if (!actual || !properties.every((p) => actual.includes(p))) {
-            missing.push(`${table}.${indexName}`);
-        }
+        const valid = rows.some((row) => {
+            // LADYBUGDB-CONTRACT: `property_names` is a named STRING[] column;
+            // identity/type use the shared catalog readers in lbug-adapter.ts.
+            const actual = row.property_names;
+            return (indexRowTable(row) === table &&
+                indexRowName(row) === indexName &&
+                indexRowType(row) === 'FTS' &&
+                Array.isArray(actual) &&
+                actual.every((property) => typeof property === 'string') &&
+                properties.every((property) => actual.includes(property)));
+        });
+        if (valid)
+            continue;
+        missing.push(`${table}.${indexName}`);
+        if (!onMismatch)
+            continue;
+        // Show only rows that could explain this identity mismatch, and only
+        // catalog identity/type/property fields. Malformed objects are represented
+        // by their type rather than serialized (they can carry arbitrary content).
+        const relevant = rows.filter((row) => indexRowTable(row) === table || indexRowName(row) === indexName);
+        const observed = relevant
+            .slice(0, 3)
+            .map((row) => `{table=${catalogFieldEvidence(indexRowTable(row))}, ` +
+            `index=${catalogFieldEvidence(indexRowName(row))}, ` +
+            `type=${catalogFieldEvidence(indexRowType(row))}, ` +
+            `properties=${catalogPropertiesEvidence(row.property_names)}}`);
+        const message = `${table}.${indexName}: expected table=${catalogFieldEvidence(table)}, ` +
+            `index=${catalogFieldEvidence(indexName)}, type=FTS, ` +
+            `properties=${catalogPropertiesEvidence(properties)}; observed ` +
+            (observed.length > 0 ? observed.join(', ') : 'no matching table or index name') +
+            (relevant.length > 3 ? ` (${relevant.length - 3} catalog rows truncated)` : '');
+        onMismatch({ table, indexName, message: boundCatalogText(message, 2048) });
     }
     return missing;
 }
@@ -418,28 +445,47 @@ export async function buildSearchIndexesOrDegrade(executeQuery, options) {
         // means description search is broken (#2299).
         const failures = await createSearchFTSIndexes(options);
         const indexes = options?.indexes ?? FTS_INDEXES;
-        const missing = await verifySearchFTSIndexes(executeQuery, indexes);
-        if (failures.length === 0 && missing.length === 0)
+        const diagnostics = [];
+        let missing = [];
+        let verificationError;
+        try {
+            missing = await verifySearchFTSIndexes(executeQuery, indexes, (diagnostic) => diagnostics.push(diagnostic));
+        }
+        catch (e) {
+            // A failed catalog read is unknown, not absence. Keep the native build
+            // failures already collected rather than replacing them with this error.
+            verificationError = e instanceof Error ? e.message : String(e);
+        }
+        if (failures.length === 0 && missing.length === 0 && verificationError === undefined) {
             return { ok: true };
-        // A table that failed to build is necessarily missing too — report it once,
-        // with its reason, and keep `missing` for indexes nothing explains.
+        }
+        // A failed DROP may leave an old catalog row present. Build failures stand
+        // on their own; avoid naming the same table again as an unexplained failure.
         const named = new Set(failures.map((f) => `${f.table}.${f.indexName}`));
-        const unexplained = missing.filter((name) => !named.has(name));
+        const unexplained = diagnostics.filter((d) => !named.has(`${d.table}.${d.indexName}`));
         const error = [
             failures.length > 0 ? summarizeFtsIndexBuildFailures(failures, indexes) : '',
             // Structural incompleteness with no thrown error — classified capability
             // (degrade) below, matching prior behavior; a broken *write* surfaces as
             // a thrown IO/checkpoint error and is classified integrity there.
-            unexplained.length > 0 ? `missing indexes after build: ${unexplained.join(', ')}` : '',
+            unexplained.length > 0
+                ? 'missing indexes or mismatched catalog rows after build ' +
+                    '(no build error was returned for these indexes): ' +
+                    unexplained.map((d) => d.message).join('; ')
+                : '',
+            verificationError !== undefined
+                ? `FTS catalog verification failed: ${verificationError}`
+                : '',
         ]
             .filter((part) => part.length > 0)
             .join('; ');
         // Classify per failure, not over the joined text: capability signatures are
         // checked first, so folding the messages together would let an untokenizable
         // row mask a genuinely broken write and downgrade an abort into a degrade.
-        const failureClass = failures.some((f) => classifyFtsBuildError(f.error) === 'integrity')
+        const failureClass = failures.some((f) => classifyFtsBuildError(f.error) === 'integrity') ||
+            (verificationError !== undefined && classifyFtsBuildError(verificationError) === 'integrity')
             ? 'integrity'
-            : classifyFtsBuildError(error);
+            : 'capability';
         return { ok: false, error, failureClass };
     }
     catch (e) {

package/package.json

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