gitnexus 1.3.11 → 1.4.1

package/dist/cli/index.js

@@ -2,8 +2,18 @@
 // 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();
@@ -14,37 +24,37 @@ program
 program
     .command('setup')
     .description('One-time setup: configure MCP for Cursor, Claude Code, OpenCode')
-    .action(createLazyAction(() => import('./setup.js'), 'setupCommand'));
+    .action(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(createLazyAction(() => import('./analyze.js'), 'analyzeCommand'));
+    .action(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(createLazyAction(() => import('./serve.js'), 'serveCommand'));
+    .action(serveCommand);
 program
     .command('mcp')
     .description('Start MCP server (stdio) — serves all indexed repos')
-    .action(createLazyAction(() => import('./mcp.js'), 'mcpCommand'));
+    .action(mcpCommand);
 program
     .command('list')
     .description('List all indexed repositories')
-    .action(createLazyAction(() => import('./list.js'), 'listCommand'));
+    .action(listCommand);
 program
     .command('status')
     .description('Show index status for current repo')
-    .action(createLazyAction(() => import('./status.js'), 'statusCommand'));
+    .action(statusCommand);
 program
     .command('clean')
     .description('Delete GitNexus index for current repo')
     .option('-f, --force', 'Skip confirmation prompt')
     .option('--all', 'Clean all indexed repos')
-    .action(createLazyAction(() => import('./clean.js'), 'cleanCommand'));
+    .action(cleanCommand);
 program
     .command('wiki [path]')
     .description('Generate repository wiki from knowledge graph')
@@ -54,11 +64,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(createLazyAction(() => import('./wiki.js'), 'wikiCommand'));
+    .action(wikiCommand);
 program
     .command('augment <pattern>')
     .description('Augment a search pattern with knowledge graph context (used by hooks)')
-    .action(createLazyAction(() => import('./augment.js'), 'augmentCommand'));
+    .action(augmentCommand);
 // ─── Direct Tool Commands (no MCP overhead) ────────────────────────
 // These invoke LocalBackend directly for use in eval, scripts, and CI.
 program
@@ -69,7 +79,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(createLazyAction(() => import('./tool.js'), 'queryCommand'));
+    .action(queryCommand);
 program
     .command('context [name]')
     .description('360-degree view of a code symbol: callers, callees, processes')
@@ -77,7 +87,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(createLazyAction(() => import('./tool.js'), 'contextCommand'));
+    .action(contextCommand);
 program
     .command('impact <target>')
     .description('Blast radius analysis: what breaks if you change a symbol')
@@ -85,17 +95,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(createLazyAction(() => import('./tool.js'), 'impactCommand'));
+    .action(impactCommand);
 program
     .command('cypher <query>')
     .description('Execute raw Cypher query against the knowledge graph')
     .option('-r, --repo <name>', 'Target repository')
-    .action(createLazyAction(() => import('./tool.js'), 'cypherCommand'));
+    .action(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(createLazyAction(() => import('./eval-server.js'), 'evalServerCommand'));
+    .action(evalServerCommand);
 program.parse(process.argv);

package/dist/cli/setup.js

@@ -147,34 +147,36 @@ async function installClaudeCodeHooks(result) {
             // even when it's no longer inside the npm package tree
             const resolvedCli = path.join(__dirname, '..', 'cli', 'index.js');
             const normalizedCli = path.resolve(resolvedCli).replace(/\\/g, '/');
-            const jsonCli = JSON.stringify(normalizedCli);
-            content = content.replace("let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');", `let cliPath = ${jsonCli};`);
+            content = content.replace("let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');", `let cliPath = '${normalizedCli}';`);
             await fs.writeFile(dest, content, 'utf-8');
         }
         catch {
             // Script not found in source — skip
         }
-        const hookPath = path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/');
-        const hookCmd = `node "${hookPath.replace(/"/g, '\\"')}"`;
+        const hookCmd = `node "${path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/')}"`;
         // Merge hook config into ~/.claude/settings.json
         const existing = await readJsonFile(settingsPath) || {};
         if (!existing.hooks)
             existing.hooks = {};
-        function ensureHookEntry(eventName, matcher, timeout, statusMessage) {
-            if (!existing.hooks[eventName])
-                existing.hooks[eventName] = [];
-            const hasHook = existing.hooks[eventName].some((h) => h.hooks?.some(hh => hh.command?.includes('gitnexus-hook')));
-            if (!hasHook) {
-                existing.hooks[eventName].push({
-                    matcher,
-                    hooks: [{ type: 'command', command: hookCmd, timeout, statusMessage }],
-                });
-            }
+        // NOTE: SessionStart hooks are broken on Windows (Claude Code bug #23576).
+        // Session context is delivered via CLAUDE.md / skills instead.
+        // Add PreToolUse hook if not already present
+        if (!existing.hooks.PreToolUse)
+            existing.hooks.PreToolUse = [];
+        const hasPreToolHook = existing.hooks.PreToolUse.some((h) => h.hooks?.some((hh) => hh.command?.includes('gitnexus')));
+        if (!hasPreToolHook) {
+            existing.hooks.PreToolUse.push({
+                matcher: 'Grep|Glob|Bash',
+                hooks: [{
+                        type: 'command',
+                        command: hookCmd,
+                        timeout: 8000,
+                        statusMessage: 'Enriching with GitNexus graph context...',
+                    }],
+            });
         }
-        ensureHookEntry('PreToolUse', 'Grep|Glob|Bash', 10, 'Enriching with GitNexus graph context...');
-        ensureHookEntry('PostToolUse', 'Bash', 10, 'Checking GitNexus index freshness...');
         await writeJsonFile(settingsPath, existing);
-        result.configured.push('Claude Code hooks (PreToolUse, PostToolUse)');
+        result.configured.push('Claude Code hooks (PreToolUse)');
     }
     catch (err) {
         result.errors.push(`Claude Code hooks: ${err.message}`);

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,10 +1,9 @@
 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: effectiveMax,
+        max: maxSize,
         dispose: (tree) => {
             try {
                 // NOTE: web-tree-sitter has tree.delete(); native tree-sitter trees are GC-managed.
@@ -29,7 +28,7 @@ export const createASTCache = (maxSize = 50) => {
         },
         stats: () => ({
             size: cache.size,
-            maxSize: effectiveMax
+            maxSize: maxSize
         })
     };
 };

package/dist/core/ingestion/call-processor.js

@@ -54,7 +54,8 @@ const findEnclosingFunction = (node, filePath, symbolTable) => {
             // Swift init/deinit — handle before generic cases (more specific)
             if (current.type === 'init_declaration' || current.type === 'deinit_declaration') {
                 const funcName = current.type === 'init_declaration' ? 'init' : 'deinit';
-                return generateId('Constructor', `${filePath}:${funcName}`);
+                const startLine = current.startPosition?.row ?? 0;
+                return generateId('Constructor', `${filePath}:${funcName}:${startLine}`);
             }
             if (current.type === 'function_declaration' ||
                 current.type === 'function_definition' ||
@@ -114,12 +115,9 @@ const findEnclosingFunction = (node, filePath, symbolTable) => {
                 if (nodeId)
                     return nodeId;
                 // Try construct ID manually if lookup fails (common for non-exported internal functions)
-                // Format should match what parsing-processor generates: "Function:path/to/file:funcName"
-                // Check if we already have a node with this ID in the symbol table to be safe
-                const generatedId = generateId(label, `${filePath}:${funcName}`);
-                // Ideally we should verify this ID exists, but strictly speaking if we are inside it,
-                // it SHOULD exist. Returning it is better than falling back to File.
-                return generatedId;
+                // Format must match parsing-processor: "Label:path/to/file:funcName:startLine"
+                const startLine = current.startPosition?.row ?? 0;
+                return generateId(label, `${filePath}:${funcName}:${startLine}`);
             }
             // Couldn't determine function name - try parent (might be nested)
         }

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

@@ -12,9 +12,6 @@ import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
 import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { createWorkerPool } from './workers/worker-pool.js';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
 const isDev = process.env.NODE_ENV === 'development';
 /** Max bytes of source content to load per parse chunk. Each chunk's source +
  *  parsed ASTs + extracted records + worker serialization overhead all live in
@@ -90,14 +87,6 @@ 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 = [];
@@ -127,21 +116,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         // Create worker pool once, reuse across chunks
         let workerPool;
         try {
-            let workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
-            // When running under vitest, import.meta.url points to src/ where no .js exists.
-            // Fall back to the compiled dist/ worker so the pool can spawn real worker threads.
-            const thisDir = fileURLToPath(new URL('.', import.meta.url));
-            if (!fs.existsSync(fileURLToPath(workerUrl))) {
-                const distWorker = path.resolve(thisDir, '..', '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js');
-                if (fs.existsSync(distWorker)) {
-                    workerUrl = pathToFileURL(distWorker);
-                }
-            }
+            const workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
             workerPool = createWorkerPool(workerUrl);
         }
         catch (err) {
-            if (isDev)
-                console.warn('Worker pool creation failed, using sequential fallback:', err.message);
+            // Worker pool creation failed — sequential fallback
         }
         let filesParsedSoFar = 0;
         // AST cache sized for one chunk (sequential fallback uses it for import/call/heritage)