gitnexus 1.4.1 → 1.4.6

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,40 @@ 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);
+    .option('--skills', 'Generate repo-specific skill files from detected communities')
+    .option('-v, --verbose', 'Enable verbose ingestion warnings (default: false)')
+    .addHelpText('after', '\nEnvironment variables:\n  GITNEXUS_NO_GITIGNORE=1  Skip .gitignore parsing (still reads .gitnexusignore)')
+    .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 +57,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 +72,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 +80,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 +88,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/cli/mcp.js

@@ -9,7 +9,7 @@ import { startMCPServer } from '../mcp/server.js';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 export const mcpCommand = async () => {
     // Prevent unhandled errors from crashing the MCP server process.
-    // KuzuDB lock conflicts and transient errors should degrade gracefully.
+    // LadybugDB lock conflicts and transient errors should degrade gracefully.
     process.on('uncaughtException', (err) => {
         console.error(`GitNexus MCP: uncaught exception — ${err.message}`);
         // Process is in an undefined state after uncaughtException — exit after flushing

package/dist/cli/setup.js

@@ -9,6 +9,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
+import { glob } from 'glob';
 import { getGlobalDir } from '../storage/repo-manager.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -147,36 +148,34 @@ 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, '/');
-            content = content.replace("let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');", `let cliPath = '${normalizedCli}';`);
+            const jsonCli = JSON.stringify(normalizedCli);
+            content = content.replace("let cliPath = path.resolve(__dirname, '..', '..', 'dist', 'cli', 'index.js');", `let cliPath = ${jsonCli};`);
             await fs.writeFile(dest, content, 'utf-8');
         }
         catch {
             // Script not found in source — skip
         }
-        const hookCmd = `node "${path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/')}"`;
+        const hookPath = path.join(destHooksDir, 'gitnexus-hook.cjs').replace(/\\/g, '/');
+        const hookCmd = `node "${hookPath.replace(/"/g, '\\"')}"`;
         // Merge hook config into ~/.claude/settings.json
         const existing = await readJsonFile(settingsPath) || {};
         if (!existing.hooks)
             existing.hooks = {};
-        // 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...',
-                    }],
-            });
+        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 }],
+                });
+            }
         }
+        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)');
+        result.configured.push('Claude Code hooks (PreToolUse, PostToolUse)');
     }
     catch (err) {
         result.errors.push(`Claude Code hooks: ${err.message}`);
@@ -203,7 +202,6 @@ async function setupOpenCode(result) {
     }
 }
 // ─── Skill Installation ───────────────────────────────────────────
-const SKILL_NAMES = ['gitnexus-exploring', 'gitnexus-debugging', 'gitnexus-impact-analysis', 'gitnexus-refactoring', 'gitnexus-guide', 'gitnexus-cli'];
 /**
  * Install GitNexus skills to a target directory.
  * Each skill is installed as {targetDir}/gitnexus-{skillName}/SKILL.md
@@ -216,24 +214,36 @@ const SKILL_NAMES = ['gitnexus-exploring', 'gitnexus-debugging', 'gitnexus-impac
 async function installSkillsTo(targetDir) {
     const installed = [];
     const skillsRoot = path.join(__dirname, '..', '..', 'skills');
-    for (const skillName of SKILL_NAMES) {
+    let flatFiles = [];
+    let dirSkillFiles = [];
+    try {
+        [flatFiles, dirSkillFiles] = await Promise.all([
+            glob('*.md', { cwd: skillsRoot }),
+            glob('*/SKILL.md', { cwd: skillsRoot }),
+        ]);
+    }
+    catch {
+        return [];
+    }
+    const skillSources = new Map();
+    for (const relPath of dirSkillFiles) {
+        skillSources.set(path.dirname(relPath), { isDirectory: true });
+    }
+    for (const relPath of flatFiles) {
+        const skillName = path.basename(relPath, '.md');
+        if (!skillSources.has(skillName)) {
+            skillSources.set(skillName, { isDirectory: false });
+        }
+    }
+    for (const [skillName, source] of skillSources) {
         const skillDir = path.join(targetDir, skillName);
         try {
-            // Try directory-based skill first (skills/{name}/SKILL.md)
-            const dirSource = path.join(skillsRoot, skillName);
-            const dirSkillFile = path.join(dirSource, 'SKILL.md');
-            let isDirectory = false;
-            try {
-                const stat = await fs.stat(dirSource);
-                isDirectory = stat.isDirectory();
-            }
-            catch { /* not a directory */ }
-            if (isDirectory) {
+            if (source.isDirectory) {
+                const dirSource = path.join(skillsRoot, skillName);
                 await copyDirRecursive(dirSource, skillDir);
                 installed.push(skillName);
             }
             else {
-                // Fall back to flat file (skills/{name}.md)
                 const flatSource = path.join(skillsRoot, `${skillName}.md`);
                 const content = await fs.readFile(flatSource, 'utf-8');
                 await fs.mkdir(skillDir, { recursive: true });

package/dist/cli/skill-gen.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Skill File Generator
+ *
+ * Generates repo-specific SKILL.md files from detected Leiden communities.
+ * Each significant community becomes a skill that describes a functional area
+ * of the codebase, including key files, entry points, execution flows, and
+ * cross-community connections.
+ */
+import { PipelineResult } from '../types/pipeline.js';
+export interface GeneratedSkillInfo {
+    name: string;
+    label: string;
+    symbolCount: number;
+    fileCount: number;
+}
+/**
+ * @brief Generate repo-specific skill files from detected communities
+ * @param {string} repoPath - Absolute path to the repository root
+ * @param {string} projectName - Human-readable project name
+ * @param {PipelineResult} pipelineResult - In-memory pipeline data with communities, processes, graph
+ * @returns {Promise<{ skills: GeneratedSkillInfo[], outputPath: string }>} Generated skill metadata
+ */
+export declare const generateSkillFiles: (repoPath: string, projectName: string, pipelineResult: PipelineResult) => Promise<{
+    skills: GeneratedSkillInfo[];
+    outputPath: string;
+}>;