gitnexus 1.6.10-rc.45 → 1.6.10-rc.46

package/dist/core/run-analyze.js

@@ -15,7 +15,7 @@ import { runPipelineFromRepo } from './ingestion/pipeline.js';
 import { resetDegradedParseCounter } from './tree-sitter/safe-parse.js';
 import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, closeLbugBeforeExit, loadCachedEmbeddings, deleteNodesForFiles, deleteAllCommunitiesAndProcesses, deleteAllInterprocTaintPaths, deleteAllCallSummaries, deleteAllInjects, queryImportersBatch, loadFTSExtension, wipeLbugDbFiles, LbugWipeError, DELETE_FILES_CHUNK_SIZE, } from './lbug/lbug-adapter.js';
 import { escapeCypherString } from './lbug/cypher-escape.js';
-import { createSearchFTSIndexes, initialiseSearchFTSStemmer, verifySearchFTSIndexes, } from './search/fts-indexes.js';
+import { buildSearchIndexesOrDegrade, createSearchFTSIndexes, initialiseSearchFTSStemmer, verifySearchFTSIndexes, } from './search/fts-indexes.js';
 import { cjkSegmentationModeMismatch, getSearchFTSCjkSegmentation, initialiseSearchFTSCjkSegmentation, } from './search/cjk-segmentation.js';
 import { getExtensionCapabilities, resolveAnalyzeInstallPolicy } from './lbug/extension-loader.js';
 import { diagnoseExtensionLoad } from './lbug/extension-load-error.js';
@@ -1206,8 +1206,17 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         const ftsAvailable = await loadFTSExtension(undefined, {
             policy: resolveAnalyzeInstallPolicy(),
         });
+        // Tracks whether search indexes actually ended up usable this run — starts
+        // as ftsAvailable (extension loaded) but flips to false below when the
+        // build/verify step itself fails, so capabilities.fts.status / ftsSkipped
+        // stay honest even though that failure no longer aborts the whole analyze.
+        let ftsReady = ftsAvailable;
         if (ftsAvailable) {
-            await createSearchFTSIndexes({
+            // Degrade rather than throw: createSearchFTSIndexes re-tokenizes every
+            // stored row on every run, so a native tokenizer error on a single
+            // pre-existing row (#2544/#2546) must not discard this run's otherwise-
+            // successful graph/embeddings work — only keyword search degrades.
+            const ftsResult = await buildSearchIndexesOrDegrade(executeQuery, {
                 onIndexStart: options.verbose
                     ? (table, indexName) => log(`FTS: creating ${table}.${indexName}`)
                     : undefined,
@@ -1215,12 +1224,15 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                     ? (table, indexName) => log(`FTS: ready ${table}.${indexName}`)
                     : undefined,
             });
-            const missingIndexNames = await verifySearchFTSIndexes(executeQuery);
-            if (missingIndexNames.length > 0) {
-                throw new Error(`FTS verification failed - missing indexes after analyze: ${missingIndexNames.join(', ')}. ` +
-                    'Check FTS extension availability, then retry `gitnexus analyze --force` for a full rebuild.');
+            if (ftsResult.ok) {
+                progress('fts', 90, 'Search indexes ready');
+            }
+            else {
+                ftsReady = false;
+                log(`FTS index build failed (${ftsResult.error}) — keyword search degraded this run. ` +
+                    'Graph and embeddings analysis completed successfully. Run `gitnexus analyze --repair-fts` to retry.');
+                progress('fts', 90, 'Search indexes skipped (build failed)');
             }
-            progress('fts', 90, 'Search indexes ready');
         }
         else {
             // For a missing runtime dependency (#2374) the file is present, so the
@@ -1559,7 +1571,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 // meta.json / `gitnexus doctor` honest about degraded search.
                 fts: {
                     provider: 'ladybugdb-fts',
-                    status: ftsAvailable ? runtimeCapabilities.fts : 'unavailable',
+                    status: ftsReady ? runtimeCapabilities.fts : 'unavailable',
                 },
                 vectorSearch: {
                     provider: effectiveSemanticMode === 'vector-index' ? 'ladybugdb-vector' : 'exact-scan',
@@ -1723,7 +1735,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             repoPath,
             stats: meta.stats,
             pipelineResult,
-            ftsSkipped: !ftsAvailable,
+            ftsSkipped: !ftsReady,
             isPrimaryBranch: !placement.branch,
         };
     }

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

@@ -26,3 +26,18 @@ export declare function initialiseSearchFTSStemmer(): string;
 export declare function getSearchFTSStemmer(): string;
 export declare function createSearchFTSIndexes(options?: CreateSearchFTSIndexesOptions): Promise<void>;
 export declare function verifySearchFTSIndexes(executeQuery: (cypher: string) => Promise<unknown[]>): Promise<string[]>;
+export interface BuildSearchIndexesResult {
+    ok: boolean;
+    error?: string;
+}
+/**
+ * Build + verify FTS indexes, catching any failure instead of letting it
+ * propagate. `createSearchFTSIndexes` re-tokenizes every stored row on every
+ * analyze run (see the `ponytail:` comment above) — a native LadybugDB
+ * tokenizer error on a single pre-existing row (e.g. a "Failed calling
+ * LOWER: Invalid UTF-8", #2544/#2546) must not discard an otherwise-
+ * successful analyze's graph/embeddings work. The caller degrades keyword
+ * search for this run instead, mirroring the existing FTS-extension-
+ * unavailable degrade path in `run-analyze.ts`.
+ */
+export declare function buildSearchIndexesOrDegrade(executeQuery: (cypher: string) => Promise<unknown[]>, options?: CreateSearchFTSIndexesOptions): Promise<BuildSearchIndexesResult>;

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

@@ -152,3 +152,26 @@ export async function verifySearchFTSIndexes(executeQuery) {
     }
     return missing;
 }
+/**
+ * Build + verify FTS indexes, catching any failure instead of letting it
+ * propagate. `createSearchFTSIndexes` re-tokenizes every stored row on every
+ * analyze run (see the `ponytail:` comment above) — a native LadybugDB
+ * tokenizer error on a single pre-existing row (e.g. a "Failed calling
+ * LOWER: Invalid UTF-8", #2544/#2546) must not discard an otherwise-
+ * successful analyze's graph/embeddings work. The caller degrades keyword
+ * search for this run instead, mirroring the existing FTS-extension-
+ * unavailable degrade path in `run-analyze.ts`.
+ */
+export async function buildSearchIndexesOrDegrade(executeQuery, options) {
+    try {
+        await createSearchFTSIndexes(options);
+        const missing = await verifySearchFTSIndexes(executeQuery);
+        if (missing.length > 0) {
+            return { ok: false, error: `missing indexes after build: ${missing.join(', ')}` };
+        }
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.45",
+  "version": "1.6.10-rc.46",
   "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",