gitnexus 1.6.3 → 1.6.4-rc.10

package/dist/core/run-analyze.js

@@ -12,6 +12,7 @@ import path from 'path';
 import fs from 'fs/promises';
 import { runPipelineFromRepo } from './ingestion/pipeline.js';
 import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, loadCachedEmbeddings, } from './lbug/lbug-adapter.js';
+import { createSearchFTSIndexes } from './search/fts-indexes.js';
 import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, cleanupOldKuzuFiles, } from '../storage/repo-manager.js';
 import { getCurrentCommit, getRemoteUrl, hasGitDir, getInferredRepoName } from '../storage/git.js';
 import { generateAIContextFiles } from '../cli/ai-context.js';
@@ -165,12 +166,9 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             progress('lbug', pct, msg);
         });
         // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
-        // FTS indexes are created lazily on first `query`/`context` call instead
-        // of eagerly here. On small repos / CI runners the LadybugDB
-        // CREATE_FTS_INDEX cost is ~440 ms × 5 (≈2 s) regardless of table size,
-        // which dominated `analyze` runtime and pushed Windows CI past its
-        // 30 s test budget. Lazy creation is implemented in
-        // `core/search/bm25-index.ts` via `ensureFTSIndex`.
+        progress('fts', 85, 'Creating search indexes...');
+        await createSearchFTSIndexes();
+        progress('fts', 90, 'Search indexes ready');
         // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
         if (cachedEmbeddings.length > 0) {
             const cachedDims = cachedEmbeddings[0].embedding.length;

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

@@ -3,12 +3,6 @@
  *
  * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
- *
- * FTS indexes are created lazily on first query (via `ensureFTSIndex`) — see
- * `lbug-adapter.ts` for the rationale. This keeps `analyze` fast (the
- * ~440 ms × 5 LadybugDB CREATE_FTS_INDEX cost dominates pipeline time on
- * small repos / CI runners) at the cost of paying that overhead on the
- * first `query`/`context` call in a session.
  */
 export interface BM25SearchResult {
     filePath: string;
@@ -16,17 +10,6 @@ export interface BM25SearchResult {
     rank: number;
     nodeIds?: string[];
 }
-/**
- * Drop all ensured-FTS cache entries for a given repoId.
- *
- * Called from the pool-close listener so that a pool teardown / recreation
- * forces the next `searchFTSFromLbug` call to re-issue `CREATE_FTS_INDEX`
- * against the fresh connection rather than trust stale ensure-state from a
- * previous pool lifetime.
- *
- * Exported for tests; the listener wiring is internal.
- */
-export declare function invalidateEnsuredFTSForRepo(repoId: string): void;
 /**
  * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *

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

@@ -3,96 +3,9 @@
  *
  * Uses LadybugDB's built-in full-text search indexes for keyword-based search.
  * Always reads from the database (no cached state to drift).
- *
- * FTS indexes are created lazily on first query (via `ensureFTSIndex`) — see
- * `lbug-adapter.ts` for the rationale. This keeps `analyze` fast (the
- * ~440 ms × 5 LadybugDB CREATE_FTS_INDEX cost dominates pipeline time on
- * small repos / CI runners) at the cost of paying that overhead on the
- * first `query`/`context` call in a session.
- */
-import { queryFTS, ensureFTSIndex } from '../lbug/lbug-adapter.js';
-/**
- * FTS schema served by `searchFTSFromLbug`. Centralised so that both the
- * CLI/pipeline path and the MCP pool path use identical (table, index,
- * properties) tuples and the lazy-create logic stays in one place.
- */
-const FTS_INDEXES = [
-    { 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'] },
-];
-/**
- * Per-process cache for the MCP pool path: tracks which `(repoId, table)`
- * pairs have been ensured. The CLI/pipeline path gets its own cache inside
- * `lbug-adapter.ts` keyed by table/index, scoped to the singleton connection.
- *
- * IMPORTANT: an entry is added ONLY when the index was confirmed to exist
- * (CREATE_FTS_INDEX succeeded, or failed with `'already exists'`). Other
- * failures (transient lock errors, missing extension, etc.) leave the key
- * unset so the next query retries instead of silently caching the failure.
- *
- * Entries for a given repoId are invalidated when its pool is closed —
- * see the `addPoolCloseListener` registration in `searchFTSFromLbug`.
- */
-const ensuredPoolFTS = new Set();
-/**
- * Drop all ensured-FTS cache entries for a given repoId.
- *
- * Called from the pool-close listener so that a pool teardown / recreation
- * forces the next `searchFTSFromLbug` call to re-issue `CREATE_FTS_INDEX`
- * against the fresh connection rather than trust stale ensure-state from a
- * previous pool lifetime.
- *
- * Exported for tests; the listener wiring is internal.
  */
-export function invalidateEnsuredFTSForRepo(repoId) {
-    const prefix = `${repoId}:`;
-    for (const key of ensuredPoolFTS) {
-        if (key.startsWith(prefix))
-            ensuredPoolFTS.delete(key);
-    }
-}
-/**
- * Tracks whether we've already wired the pool-close listener for this
- * process. The pool adapter is dynamically imported, so registration
- * happens lazily on the first MCP-pool-backed FTS query.
- */
-let poolCloseListenerRegistered = false;
-function registerPoolCloseListenerOnce(addPoolCloseListener) {
-    if (poolCloseListenerRegistered)
-        return;
-    poolCloseListenerRegistered = true;
-    addPoolCloseListener((repoId) => invalidateEnsuredFTSForRepo(repoId));
-}
-async function ensureFTSIndexViaExecutor(executor, repoId, table, indexName, properties) {
-    const key = `${repoId}:${table}:${indexName}`;
-    if (ensuredPoolFTS.has(key))
-        return;
-    const propList = properties.map((p) => `'${p}'`).join(', ');
-    try {
-        await executor(`CALL CREATE_FTS_INDEX('${table}', '${indexName}', [${propList}], stemmer := 'porter')`);
-        // Index was created successfully — safe to cache.
-        ensuredPoolFTS.add(key);
-    }
-    catch (e) {
-        // 'already exists' is the happy path (index persists on disk between
-        // process invocations) — cache it. Anything else is treated as a
-        // transient failure: surface a one-time warning and leave the key
-        // unset so the NEXT query retries rather than silently using a
-        // cached failure (which previously disabled BM25 for the whole
-        // process for that repo).
-        const msg = String(e?.message ?? '');
-        if (msg.includes('already exists')) {
-            ensuredPoolFTS.add(key);
-        }
-        else {
-            console.warn(`[gitnexus] FTS index ensure failed for repo "${repoId}" table "${table}" ` +
-                `(index "${indexName}"): ${msg || e}. Will retry on next query.`);
-        }
-    }
-}
+import { queryFTS } from '../lbug/lbug-adapter.js';
+import { FTS_INDEXES } from './fts-schema.js';
 /**
  * Execute a single FTS query via a custom executor (for MCP connection pool).
  * Returns the same shape as core queryFTS (from LadybugDB adapter).
@@ -134,41 +47,23 @@ async function queryFTSViaExecutor(executor, tableName, indexName, query, limit)
  * @returns Ranked search results from FTS indexes
  */
 export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
-    let fileResults, functionResults, classResults, methodResults, interfaceResults;
+    const resultsByIndex = [];
     if (repoId) {
         // Use MCP connection pool via dynamic import
         // IMPORTANT: FTS queries run sequentially to avoid connection contention.
         // The MCP pool supports multiple connections, but FTS is best run serially.
         const poolMod = await import('../lbug/pool-adapter.js');
-        const { executeQuery, addPoolCloseListener } = poolMod;
-        // Register the pool-close listener lazily on first use so a teardown of
-        // the pool entry (LRU eviction, idle timeout, explicit close) drops the
-        // matching `ensuredPoolFTS` entries. Without this, stale ensure-state
-        // can outlive the pool that produced it.
-        registerPoolCloseListenerOnce(addPoolCloseListener);
+        const { executeQuery } = poolMod;
         const executor = (cypher) => executeQuery(repoId, cypher);
-        // Lazy-create FTS indexes on first query for this repo (analyze no longer
-        // creates them up-front, so we ensure them here). Cached per-process.
-        for (const { table, indexName, properties } of FTS_INDEXES) {
-            await ensureFTSIndexViaExecutor(executor, repoId, table, indexName, properties);
+        for (const { table, indexName } of FTS_INDEXES) {
+            resultsByIndex.push(await queryFTSViaExecutor(executor, table, indexName, query, limit));
         }
-        fileResults = await queryFTSViaExecutor(executor, 'File', 'file_fts', query, limit);
-        functionResults = await queryFTSViaExecutor(executor, 'Function', 'function_fts', query, limit);
-        classResults = await queryFTSViaExecutor(executor, 'Class', 'class_fts', query, limit);
-        methodResults = await queryFTSViaExecutor(executor, 'Method', 'method_fts', query, limit);
-        interfaceResults = await queryFTSViaExecutor(executor, 'Interface', 'interface_fts', query, limit);
     }
     else {
         // Use core lbug adapter (CLI / pipeline context) — also sequential for safety.
-        // Lazy-create FTS indexes on first query (analyze no longer does it).
-        for (const { table, indexName, properties } of FTS_INDEXES) {
-            await ensureFTSIndex(table, indexName, [...properties]).catch(() => { });
+        for (const { table, indexName } of FTS_INDEXES) {
+            resultsByIndex.push(await queryFTS(table, indexName, query, limit, false).catch(() => []));
         }
-        fileResults = await queryFTS('File', 'file_fts', query, limit, false).catch(() => []);
-        functionResults = await queryFTS('Function', 'function_fts', query, limit, false).catch(() => []);
-        classResults = await queryFTS('Class', 'class_fts', query, limit, false).catch(() => []);
-        methodResults = await queryFTS('Method', 'method_fts', query, limit, false).catch(() => []);
-        interfaceResults = await queryFTS('Interface', 'interface_fts', query, limit, false).catch(() => []);
     }
     // Collect all node scores per filePath to track which nodes actually matched
     const fileNodeScores = new Map();
@@ -179,11 +74,8 @@ export const searchFTSFromLbug = async (query, limit = 20, repoId) => {
             fileNodeScores.get(r.filePath).push({ score: r.score, nodeId: r.nodeId });
         }
     };
-    addResults(fileResults);
-    addResults(functionResults);
-    addResults(classResults);
-    addResults(methodResults);
-    addResults(interfaceResults);
+    for (const results of resultsByIndex)
+        addResults(results);
     // Sum the top-3 highest-scoring nodes per file and collect their nodeIds.
     // Summing all nodes naively inflates scores for files with many mediocre
     // matches (e.g. test files) over files with a single highly-relevant symbol.

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

@@ -0,0 +1 @@
+export declare function createSearchFTSIndexes(): Promise<void>;

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

@@ -0,0 +1,7 @@
+import { createFTSIndex } from '../lbug/lbug-adapter.js';
+import { FTS_INDEXES } from './fts-schema.js';
+export async function createSearchFTSIndexes() {
+    for (const { table, indexName, properties } of FTS_INDEXES) {
+        await createFTSIndex(table, indexName, [...properties]);
+    }
+}

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

@@ -0,0 +1,6 @@
+export interface FTSIndexDefinition {
+    readonly table: string;
+    readonly indexName: string;
+    readonly properties: readonly string[];
+}
+export declare const FTS_INDEXES: readonly FTSIndexDefinition[];

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

@@ -0,0 +1,7 @@
+export const FTS_INDEXES = [
+    { 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'] },
+];

package/dist/mcp/core/embedder.js

@@ -5,6 +5,8 @@
  * For MCP, we only need to compute query embeddings, not batch embed.
  */
 import { pipeline, env } from '@huggingface/transformers';
+import os from 'os';
+import { join } from 'path';
 import { isHttpMode, getHttpDimensions, httpEmbedQuery, } from '../../core/embeddings/http-client.js';
 import { silenceStdout, restoreStdout, realStderrWrite } from '../../core/lbug/pool-adapter.js';
 // Model config
@@ -34,7 +36,7 @@ export const initEmbedder = async () => {
             // ./node_modules/.cache inside its own install dir, which is unwritable
             // when gitnexus is installed globally (e.g. /usr/lib/node_modules/).
             // Respect HF_HOME if set, otherwise fall back to ~/.cache/huggingface.
-            env.cacheDir = process.env.HF_HOME ?? `${process.env.HOME}/.cache/huggingface`;
+            env.cacheDir = process.env.HF_HOME ?? join(os.homedir(), '.cache', 'huggingface');
             console.error('GitNexus: Loading embedding model (first search may take a moment)...');
             // Try GPU first (DirectML on Windows, CUDA on Linux), fall back to CPU
             const isWindows = process.platform === 'win32';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.3",
+  "version": "1.6.4-rc.10",
   "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/skills/gitnexus-cli.md

@@ -23,7 +23,7 @@ Run from the project root. This parses all source files, builds the knowledge gr
 | `--embeddings` | Enable embedding generation for semantic search (off by default) |
 | `--drop-embeddings` | Drop existing embeddings on rebuild. By default, an `analyze` without `--embeddings` preserves them. |
 
-**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. In Claude Code, a PostToolUse hook runs `analyze` automatically after `git commit` and `git merge`, preserving embeddings if previously generated.
+**When to run:** First time in a project, after major code changes, or when `gitnexus://repo/{name}/context` reports the index is stale. In Claude Code, a PostToolUse hook detects staleness after `git commit` and `git merge` and notifies the agent to run `analyze` — the hook does not run analyze itself, to avoid blocking the agent for up to 120s and risking KuzuDB corruption on timeout.
 
 ### status — Check index freshness