gitnexus 1.6.9-rc.21 → 1.6.9-rc.22

package/dist/core/run-analyze.js

@@ -353,6 +353,20 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         }
         try {
             await initLbug(lbugPath);
+            // Gate on FTS availability BEFORE touching any index. createSearchFTSIndexes
+            // now DROPs each index before recreating it (so schema changes reach existing
+            // DBs); if the extension were unavailable, the drops would run and leave the
+            // DB index-less, only failing at the create step. Fail loudly first — mirrors
+            // the analyze path's `if (ftsAvailable)` gate below — so an unavailable
+            // extension never destroys the existing indexes.
+            const repairFtsAvailable = await loadFTSExtension(undefined, {
+                policy: resolveAnalyzeInstallPolicy(),
+            });
+            if (!repairFtsAvailable) {
+                throw new Error('Cannot repair FTS indexes: the LadybugDB FTS extension is unavailable ' +
+                    '(not pre-installed and could not be installed on this machine). ' +
+                    'Run `gitnexus doctor` to install it, then retry `--repair-fts`.');
+            }
             progress('fts', 85, 'Repairing search indexes...');
             await createSearchFTSIndexes({
                 onIndexStart: options.verbose

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

@@ -1,32 +1,48 @@
-import { createFTSIndex } from '../lbug/lbug-adapter.js';
+import { createFTSIndex, dropFTSIndex } from '../lbug/lbug-adapter.js';
 import { FTS_INDEXES } from './fts-schema.js';
 export async function createSearchFTSIndexes(options) {
     for (const { table, indexName, properties } of FTS_INDEXES) {
         options?.onIndexStart?.(table, indexName);
+        // Drop first so the live `properties` always win. `createFTSIndex` is
+        // idempotent-by-name (skips when the index already exists), so without the
+        // drop a schema change — e.g. adding `description` (#2299) — would never
+        // reach an existing `.lbug` DB on an incremental re-analyze or `--repair-fts`;
+        // the old name+content index would silently persist. `dropFTSIndex` no-ops
+        // when the index is absent (first-ever analyze) and clears the per-connection
+        // memo so the create below actually runs.
+        // ponytail: this rebuilds every FTS index on every analyze instead of
+        // skipping when present; FTS build is proportional to symbol-table size and
+        // runs inside the existing FTS phase. Gate on a stored schema fingerprint if
+        // this rebuild cost ever shows up in analyze profiles.
+        await dropFTSIndex(table, indexName);
         await createFTSIndex(table, indexName, [...properties]);
         options?.onIndexReady?.(table, indexName);
     }
 }
 export async function verifySearchFTSIndexes(executeQuery) {
-    const safeIdentifier = (value) => {
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
-            throw new Error(`Invalid FTS identifier: ${value}`);
-        }
-        return value;
-    };
+    // 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 = record.index_name;
+        const propertyNames = record.property_names;
+        if (typeof indexName !== 'string' || !Array.isArray(propertyNames))
+            continue;
+        propsByIndex.set(indexName, propertyNames.filter((p) => typeof p === 'string'));
+    }
     const missing = [];
-    for (const { table, indexName } of FTS_INDEXES) {
-        const safeTable = safeIdentifier(table);
-        const safeIndex = safeIdentifier(indexName);
-        const probe = `
-      CALL QUERY_FTS_INDEX('${safeTable}', '${safeIndex}', '__gitnexus_fts_probe__', conjunctive := false)
-      RETURN score
-      LIMIT 1
-    `;
-        try {
-            await executeQuery(probe);
-        }
-        catch {
+    for (const { table, indexName, properties } of FTS_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}`);
         }
     }

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

@@ -1,7 +1,40 @@
+// Shared by both index creation (`createSearchFTSIndexes`) and querying
+// (`searchFTSFromLbug` / `verifySearchFTSIndexes`) — the single source of truth
+// for which tables/columns are full-text searchable. Adding `description` here
+// makes doc comments (Javadoc/KDoc/JSDoc/Doxygen/godoc/RDoc) keyword-searchable
+// once they are populated by `descriptionExtractor` (#2270/#2286, issue #2299).
+//
+// IMPORTANT: every property must be a real column on its table (see
+// `core/lbug/schema.ts`). `File` has no `description` column, so it stays
+// name+content. All other entries below carry a `description` column.
+//
+// Tables beyond the original 5 mirror `EMBEDDABLE_LABELS` (embeddings/types.ts):
+// indexing the same set keeps a symbol's doc comment both keyword- and
+// semantically-searchable.
+const FTS_PROPERTIES = ['name', 'content', 'description'];
 export const FTS_INDEXES = [
+    // File has no `description` column — keep it name+content only.
     { table: 'File', indexName: 'file_fts', properties: ['name', 'content'] },
-    { table: 'Function', indexName: 'function_fts', properties: ['name', 'content'] },
-    { table: 'Class', indexName: 'class_fts', properties: ['name', 'content'] },
-    { table: 'Method', indexName: 'method_fts', properties: ['name', 'content'] },
-    { table: 'Interface', indexName: 'interface_fts', properties: ['name', 'content'] },
+    // Original 5 (minus File) gain `description`.
+    { table: 'Function', indexName: 'function_fts', properties: FTS_PROPERTIES },
+    { table: 'Class', indexName: 'class_fts', properties: FTS_PROPERTIES },
+    { table: 'Method', indexName: 'method_fts', properties: FTS_PROPERTIES },
+    { table: 'Interface', indexName: 'interface_fts', properties: FTS_PROPERTIES },
+    // Remaining EMBEDDABLE_LABELS symbol tables — all CODE_ELEMENT_BASE-shaped
+    // (or a superset), so all carry name + content + description columns.
+    { table: 'Constructor', indexName: 'constructor_fts', properties: FTS_PROPERTIES },
+    { table: 'Struct', indexName: 'struct_fts', properties: FTS_PROPERTIES },
+    { table: 'Enum', indexName: 'enum_fts', properties: FTS_PROPERTIES },
+    { table: 'Trait', indexName: 'trait_fts', properties: FTS_PROPERTIES },
+    { table: 'Impl', indexName: 'impl_fts', properties: FTS_PROPERTIES },
+    { table: 'Macro', indexName: 'macro_fts', properties: FTS_PROPERTIES },
+    { table: 'Namespace', indexName: 'namespace_fts', properties: FTS_PROPERTIES },
+    { table: 'TypeAlias', indexName: 'type_alias_fts', properties: FTS_PROPERTIES },
+    { table: 'Typedef', indexName: 'typedef_fts', properties: FTS_PROPERTIES },
+    { table: 'Const', indexName: 'const_fts', properties: FTS_PROPERTIES },
+    { table: 'Property', indexName: 'property_fts', properties: FTS_PROPERTIES },
+    { table: 'Record', indexName: 'record_fts', properties: FTS_PROPERTIES },
+    { table: 'Union', indexName: 'union_fts', properties: FTS_PROPERTIES },
+    { table: 'Static', indexName: 'static_fts', properties: FTS_PROPERTIES },
+    { table: 'Variable', indexName: 'variable_fts', properties: FTS_PROPERTIES },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.9-rc.21",
+  "version": "1.6.9-rc.22",
   "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",

package/scripts/cross-platform-tests.ts

@@ -70,6 +70,7 @@ const LBUG_NATIVE = [
   'test/integration/local-backend-calltool.test.ts',
   'test/integration/search-core.test.ts',
   'test/integration/search-pool.test.ts',
+  'test/integration/fts-description-search.test.ts',
   'test/integration/staleness-and-stability.test.ts',
   'test/integration/analyze-wal-checkpoint-failure.test.ts',
 ];