gitnexus 1.3.8 → 1.3.10

package/dist/cli/index.js

@@ -2,18 +2,8 @@
 // Heap re-spawn removed — only analyze.ts needs the 8GB heap (via its own ensureHeap()).
 // Removing it from here improves MCP server startup time significantly.
 import { Command } from 'commander';
-import { analyzeCommand } from './analyze.js';
-import { serveCommand } from './serve.js';
-import { listCommand } from './list.js';
-import { statusCommand } from './status.js';
-import { mcpCommand } from './mcp.js';
-import { cleanCommand } from './clean.js';
-import { setupCommand } from './setup.js';
-import { augmentCommand } from './augment.js';
-import { wikiCommand } from './wiki.js';
-import { queryCommand, contextCommand, impactCommand, cypherCommand } from './tool.js';
-import { evalServerCommand } from './eval-server.js';
 import { createRequire } from 'node:module';
+import { createLazyAction } from './lazy-action.js';
 const _require = createRequire(import.meta.url);
 const pkg = _require('../../package.json');
 const program = new Command();
@@ -24,37 +14,37 @@ program
 program
     .command('setup')
     .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode')
-    .action(setupCommand);
+    .action(createLazyAction(() => import('./setup.js'), 'setupCommand'));
 program
     .command('analyze [path]')
     .description('Index a repository (full analysis)')
     .option('-f, --force', 'Force full re-index even if up to date')
     .option('--embeddings', 'Enable embedding generation for semantic search (off by default)')
-    .action(analyzeCommand);
+    .action(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
 program
     .command('serve')
     .description('Start local HTTP server for web UI connection')
     .option('-p, --port <port>', 'Port number', '4747')
     .option('--host <host>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 for remote access)')
-    .action(serveCommand);
+    .action(createLazyAction(() => import('./serve.js'), 'serveCommand'));
 program
     .command('mcp')
     .description('Start MCP server (stdio) — serves all indexed repos')
-    .action(mcpCommand);
+    .action(createLazyAction(() => import('./mcp.js'), 'mcpCommand'));
 program
     .command('list')
     .description('List all indexed repositories')
-    .action(listCommand);
+    .action(createLazyAction(() => import('./list.js'), 'listCommand'));
 program
     .command('status')
     .description('Show index status for current repo')
-    .action(statusCommand);
+    .action(createLazyAction(() => import('./status.js'), 'statusCommand'));
 program
     .command('clean')
     .description('Delete GitNexus index for current repo')
     .option('-f, --force', 'Skip confirmation prompt')
     .option('--all', 'Clean all indexed repos')
-    .action(cleanCommand);
+    .action(createLazyAction(() => import('./clean.js'), 'cleanCommand'));
 program
     .command('wiki [path]')
     .description('Generate repository wiki from knowledge graph')
@@ -64,11 +54,11 @@ program
     .option('--api-key <key>', 'LLM API key (saved to ~/.gitnexus/config.json)')
     .option('--concurrency <n>', 'Parallel LLM calls (default: 3)', '3')
     .option('--gist', 'Publish wiki as a public GitHub Gist after generation')
-    .action(wikiCommand);
+    .action(createLazyAction(() => import('./wiki.js'), 'wikiCommand'));
 program
     .command('augment <pattern>')
     .description('Augment a search pattern with knowledge graph context (used by hooks)')
-    .action(augmentCommand);
+    .action(createLazyAction(() => import('./augment.js'), 'augmentCommand'));
 // ─── Direct Tool Commands (no MCP overhead) ────────────────────────
 // These invoke LocalBackend directly for use in eval, scripts, and CI.
 program
@@ -79,7 +69,7 @@ program
     .option('-g, --goal <text>', 'What you want to find')
     .option('-l, --limit <n>', 'Max processes to return (default: 5)')
     .option('--content', 'Include full symbol source code')
-    .action(queryCommand);
+    .action(createLazyAction(() => import('./tool.js'), 'queryCommand'));
 program
     .command('context [name]')
     .description('360-degree view of a code symbol: callers, callees, processes')
@@ -87,7 +77,7 @@ program
     .option('-u, --uid <uid>', 'Direct symbol UID (zero-ambiguity lookup)')
     .option('-f, --file <path>', 'File path to disambiguate common names')
     .option('--content', 'Include full symbol source code')
-    .action(contextCommand);
+    .action(createLazyAction(() => import('./tool.js'), 'contextCommand'));
 program
     .command('impact <target>')
     .description('Blast radius analysis: what breaks if you change a symbol')
@@ -95,17 +85,17 @@ program
     .option('-r, --repo <name>', 'Target repository')
     .option('--depth <n>', 'Max relationship depth (default: 3)')
     .option('--include-tests', 'Include test files in results')
-    .action(impactCommand);
+    .action(createLazyAction(() => import('./tool.js'), 'impactCommand'));
 program
     .command('cypher <query>')
     .description('Execute raw Cypher query against the knowledge graph')
     .option('-r, --repo <name>', 'Target repository')
-    .action(cypherCommand);
+    .action(createLazyAction(() => import('./tool.js'), 'cypherCommand'));
 // ─── Eval Server (persistent daemon for SWE-bench) ─────────────────
 program
     .command('eval-server')
     .description('Start lightweight HTTP server for fast tool calls during evaluation')
     .option('-p, --port <port>', 'Port number', '4848')
     .option('--idle-timeout <seconds>', 'Auto-shutdown after N seconds idle (0 = disabled)', '0')
-    .action(evalServerCommand);
+    .action(createLazyAction(() => import('./eval-server.js'), 'evalServerCommand'));
 program.parse(process.argv);

package/dist/cli/lazy-action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a lazy-loaded CLI action that defers module import until invocation.
+ * The generic constraints ensure the export name is a valid key of the module
+ * at compile time — catching typos when used with concrete module imports.
+ */
+export declare function createLazyAction<TModule extends Record<string, unknown>, TKey extends string & keyof TModule>(loader: () => Promise<TModule>, exportName: TKey): (...args: unknown[]) => Promise<void>;

package/dist/cli/lazy-action.js

@@ -0,0 +1,18 @@
+/**
+ * Creates a lazy-loaded CLI action that defers module import until invocation.
+ * The generic constraints ensure the export name is a valid key of the module
+ * at compile time — catching typos when used with concrete module imports.
+ */
+function isCallable(value) {
+    return typeof value === 'function';
+}
+export function createLazyAction(loader, exportName) {
+    return async (...args) => {
+        const module = await loader();
+        const action = module[exportName];
+        if (!isCallable(action)) {
+            throw new Error(`Lazy action export not found: ${exportName}`);
+        }
+        await action(...args);
+    };
+}

package/dist/core/augmentation/engine.js

@@ -98,11 +98,11 @@ export async function augment(pattern, cwd) {
         for (const result of bm25Results.slice(0, 5)) {
             const escaped = result.filePath.replace(/'/g, "''");
             try {
-                const symbols = await executeQuery(repoId, `
-          MATCH (n) WHERE n.filePath = '${escaped}'
-          AND n.name CONTAINS '${pattern.replace(/'/g, "''").split(/\s+/)[0]}'
-          RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
-          LIMIT 3
+                const symbols = await executeQuery(repoId, `
+          MATCH (n) WHERE n.filePath = '${escaped}'
+          AND n.name CONTAINS '${pattern.replace(/'/g, "''").split(/\s+/)[0]}'
+          RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
+          LIMIT 3
         `);
                 for (const sym of symbols) {
                     symbolMatches.push({
@@ -130,10 +130,10 @@ export async function augment(pattern, cwd) {
             // Callers
             let callers = [];
             try {
-                const rows = await executeQuery(repoId, `
-          MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n {id: '${escaped}'})
-          RETURN caller.name AS name
-          LIMIT 3
+                const rows = await executeQuery(repoId, `
+          MATCH (caller)-[:CodeRelation {type: 'CALLS'}]->(n {id: '${escaped}'})
+          RETURN caller.name AS name
+          LIMIT 3
         `);
                 callers = rows.map((r) => r.name || r[0]).filter(Boolean);
             }
@@ -141,10 +141,10 @@ export async function augment(pattern, cwd) {
             // Callees
             let callees = [];
             try {
-                const rows = await executeQuery(repoId, `
-          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'CALLS'}]->(callee)
-          RETURN callee.name AS name
-          LIMIT 3
+                const rows = await executeQuery(repoId, `
+          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'CALLS'}]->(callee)
+          RETURN callee.name AS name
+          LIMIT 3
         `);
                 callees = rows.map((r) => r.name || r[0]).filter(Boolean);
             }
@@ -152,9 +152,9 @@ export async function augment(pattern, cwd) {
             // Processes
             let processes = [];
             try {
-                const rows = await executeQuery(repoId, `
-          MATCH (n {id: '${escaped}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
-          RETURN p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
+                const rows = await executeQuery(repoId, `
+          MATCH (n {id: '${escaped}'})-[r:CodeRelation {type: 'STEP_IN_PROCESS'}]->(p:Process)
+          RETURN p.heuristicLabel AS label, r.step AS step, p.stepCount AS stepCount
         `);
                 processes = rows.map((r) => {
                     const label = r.label || r[0];
@@ -167,10 +167,10 @@ export async function augment(pattern, cwd) {
             // Cluster cohesion (internal ranking signal)
             let cohesion = 0;
             try {
-                const rows = await executeQuery(repoId, `
-          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
-          RETURN c.cohesion AS cohesion
-          LIMIT 1
+                const rows = await executeQuery(repoId, `
+          MATCH (n {id: '${escaped}'})-[:CodeRelation {type: 'MEMBER_OF'}]->(c:Community)
+          RETURN c.cohesion AS cohesion
+          LIMIT 1
         `);
                 if (rows.length > 0) {
                     cohesion = (rows[0].cohesion ?? rows[0][0]) || 0;

package/dist/core/embeddings/embedding-pipeline.js

@@ -24,19 +24,19 @@ const queryEmbeddableNodes = async (executeQuery) => {
             let query;
             if (label === 'File') {
                 // File nodes don't have startLine/endLine
-                query = `
-          MATCH (n:File)
-          RETURN n.id AS id, n.name AS name, 'File' AS label, 
-                 n.filePath AS filePath, n.content AS content
+                query = `
+          MATCH (n:File)
+          RETURN n.id AS id, n.name AS name, 'File' AS label, 
+                 n.filePath AS filePath, n.content AS content
         `;
             }
             else {
                 // Code elements have startLine/endLine
-                query = `
-          MATCH (n:${label})
-          RETURN n.id AS id, n.name AS name, '${label}' AS label, 
-                 n.filePath AS filePath, n.content AS content,
-                 n.startLine AS startLine, n.endLine AS endLine
+                query = `
+          MATCH (n:${label})
+          RETURN n.id AS id, n.name AS name, '${label}' AS label, 
+                 n.filePath AS filePath, n.content AS content,
+                 n.startLine AS startLine, n.endLine AS endLine
         `;
             }
             const rows = await executeQuery(query);
@@ -77,8 +77,8 @@ const batchInsertEmbeddings = async (executeWithReusedStatement, updates) => {
  * Now indexes the separate CodeEmbedding table
  */
 const createVectorIndex = async (executeQuery) => {
-    const cypher = `
-    CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')
+    const cypher = `
+    CALL CREATE_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 'embedding', metric := 'cosine')
   `;
     try {
         await executeQuery(cypher);
@@ -240,14 +240,14 @@ export const semanticSearch = async (executeQuery, query, k = 10, maxDistance =
     const queryVec = embeddingToArray(queryEmbedding);
     const queryVecStr = `[${queryVec.join(',')}]`;
     // Query the vector index on CodeEmbedding to get nodeIds and distances
-    const vectorQuery = `
-    CALL QUERY_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 
-      CAST(${queryVecStr} AS FLOAT[384]), ${k})
-    YIELD node AS emb, distance
-    WITH emb, distance
-    WHERE distance < ${maxDistance}
-    RETURN emb.nodeId AS nodeId, distance
-    ORDER BY distance
+    const vectorQuery = `
+    CALL QUERY_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', 
+      CAST(${queryVecStr} AS FLOAT[384]), ${k})
+    YIELD node AS emb, distance
+    WITH emb, distance
+    WHERE distance < ${maxDistance}
+    RETURN emb.nodeId AS nodeId, distance
+    ORDER BY distance
   `;
     const embResults = await executeQuery(vectorQuery);
     if (embResults.length === 0) {
@@ -266,16 +266,16 @@ export const semanticSearch = async (executeQuery, query, k = 10, maxDistance =
         try {
             let nodeQuery;
             if (label === 'File') {
-                nodeQuery = `
-          MATCH (n:File {id: '${nodeId.replace(/'/g, "''")}'}) 
-          RETURN n.name AS name, n.filePath AS filePath
+                nodeQuery = `
+          MATCH (n:File {id: '${nodeId.replace(/'/g, "''")}'}) 
+          RETURN n.name AS name, n.filePath AS filePath
         `;
             }
             else {
-                nodeQuery = `
-          MATCH (n:${label} {id: '${nodeId.replace(/'/g, "''")}'}) 
-          RETURN n.name AS name, n.filePath AS filePath, 
-                 n.startLine AS startLine, n.endLine AS endLine
+                nodeQuery = `
+          MATCH (n:${label} {id: '${nodeId.replace(/'/g, "''")}'}) 
+          RETURN n.name AS name, n.filePath AS filePath, 
+                 n.startLine AS startLine, n.endLine AS endLine
         `;
             }
             const nodeRows = await executeQuery(nodeQuery);

package/dist/core/ingestion/ast-cache.js

@@ -1,9 +1,10 @@
 import { LRUCache } from 'lru-cache';
 export const createASTCache = (maxSize = 50) => {
+    const effectiveMax = Math.max(maxSize, 1);
     // Initialize the cache with a 'dispose' handler
     // This is the magic: When an item is evicted (dropped), this runs automatically.
     const cache = new LRUCache({
-        max: maxSize,
+        max: effectiveMax,
         dispose: (tree) => {
             try {
                 // NOTE: web-tree-sitter has tree.delete(); native tree-sitter trees are GC-managed.
@@ -28,7 +29,7 @@ export const createASTCache = (maxSize = 50) => {
         },
         stats: () => ({
             size: cache.size,
-            maxSize: maxSize
+            maxSize: effectiveMax
         })
     };
 };

package/dist/core/ingestion/cluster-enricher.js

@@ -13,12 +13,12 @@ const buildEnrichmentPrompt = (members, heuristicLabel) => {
     const memberList = limitedMembers
         .map(m => `${m.name} (${m.type})`)
         .join(', ');
-    return `Analyze this code cluster and provide a semantic name and short description.
-
-Heuristic: "${heuristicLabel}"
-Members: ${memberList}${members.length > 20 ? ` (+${members.length - 20} more)` : ''}
-
-Reply with JSON only:
+    return `Analyze this code cluster and provide a semantic name and short description.
+
+Heuristic: "${heuristicLabel}"
+Members: ${memberList}${members.length > 20 ? ` (+${members.length - 20} more)` : ''}
+
+Reply with JSON only:
 {"name": "2-4 word semantic name", "description": "One sentence describing purpose"}`;
 };
 // ============================================================================
@@ -115,18 +115,18 @@ export const enrichClustersBatch = async (communities, memberMap, llmClient, bat
             const memberList = limitedMembers
                 .map(m => `${m.name} (${m.type})`)
                 .join(', ');
-            return `Cluster ${idx + 1} (id: ${community.id}):
-Heuristic: "${community.heuristicLabel}"
+            return `Cluster ${idx + 1} (id: ${community.id}):
+Heuristic: "${community.heuristicLabel}"
 Members: ${memberList}`;
         }).join('\n\n');
-        const prompt = `Analyze these code clusters and generate semantic names, keywords, and descriptions.
-
-${batchPrompt}
-
-Output JSON array:
-[
-  {"id": "comm_X", "name": "...", "keywords": [...], "description": "..."},
-  ...
+        const prompt = `Analyze these code clusters and generate semantic names, keywords, and descriptions.
+
+${batchPrompt}
+
+Output JSON array:
+[
+  {"id": "comm_X", "name": "...", "keywords": [...], "description": "..."},
+  ...
 ]`;
         try {
             const response = await llmClient.generate(prompt);

package/dist/core/ingestion/pipeline.js

@@ -87,6 +87,14 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
             console.warn(`Skipping ${count} ${lang} file(s) — ${lang} parser not available (native binding may not have built). Try: npm rebuild tree-sitter-${lang}`);
         }
         const totalParseable = parseableScanned.length;
+        if (totalParseable === 0) {
+            onProgress({
+                phase: 'parsing',
+                percent: 82,
+                message: 'No parseable files found — skipping parsing phase',
+                stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: graph.nodeCount },
+            });
+        }
         // Build byte-budget chunks
         const chunks = [];
         let currentChunk = [];