gitnexus 1.6.6-rc.22 → 1.6.6-rc.24

package/README.md

@@ -151,7 +151,8 @@ Your AI agent gets these tools automatically:
 ```bash
 gitnexus setup                   # Configure MCP for your editors (one-time)
 gitnexus analyze [path]          # Index a repository (or update stale index)
-gitnexus analyze --force         # Force full re-index
+gitnexus analyze --repair-fts    # Fast path: rebuild/verify only FTS indexes on existing index data
+gitnexus analyze --force         # Full rebuild: re-parse + graph rebuild + FTS rebuild
 gitnexus analyze --embeddings    # Enable embedding generation (slower, better search)
 gitnexus analyze --skip-agents-md  # Preserve custom AGENTS.md/CLAUDE.md gitnexus section edits
 gitnexus analyze --verbose       # Log skipped files when parsers are unavailable

package/dist/cli/analyze.d.ts

@@ -9,6 +9,7 @@
  */
 export interface AnalyzeOptions {
     force?: boolean;
+    repairFts?: boolean;
     /**
      * Embedding generation toggle. Commander parses `--embeddings [limit]` as:
      *   - `undefined` when the flag is omitted

package/dist/cli/analyze.js

@@ -216,6 +216,12 @@ export const analyzeCommand = async (inputPath, options) => {
         }
         process.env.GITNEXUS_EMBEDDING_DEVICE = options.embeddingDevice;
     }
+    if (options?.repairFts && options?.force) {
+        cliError('  Cannot combine `--repair-fts` with `--force`. ' +
+            'Use `--repair-fts` for fast FTS-only repair, or `--force` for a full rebuild.\n');
+        process.exitCode = 1;
+        return;
+    }
     console.log('\n  GitNexus Analyzer\n');
     // `--index-only` is the stronger contract — it suppresses every form of file
     // injection, including community skill writes that `--skills` would normally
@@ -368,9 +374,11 @@ export const analyzeCommand = async (inputPath, options) => {
             // needs a fresh pipelineResult. Has no bearing on the registry
             // collision guard (see allowDuplicateName below).
             force: options?.force || options?.skills,
+            repairFts: options?.repairFts,
             embeddings: embeddingsEnabled,
             embeddingsNodeLimit,
             dropEmbeddings: options?.dropEmbeddings,
+            verbose: options?.verbose,
             skipGit: options?.skipGit,
             skipAgentsMd,
             skipSkills,
@@ -411,6 +419,18 @@ export const analyzeCommand = async (inputPath, options) => {
             // runFullAnalysis never opens LadybugDB, so no native handles prevent exit.
             return;
         }
+        if (result.ftsRepairedOnly) {
+            clearInterval(elapsedTimer);
+            process.removeListener('SIGINT', sigintHandler);
+            console.log = origLog;
+            // eslint-disable-next-line no-console -- restoring after intentional progress-bar routing
+            console.warn = origWarn;
+            // eslint-disable-next-line no-console -- restoring after intentional progress-bar routing
+            console.error = origError;
+            bar.stop();
+            console.log('  FTS indexes repaired successfully\n');
+            return;
+        }
         // Post-finalize invariant (#1169): runFullAnalysis nominally writes
         // meta.json and registers the repo, but on Windows it has been
         // observed to return successfully with neither artifact present

package/dist/cli/index.js

@@ -17,6 +17,7 @@ program
     .command('analyze [path]')
     .description('Index a repository (full analysis)')
     .option('-f, --force', 'Force full re-index even if up to date')
+    .option('--repair-fts', 'Repair/rebuild search FTS indexes without full re-analysis')
     .option('--embeddings [limit]', 'Enable embedding generation for semantic search (off by default). ' +
     'Optional [limit] overrides the 50,000-node safety cap; pass 0 to disable the cap entirely.')
     .option('--drop-embeddings', 'Drop existing embeddings on rebuild. By default, an `analyze` without `--embeddings` ' +

package/dist/core/ingestion/filesystem-walker.js

@@ -48,12 +48,30 @@ export const walkRepositoryPaths = async (repoPath, onProgress) => {
     }
     if (skippedLarge > 0) {
         const isDefault = maxFileSizeBytes === DEFAULT_MAX_FILE_SIZE_BYTES;
+        const isOverrideUnset = !process.env.GITNEXUS_MAX_FILE_SIZE;
         const suffix = isDefault ? ', likely generated/vendored' : '';
         logger.warn(`  Skipped ${skippedLarge} large files (>${maxFileSizeBytes / 1024}KB${suffix})`);
-        if (isVerboseIngestionEnabled()) {
-            for (const p of skippedLargePaths) {
-                logger.warn(`  - ${p}`);
-            }
+        // Always show at least the first few paths so users can diagnose why
+        // edges are missing from a specific file (issue #1659). The full list is
+        // gated behind GITNEXUS_VERBOSE=1 to avoid flooding output on repos with
+        // many generated/vendored blobs. Sort before slicing so the preview is
+        // stable across runs (fs.stat callbacks race within each batch).
+        skippedLargePaths.sort();
+        const SKIPPED_PREVIEW_CAP = 5;
+        const showAll = isVerboseIngestionEnabled() || skippedLargePaths.length <= SKIPPED_PREVIEW_CAP;
+        const preview = showAll ? skippedLargePaths : skippedLargePaths.slice(0, SKIPPED_PREVIEW_CAP);
+        for (const p of preview) {
+            logger.warn(`  - ${p}`);
+        }
+        if (!showAll) {
+            const remaining = skippedLargePaths.length - SKIPPED_PREVIEW_CAP;
+            logger.warn(`  ...and ${remaining} more (set GITNEXUS_VERBOSE=1 to list them all)`);
+        }
+        // Only hint about the env var when the user has not set it at all. An
+        // explicit GITNEXUS_MAX_FILE_SIZE=512 happens to resolve to the same
+        // bytes as the default but the operator clearly already knows the knob.
+        if (isDefault && isOverrideUnset) {
+            logger.warn(`  Set GITNEXUS_MAX_FILE_SIZE=<KB> to include files above the default cap.`);
         }
     }
     return entries;

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

@@ -1454,7 +1454,8 @@ export const createFTSIndex = async (tableName, indexName, properties, stemmer =
     if (ensuredFTSIndexes.has(key))
         return;
     if (!(await loadFTSExtension())) {
-        return;
+        throw new Error(`FTS extension unavailable - cannot create FTS index ${tableName}.${indexName}. ` +
+            'Run `gitnexus doctor` and ensure the LadybugDB FTS extension is installed and loadable on this machine.');
     }
     const propList = properties.map((p) => `'${p}'`).join(', ');
     const query = `CALL CREATE_FTS_INDEX('${tableName}', '${indexName}', [${propList}], stemmer := '${stemmer}')`;

package/dist/core/run-analyze.d.ts

@@ -20,6 +20,10 @@ export interface AnalyzeOptions {
      * bypass. See `allowDuplicateName` below.
      */
     force?: boolean;
+    /** Repair only search indexes without re-running full parsing/indexing. */
+    repairFts?: boolean;
+    /** Emit per-index FTS create logs. */
+    verbose?: boolean;
     embeddings?: boolean;
     /**
      * Override the auto-skip node-count cap for embedding generation.
@@ -74,6 +78,8 @@ export interface AnalyzeResult {
     alreadyUpToDate?: boolean;
     /** The raw pipeline result — only populated when needed by callers (e.g. skill generation). */
     pipelineResult?: any;
+    /** True when analyze only repaired FTS indexes and skipped pipeline re-analysis. */
+    ftsRepairedOnly?: boolean;
 }
 export { deriveEmbeddingMode, DEFAULT_EMBEDDING_NODE_LIMIT } from './embedding-mode.js';
 export type { EmbeddingMode } from './embedding-mode.js';

package/dist/core/run-analyze.js

@@ -13,7 +13,7 @@ import fs from 'fs/promises';
 import { execFileSync } from 'child_process';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
 import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, loadCachedEmbeddings, deleteNodesForFile, deleteAllCommunitiesAndProcesses, queryImporters, } from './lbug/lbug-adapter.js';
-import { createSearchFTSIndexes } from './search/fts-indexes.js';
+import { createSearchFTSIndexes, verifySearchFTSIndexes } from './search/fts-indexes.js';
 import { getStoragePaths, saveMeta, loadMeta, ensureGitNexusIgnored, registerRepo, cleanupOldKuzuFiles, INCREMENTAL_SCHEMA_VERSION, } from '../storage/repo-manager.js';
 import { computeFileHashes, diffFileHashes } from '../storage/file-hash.js';
 import { extractChangedSubgraph, computeEffectiveWriteSet, } from './incremental/subgraph-extract.js';
@@ -68,6 +68,70 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     const repoHasGit = hasGitDir(repoPath);
     const currentCommit = repoHasGit ? getCurrentCommit(repoPath) : '';
     const existingMeta = await loadMeta(storagePath);
+    // ── FTS-only repair path ────────────────────────────────────────────
+    if (options.repairFts) {
+        if (!existingMeta) {
+            throw new Error('Cannot repair FTS indexes because this repository has not been analyzed yet. ' +
+                'Run `gitnexus analyze` first to create the initial index, then retry `--repair-fts`.');
+        }
+        let lbugStat;
+        try {
+            lbugStat = await fs.lstat(lbugPath);
+        }
+        catch {
+            throw new Error(`Cannot repair FTS indexes: graph store at ${lbugPath} is missing. ` +
+                'Run `gitnexus analyze` (full) to rebuild from scratch.');
+        }
+        if (!lbugStat.isFile()) {
+            const foundType = lbugStat.isDirectory()
+                ? 'a directory'
+                : lbugStat.isSymbolicLink()
+                    ? 'a symbolic link'
+                    : lbugStat.isSocket()
+                        ? 'a socket'
+                        : lbugStat.isBlockDevice()
+                            ? 'a block device'
+                            : lbugStat.isCharacterDevice()
+                                ? 'a character device'
+                                : lbugStat.isFIFO()
+                                    ? 'a FIFO'
+                                    : 'not a regular file';
+            throw new Error(`Cannot repair FTS indexes: graph store at ${lbugPath} is ${foundType} (expected a file). ` +
+                'Run `gitnexus analyze` (full) to rebuild from scratch.');
+        }
+        try {
+            await initLbug(lbugPath);
+            progress('fts', 85, 'Repairing search indexes...');
+            await createSearchFTSIndexes({
+                onIndexStart: options.verbose
+                    ? (table, indexName) => log(`FTS: creating ${table}.${indexName}`)
+                    : undefined,
+                onIndexReady: options.verbose
+                    ? (table, indexName) => log(`FTS: ready ${table}.${indexName}`)
+                    : undefined,
+            });
+            const missing = await verifySearchFTSIndexes(executeQuery);
+            if (missing.length > 0) {
+                throw new Error(`FTS repair failed - missing indexes after rebuild: ${missing.join(', ')}. ` +
+                    'Run `gitnexus analyze --force` to perform a full graph+FTS rebuild; ' +
+                    'if that also fails, verify FTS extension availability via `gitnexus doctor`.');
+            }
+            await ensureGitNexusIgnored(repoPath);
+            progress('fts', 90, 'Search indexes ready');
+            progress('done', 100, 'Done');
+            return {
+                repoName: options.registryName ??
+                    getInferredRepoName(repoPath) ??
+                    path.basename(resolveRepoIdentityRoot(repoPath)),
+                repoPath,
+                stats: existingMeta.stats ?? {},
+                ftsRepairedOnly: true,
+            };
+        }
+        finally {
+            await closeLbug().catch(() => { });
+        }
+    }
     // ── Crash recovery: dirty flag forces full rebuild ────────────────
     // If the previous incremental run set incrementalInProgress and didn't
     // clear it, the on-disk index may be in a half-state. Cheapest path
@@ -420,7 +484,19 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         }
         // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
         progress('fts', 85, 'Creating search indexes...');
-        await createSearchFTSIndexes();
+        await createSearchFTSIndexes({
+            onIndexStart: options.verbose
+                ? (table, indexName) => log(`FTS: creating ${table}.${indexName}`)
+                : undefined,
+            onIndexReady: options.verbose
+                ? (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.');
+        }
         progress('fts', 90, 'Search indexes ready');
         // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
         // Runs on BOTH the full-rebuild path and the incremental path:

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

@@ -1 +1,6 @@
-export declare function createSearchFTSIndexes(): Promise<void>;
+export interface CreateSearchFTSIndexesOptions {
+    onIndexStart?: (table: string, indexName: string) => void;
+    onIndexReady?: (table: string, indexName: string) => void;
+}
+export declare function createSearchFTSIndexes(options?: CreateSearchFTSIndexesOptions): Promise<void>;
+export declare function verifySearchFTSIndexes(executeQuery: (cypher: string) => Promise<unknown[]>): Promise<string[]>;

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

@@ -1,7 +1,34 @@
 import { createFTSIndex } from '../lbug/lbug-adapter.js';
 import { FTS_INDEXES } from './fts-schema.js';
-export async function createSearchFTSIndexes() {
+export async function createSearchFTSIndexes(options) {
     for (const { table, indexName, properties } of FTS_INDEXES) {
+        options?.onIndexStart?.(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;
+    };
+    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 {
+            missing.push(`${table}.${indexName}`);
+        }
+    }
+    return missing;
+}

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

@@ -894,7 +894,7 @@ export class LocalBackend {
             definitions: definitions.slice(0, 20), // cap standalone definitions
             timing,
             ...(!ftsUsed && {
-                warning: 'FTS indexes missing — keyword search degraded. Run: gitnexus analyze --force to rebuild indexes.',
+                warning: 'FTS indexes missing — keyword search degraded. Run: gitnexus analyze --repair-fts (or gitnexus analyze --force) to rebuild indexes.',
             }),
         };
     }

package/dist/server/api.js

@@ -1071,7 +1071,7 @@ export const createServer = async (port, host = '127.0.0.1') => {
             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.';
+                    'FTS indexes missing — keyword search degraded. Run: gitnexus analyze --repair-fts (or gitnexus analyze --force) to rebuild indexes.';
             }
             res.json(response);
         }

package/package.json

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