gitnexus 1.4.9 → 1.5.0

package/README.md

@@ -149,11 +149,12 @@ Your AI agent gets these tools automatically:
 ## CLI Commands
 
 ```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 --embeddings     # Enable embedding generation (slower, better search)
-gitnexus analyze --verbose        # Log skipped files when parsers are unavailable
+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 --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
 gitnexus mcp                     # Start MCP server (stdio) — serves all indexed repos
 gitnexus serve                   # Start local HTTP server (multi-repo) for web UI
 gitnexus index                   # Register an existing .gitnexus/ folder into the global registry

package/dist/cli/ai-context.d.ts

@@ -14,10 +14,13 @@ interface RepoStats {
     clusters?: number;
     processes?: number;
 }
+export interface AIContextOptions {
+    skipAgentsMd?: boolean;
+}
 /**
  * Generate AI context files after indexing
  */
-export declare function generateAIContextFiles(repoPath: string, _storagePath: string, projectName: string, stats: RepoStats, generatedSkills?: GeneratedSkillInfo[]): Promise<{
+export declare function generateAIContextFiles(repoPath: string, _storagePath: string, projectName: string, stats: RepoStats, generatedSkills?: GeneratedSkillInfo[], options?: AIContextOptions): Promise<{
     files: string[];
 }>;
 export {};

package/dist/cli/ai-context.js

@@ -25,8 +25,10 @@ const GITNEXUS_END_MARKER = '<!-- gitnexus:end -->';
  * - Self-review checklist — forces model to verify its own work
  */
 function generateGitNexusContent(projectName, stats, generatedSkills) {
-    const generatedRows = (generatedSkills && generatedSkills.length > 0)
-        ? generatedSkills.map(s => `| Work in the ${s.label} area (${s.symbolCount} symbols) | \`.claude/skills/generated/${s.name}/SKILL.md\` |`).join('\n')
+    const generatedRows = generatedSkills && generatedSkills.length > 0
+        ? generatedSkills
+            .map((s) => `| Work in the ${s.label} area (${s.symbolCount} symbols) | \`.claude/skills/generated/${s.name}/SKILL.md\` |`)
+            .join('\n')
         : '';
     const skillsTable = `| Task | Read this skill file |
 |------|---------------------|
@@ -245,17 +247,23 @@ Use GitNexus tools to accomplish this task.
 /**
  * Generate AI context files after indexing
  */
-export async function generateAIContextFiles(repoPath, _storagePath, projectName, stats, generatedSkills) {
+export async function generateAIContextFiles(repoPath, _storagePath, projectName, stats, generatedSkills, options) {
     const content = generateGitNexusContent(projectName, stats, generatedSkills);
     const createdFiles = [];
-    // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Cline, etc.)
-    const agentsPath = path.join(repoPath, 'AGENTS.md');
-    const agentsResult = await upsertGitNexusSection(agentsPath, content);
-    createdFiles.push(`AGENTS.md (${agentsResult})`);
-    // Create CLAUDE.md (for Claude Code)
-    const claudePath = path.join(repoPath, 'CLAUDE.md');
-    const claudeResult = await upsertGitNexusSection(claudePath, content);
-    createdFiles.push(`CLAUDE.md (${claudeResult})`);
+    if (!options?.skipAgentsMd) {
+        // Create AGENTS.md (standard for Cursor, Windsurf, OpenCode, Cline, etc.)
+        const agentsPath = path.join(repoPath, 'AGENTS.md');
+        const agentsResult = await upsertGitNexusSection(agentsPath, content);
+        createdFiles.push(`AGENTS.md (${agentsResult})`);
+        // Create CLAUDE.md (for Claude Code)
+        const claudePath = path.join(repoPath, 'CLAUDE.md');
+        const claudeResult = await upsertGitNexusSection(claudePath, content);
+        createdFiles.push(`CLAUDE.md (${claudeResult})`);
+    }
+    else {
+        createdFiles.push('AGENTS.md (skipped via --skip-agents-md)');
+        createdFiles.push('CLAUDE.md (skipped via --skip-agents-md)');
+    }
     // Install skills to .claude/skills/gitnexus/
     const installedSkills = await installSkills(repoPath);
     if (installedSkills.length > 0) {

package/dist/cli/analyze.d.ts

@@ -2,12 +2,18 @@
  * Analyze Command
  *
  * Indexes a repository and stores the knowledge graph in .gitnexus/
+ *
+ * Delegates core analysis to the shared runFullAnalysis orchestrator.
+ * This CLI wrapper handles: heap management, progress bar, SIGINT,
+ * skill generation (--skills), summary output, and process.exit().
  */
 export interface AnalyzeOptions {
     force?: boolean;
     embeddings?: boolean;
     skills?: boolean;
     verbose?: boolean;
+    /** Skip AGENTS.md and CLAUDE.md gitnexus block updates. */
+    skipAgentsMd?: boolean;
     /** Index the folder even when no .git directory is present. */
     skipGit?: boolean;
 }

package/dist/cli/analyze.js

@@ -2,21 +2,19 @@
  * Analyze Command
  *
  * Indexes a repository and stores the knowledge graph in .gitnexus/
+ *
+ * Delegates core analysis to the shared runFullAnalysis orchestrator.
+ * This CLI wrapper handles: heap management, progress bar, SIGINT,
+ * skill generation (--skills), summary output, and process.exit().
  */
 import path from 'path';
 import { execFileSync } from 'child_process';
 import v8 from 'v8';
 import cliProgress from 'cli-progress';
-import { runPipelineFromRepo } from '../core/ingestion/pipeline.js';
-import { initLbug, loadGraphToLbug, getLbugStats, executeQuery, executeWithReusedStatement, closeLbug, createFTSIndex, loadCachedEmbeddings } from '../core/lbug/lbug-adapter.js';
-// Embedding imports are lazy (dynamic import) so onnxruntime-node is never
-// loaded when embeddings are not requested. This avoids crashes on Node
-// versions whose ABI is not yet supported by the native binary (#89).
-// disposeEmbedder intentionally not called — ONNX Runtime segfaults on cleanup (see #38)
-import { getStoragePaths, saveMeta, loadMeta, addToGitignore, registerRepo, getGlobalRegistryPath, cleanupOldKuzuFiles } from '../storage/repo-manager.js';
-import { getCurrentCommit, getGitRoot, hasGitDir } from '../storage/git.js';
-import { generateAIContextFiles } from './ai-context.js';
-import { generateSkillFiles } from './skill-gen.js';
+import { closeLbug } from '../core/lbug/lbug-adapter.js';
+import { getStoragePaths, getGlobalRegistryPath } from '../storage/repo-manager.js';
+import { getGitRoot, hasGitDir } from '../storage/git.js';
+import { runFullAnalysis } from '../core/run-analyze.js';
 import fs from 'fs/promises';
 const HEAP_MB = 8192;
 const HEAP_FLAG = `--max-old-space-size=${HEAP_MB}`;
@@ -39,23 +37,6 @@ function ensureHeap() {
     }
     return true;
 }
-/** Threshold: auto-skip embeddings for repos with more nodes than this */
-const EMBEDDING_NODE_LIMIT = 50_000;
-const PHASE_LABELS = {
-    extracting: 'Scanning files',
-    structure: 'Building structure',
-    parsing: 'Parsing code',
-    imports: 'Resolving imports',
-    calls: 'Tracing calls',
-    heritage: 'Extracting inheritance',
-    communities: 'Detecting communities',
-    processes: 'Detecting processes',
-    complete: 'Pipeline complete',
-    lbug: 'Loading into LadybugDB',
-    fts: 'Creating search indexes',
-    embeddings: 'Generating embeddings',
-    done: 'Done',
-};
 export const analyzeCommand = async (inputPath, options) => {
     if (ensureHeap())
         return;
@@ -91,26 +72,12 @@ export const analyzeCommand = async (inputPath, options) => {
     if (!repoHasGit) {
         console.log('  Warning: no .git directory found \u2014 commit-tracking and incremental updates disabled.\n');
     }
-    const { storagePath, lbugPath } = getStoragePaths(repoPath);
-    // Clean up stale KuzuDB files from before the LadybugDB migration.
-    // If kuzu existed but lbug doesn't, we're doing a migration re-index — say so.
-    const kuzuResult = await cleanupOldKuzuFiles(storagePath);
-    if (kuzuResult.found && kuzuResult.needsReindex) {
-        console.log('  Migrating from KuzuDB to LadybugDB — rebuilding index...\n');
-    }
-    const currentCommit = repoHasGit ? getCurrentCommit(repoPath) : '';
-    const existingMeta = await loadMeta(storagePath);
-    if (existingMeta && !options?.force && !options?.skills && existingMeta.lastCommit === currentCommit) {
-        // Non-git folders have currentCommit = '' — always rebuild since we can't detect changes
-        if (currentCommit !== '') {
-            console.log('  Already up to date\n');
-            return;
-        }
-    }
+    // KuzuDB migration cleanup is handled by runFullAnalysis internally.
+    // Note: --skills is handled after runFullAnalysis using the returned pipelineResult.
     if (process.env.GITNEXUS_NO_GITIGNORE) {
         console.log('  GITNEXUS_NO_GITIGNORE is set — skipping .gitignore (still reading .gitnexusignore)\n');
     }
-    // Single progress bar for entire pipeline
+    // ── CLI progress bar setup ─────────────────────────────────────────
     const bar = new cliProgress.SingleBar({
         format: '  {bar} {percentage}% | {phase}',
         barCompleteChar: '\u2588',
@@ -122,35 +89,33 @@ export const analyzeCommand = async (inputPath, options) => {
         stopOnComplete: false,
     }, cliProgress.Presets.shades_grey);
     bar.start(100, 0, { phase: 'Initializing...' });
-    // Graceful SIGINT handling — clean up resources and exit
+    // Graceful SIGINT handling
     let aborted = false;
     const sigintHandler = () => {
         if (aborted)
-            process.exit(1); // Second Ctrl-C: force exit
+            process.exit(1);
         aborted = true;
         bar.stop();
         console.log('\n  Interrupted — cleaning up...');
-        closeLbug().catch(() => { }).finally(() => process.exit(130));
+        closeLbug()
+            .catch(() => { })
+            .finally(() => process.exit(130));
     };
     process.on('SIGINT', sigintHandler);
-    // Route all console output through bar.log() so the bar doesn't stamp itself
-    // multiple times when other code writes to stdout/stderr mid-render.
+    // Route console output through bar.log() to prevent progress bar corruption
     const origLog = console.log.bind(console);
     const origWarn = console.warn.bind(console);
     const origError = console.error.bind(console);
     const barLog = (...args) => {
-        // Clear the bar line, print the message, then let the next bar.update redraw
         process.stdout.write('\x1b[2K\r');
-        origLog(args.map(a => (typeof a === 'string' ? a : String(a))).join(' '));
+        origLog(args.map((a) => (typeof a === 'string' ? a : String(a))).join(' '));
     };
     console.log = barLog;
     console.warn = barLog;
     console.error = barLog;
-    // Track elapsed time per phase — both updateBar and the interval use the
-    // same format so they don't flicker against each other.
+    // Track elapsed time per phase
     let lastPhaseLabel = 'Initializing...';
     let phaseStart = Date.now();
-    /** Update bar with phase label + elapsed seconds (shown after 3s). */
     const updateBar = (value, phaseLabel) => {
         if (phaseLabel !== lastPhaseLabel) {
             lastPhaseLabel = phaseLabel;
@@ -160,217 +125,106 @@ export const analyzeCommand = async (inputPath, options) => {
         const display = elapsed >= 3 ? `${phaseLabel} (${elapsed}s)` : phaseLabel;
         bar.update(value, { phase: display });
     };
-    // Tick elapsed seconds for phases with infrequent progress callbacks
-    // (e.g. CSV streaming, FTS indexing). Uses the same display format as
-    // updateBar so there's no flickering.
     const elapsedTimer = setInterval(() => {
         const elapsed = Math.round((Date.now() - phaseStart) / 1000);
         if (elapsed >= 3) {
             bar.update({ phase: `${lastPhaseLabel} (${elapsed}s)` });
         }
     }, 1000);
-    const t0Global = Date.now();
-    // ── Cache embeddings from existing index before rebuild ────────────
-    let cachedEmbeddingNodeIds = new Set();
-    let cachedEmbeddings = [];
-    if (options?.embeddings && existingMeta && !options?.force) {
-        try {
-            updateBar(0, 'Caching embeddings...');
-            await initLbug(lbugPath);
-            const cached = await loadCachedEmbeddings();
-            cachedEmbeddingNodeIds = cached.embeddingNodeIds;
-            cachedEmbeddings = cached.embeddings;
-            await closeLbug();
-        }
-        catch {
-            try {
-                await closeLbug();
-            }
-            catch { }
-        }
-    }
-    // ── Phase 1: Full Pipeline (0–60%) ─────────────────────────────────
-    const pipelineResult = await runPipelineFromRepo(repoPath, (progress) => {
-        const phaseLabel = PHASE_LABELS[progress.phase] || progress.phase;
-        const scaled = Math.round(progress.percent * 0.6);
-        updateBar(scaled, phaseLabel);
-    });
-    // ── Phase 2: LadybugDB (60–85%) ──────────────────────────────────────
-    updateBar(60, 'Loading into LadybugDB...');
-    await closeLbug();
-    const lbugFiles = [lbugPath, `${lbugPath}.wal`, `${lbugPath}.lock`];
-    for (const f of lbugFiles) {
-        try {
-            await fs.rm(f, { recursive: true, force: true });
-        }
-        catch { }
-    }
-    const t0Lbug = Date.now();
-    await initLbug(lbugPath);
-    let lbugMsgCount = 0;
-    const lbugResult = await loadGraphToLbug(pipelineResult.graph, pipelineResult.repoPath, storagePath, (msg) => {
-        lbugMsgCount++;
-        const progress = Math.min(84, 60 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 24));
-        updateBar(progress, msg);
-    });
-    const lbugTime = ((Date.now() - t0Lbug) / 1000).toFixed(1);
-    const lbugWarnings = lbugResult.warnings;
-    // ── Phase 3: FTS (85–90%) ─────────────────────────────────────────
-    updateBar(85, 'Creating search indexes...');
-    const t0Fts = Date.now();
+    const t0 = Date.now();
+    // ── Run shared analysis orchestrator ───────────────────────────────
     try {
-        await createFTSIndex('File', 'file_fts', ['name', 'content']);
-        await createFTSIndex('Function', 'function_fts', ['name', 'content']);
-        await createFTSIndex('Class', 'class_fts', ['name', 'content']);
-        await createFTSIndex('Method', 'method_fts', ['name', 'content']);
-        await createFTSIndex('Interface', 'interface_fts', ['name', 'content']);
-    }
-    catch (e) {
-        // Non-fatal — FTS is best-effort
-    }
-    const ftsTime = ((Date.now() - t0Fts) / 1000).toFixed(1);
-    // ── Phase 3.5: Re-insert cached embeddings ────────────────────────
-    if (cachedEmbeddings.length > 0) {
-        // Check if cached embedding dimensions match current schema
-        const cachedDims = cachedEmbeddings[0].embedding.length;
-        const { EMBEDDING_DIMS } = await import('../core/lbug/schema.js');
-        if (cachedDims !== EMBEDDING_DIMS) {
-            // Dimensions changed (e.g. switched embedding model) — discard cache and re-embed all
-            console.error(`⚠️  Embedding dimensions changed (${cachedDims}d → ${EMBEDDING_DIMS}d), discarding cache`);
-            cachedEmbeddings = [];
-            cachedEmbeddingNodeIds = new Set();
+        const result = await runFullAnalysis(repoPath, {
+            force: options?.force || options?.skills,
+            embeddings: options?.embeddings,
+            skipGit: options?.skipGit,
+            skipAgentsMd: options?.skipAgentsMd,
+        }, {
+            onProgress: (_phase, percent, message) => {
+                updateBar(percent, message);
+            },
+            onLog: barLog,
+        });
+        if (result.alreadyUpToDate) {
+            clearInterval(elapsedTimer);
+            process.removeListener('SIGINT', sigintHandler);
+            console.log = origLog;
+            console.warn = origWarn;
+            console.error = origError;
+            bar.stop();
+            console.log('  Already up to date\n');
+            // Safe to return without process.exit(0) — the early-return path in
+            // runFullAnalysis never opens LadybugDB, so no native handles prevent exit.
+            return;
         }
-        else {
-            updateBar(88, `Restoring ${cachedEmbeddings.length} cached embeddings...`);
-            const EMBED_BATCH = 200;
-            for (let i = 0; i < cachedEmbeddings.length; i += EMBED_BATCH) {
-                const batch = cachedEmbeddings.slice(i, i + EMBED_BATCH);
-                const paramsList = batch.map(e => ({ nodeId: e.nodeId, embedding: e.embedding }));
-                try {
-                    await executeWithReusedStatement(`CREATE (e:CodeEmbedding {nodeId: $nodeId, embedding: $embedding})`, paramsList);
+        // Skill generation (CLI-only, uses pipeline result from analysis)
+        if (options?.skills && result.pipelineResult) {
+            updateBar(99, 'Generating skill files...');
+            try {
+                const { generateSkillFiles } = await import('./skill-gen.js');
+                const { generateAIContextFiles } = await import('./ai-context.js');
+                const skillResult = await generateSkillFiles(repoPath, result.repoName, result.pipelineResult);
+                if (skillResult.skills.length > 0) {
+                    barLog(`  Generated ${skillResult.skills.length} skill files`);
+                    // Re-generate AI context files now that we have skill info
+                    const s = result.stats;
+                    const communityResult = result.pipelineResult?.communityResult;
+                    let aggregatedClusterCount = 0;
+                    if (communityResult?.communities) {
+                        const groups = new Map();
+                        for (const c of communityResult.communities) {
+                            const label = c.heuristicLabel || c.label || 'Unknown';
+                            groups.set(label, (groups.get(label) || 0) + c.symbolCount);
+                        }
+                        aggregatedClusterCount = Array.from(groups.values()).filter((count) => count >= 5).length;
+                    }
+                    const { storagePath: sp } = getStoragePaths(repoPath);
+                    await generateAIContextFiles(repoPath, sp, result.repoName, {
+                        files: s.files ?? 0,
+                        nodes: s.nodes ?? 0,
+                        edges: s.edges ?? 0,
+                        communities: s.communities,
+                        clusters: aggregatedClusterCount,
+                        processes: s.processes,
+                    }, skillResult.skills, { skipAgentsMd: options?.skipAgentsMd });
                 }
-                catch { /* some may fail if node was removed, that's fine */ }
+            }
+            catch {
+                /* best-effort */
             }
         }
-    }
-    // ── Phase 4: Embeddings (90–98%) ──────────────────────────────────
-    const stats = await getLbugStats();
-    let embeddingTime = '0.0';
-    let embeddingSkipped = true;
-    let embeddingSkipReason = 'off (use --embeddings to enable)';
-    if (options?.embeddings) {
-        if (stats.nodes > EMBEDDING_NODE_LIMIT) {
-            embeddingSkipReason = `skipped (${stats.nodes.toLocaleString()} nodes > ${EMBEDDING_NODE_LIMIT.toLocaleString()} limit)`;
-        }
-        else {
-            embeddingSkipped = false;
+        const totalTime = ((Date.now() - t0) / 1000).toFixed(1);
+        clearInterval(elapsedTimer);
+        process.removeListener('SIGINT', sigintHandler);
+        console.log = origLog;
+        console.warn = origWarn;
+        console.error = origError;
+        bar.update(100, { phase: 'Done' });
+        bar.stop();
+        // ── Summary ────────────────────────────────────────────────────
+        const s = result.stats;
+        console.log(`\n  Repository indexed successfully (${totalTime}s)\n`);
+        console.log(`  ${(s.nodes ?? 0).toLocaleString()} nodes | ${(s.edges ?? 0).toLocaleString()} edges | ${s.communities ?? 0} clusters | ${s.processes ?? 0} flows`);
+        console.log(`  ${repoPath}`);
+        try {
+            await fs.access(getGlobalRegistryPath());
         }
-    }
-    if (!embeddingSkipped) {
-        const { isHttpMode } = await import('../core/embeddings/http-client.js');
-        const httpMode = isHttpMode();
-        updateBar(90, httpMode ? 'Connecting to embedding endpoint...' : 'Loading embedding model...');
-        const t0Emb = Date.now();
-        const { runEmbeddingPipeline } = await import('../core/embeddings/embedding-pipeline.js');
-        await runEmbeddingPipeline(executeQuery, executeWithReusedStatement, (progress) => {
-            const scaled = 90 + Math.round((progress.percent / 100) * 8);
-            const label = progress.phase === 'loading-model'
-                ? (httpMode ? 'Connecting to embedding endpoint...' : 'Loading embedding model...')
-                : `Embedding ${progress.nodesProcessed || 0}/${progress.totalNodes || '?'}`;
-            updateBar(scaled, label);
-        }, {}, cachedEmbeddingNodeIds.size > 0 ? cachedEmbeddingNodeIds : undefined);
-        embeddingTime = ((Date.now() - t0Emb) / 1000).toFixed(1);
-    }
-    // ── Phase 5: Finalize (98–100%) ───────────────────────────────────
-    updateBar(98, 'Saving metadata...');
-    // Count embeddings in the index (cached + newly generated)
-    let embeddingCount = 0;
-    try {
-        const embResult = await executeQuery(`MATCH (e:CodeEmbedding) RETURN count(e) AS cnt`);
-        embeddingCount = embResult?.[0]?.cnt ?? 0;
-    }
-    catch { /* table may not exist if embeddings never ran */ }
-    const meta = {
-        repoPath,
-        lastCommit: currentCommit,
-        indexedAt: new Date().toISOString(),
-        stats: {
-            files: pipelineResult.totalFileCount,
-            nodes: stats.nodes,
-            edges: stats.edges,
-            communities: pipelineResult.communityResult?.stats.totalCommunities,
-            processes: pipelineResult.processResult?.stats.totalProcesses,
-            embeddings: embeddingCount,
-        },
-    };
-    await saveMeta(storagePath, meta);
-    await registerRepo(repoPath, meta);
-    // Only attempt to update .gitignore when a .git directory is present.
-    // Use hasGitDir (filesystem check) rather than git CLI subprocess
-    // so we skip correctly for --skip-git folders even if git CLI is available.
-    if (hasGitDir(repoPath)) {
-        await addToGitignore(repoPath);
-    }
-    const projectName = path.basename(repoPath);
-    let aggregatedClusterCount = 0;
-    if (pipelineResult.communityResult?.communities) {
-        const groups = new Map();
-        for (const c of pipelineResult.communityResult.communities) {
-            const label = c.heuristicLabel || c.label || 'Unknown';
-            groups.set(label, (groups.get(label) || 0) + c.symbolCount);
+        catch {
+            console.log('\n  Tip: Run `gitnexus setup` to configure MCP for your editor.');
         }
-        aggregatedClusterCount = Array.from(groups.values()).filter(count => count >= 5).length;
-    }
-    let generatedSkills = [];
-    if (options?.skills && pipelineResult.communityResult) {
-        updateBar(99, 'Generating skill files...');
-        const skillResult = await generateSkillFiles(repoPath, projectName, pipelineResult);
-        generatedSkills = skillResult.skills;
-    }
-    const aiContext = await generateAIContextFiles(repoPath, storagePath, projectName, {
-        files: pipelineResult.totalFileCount,
-        nodes: stats.nodes,
-        edges: stats.edges,
-        communities: pipelineResult.communityResult?.stats.totalCommunities,
-        clusters: aggregatedClusterCount,
-        processes: pipelineResult.processResult?.stats.totalProcesses,
-    }, generatedSkills);
-    await closeLbug();
-    // Note: we intentionally do NOT call disposeEmbedder() here.
-    // ONNX Runtime's native cleanup segfaults on macOS and some Linux configs.
-    // Since the process exits immediately after, Node.js reclaims everything.
-    const totalTime = ((Date.now() - t0Global) / 1000).toFixed(1);
-    clearInterval(elapsedTimer);
-    process.removeListener('SIGINT', sigintHandler);
-    console.log = origLog;
-    console.warn = origWarn;
-    console.error = origError;
-    bar.update(100, { phase: 'Done' });
-    bar.stop();
-    // ── Summary ───────────────────────────────────────────────────────
-    const embeddingsCached = cachedEmbeddings.length > 0;
-    console.log(`\n  Repository indexed successfully (${totalTime}s)${embeddingsCached ? ` [${cachedEmbeddings.length} embeddings cached]` : ''}\n`);
-    console.log(`  ${stats.nodes.toLocaleString()} nodes | ${stats.edges.toLocaleString()} edges | ${pipelineResult.communityResult?.stats.totalCommunities || 0} clusters | ${pipelineResult.processResult?.stats.totalProcesses || 0} flows`);
-    console.log(`  LadybugDB ${lbugTime}s | FTS ${ftsTime}s | Embeddings ${embeddingSkipped ? embeddingSkipReason : embeddingTime + 's'}`);
-    console.log(`  ${repoPath}`);
-    if (aiContext.files.length > 0) {
-        console.log(`  Context: ${aiContext.files.join(', ')}`);
-    }
-    // Show a quiet summary if some edge types needed fallback insertion
-    if (lbugWarnings.length > 0) {
-        const totalFallback = lbugWarnings.reduce((sum, w) => {
-            const m = w.match(/\((\d+) edges\)/);
-            return sum + (m ? parseInt(m[1]) : 0);
-        }, 0);
-        console.log(`  Note: ${totalFallback} edges across ${lbugWarnings.length} types inserted via fallback (schema will be updated in next release)`);
-    }
-    try {
-        await fs.access(getGlobalRegistryPath());
-    }
-    catch {
-        console.log('\n  Tip: Run `gitnexus setup` to configure MCP for your editor.');
+        console.log('');
+    }
+    catch (err) {
+        clearInterval(elapsedTimer);
+        process.removeListener('SIGINT', sigintHandler);
+        console.log = origLog;
+        console.warn = origWarn;
+        console.error = origError;
+        bar.stop();
+        console.error(`\n  Analysis failed: ${err.message}\n`);
+        process.exitCode = 1;
+        return;
     }
-    console.log('');
     // LadybugDB's native module holds open handles that prevent Node from exiting.
     // ONNX Runtime also registers native atexit hooks that segfault on some
     // platforms (#38, #40). Force-exit to ensure clean termination.

package/dist/cli/eval-server.js

@@ -68,7 +68,9 @@ export function formatContextResult(result) {
     if (result.error)
         return `Error: ${result.error}`;
     if (result.status === 'ambiguous') {
-        const lines = [`Multiple symbols named '${result.candidates?.[0]?.name || '?'}'. Disambiguate with file path:\n`];
+        const lines = [
+            `Multiple symbols named '${result.candidates?.[0]?.name || '?'}'. Disambiguate with file path:\n`,
+        ];
         for (const c of result.candidates || []) {
             lines.push(`  ${c.kind} ${c.name} → ${c.filePath}:${c.line || '?'}  (uid: ${c.uid})`);
         }
@@ -171,7 +173,7 @@ export function formatCypherResult(result) {
         const keys = Object.keys(result[0]);
         const lines = [`${result.length} row(s):\n`];
         for (const row of result.slice(0, 30)) {
-            const parts = keys.map(k => `${k}: ${row[k]}`);
+            const parts = keys.map((k) => `${k}: ${row[k]}`);
             lines.push(`  ${parts.join(' | ')}`);
         }
         if (result.length > 30) {
@@ -230,13 +232,20 @@ export function formatListReposResult(result) {
  */
 function formatToolResult(toolName, result) {
     switch (toolName) {
-        case 'query': return formatQueryResult(result);
-        case 'context': return formatContextResult(result);
-        case 'impact': return formatImpactResult(result);
-        case 'cypher': return formatCypherResult(result);
-        case 'detect_changes': return formatDetectChangesResult(result);
-        case 'list_repos': return formatListReposResult(result);
-        default: return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+        case 'query':
+            return formatQueryResult(result);
+        case 'context':
+            return formatContextResult(result);
+        case 'impact':
+            return formatImpactResult(result);
+        case 'cypher':
+            return formatCypherResult(result);
+        case 'detect_changes':
+            return formatDetectChangesResult(result);
+        case 'list_repos':
+            return formatListReposResult(result);
+        default:
+            return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
     }
 }
 // ─── Next-Step Hints ──────────────────────────────────────────────────
@@ -269,7 +278,7 @@ export async function evalServerCommand(options) {
         process.exit(1);
     }
     const repos = await backend.listRepos();
-    console.error(`GitNexus eval-server: ${repos.length} repo(s) loaded: ${repos.map(r => r.name).join(', ')}`);
+    console.error(`GitNexus eval-server: ${repos.length} repo(s) loaded: ${repos.map((r) => r.name).join(', ')}`);
     let idleTimer = null;
     function resetIdleTimer() {
         if (idleTimeoutSec <= 0)
@@ -289,7 +298,7 @@ export async function evalServerCommand(options) {
             if (req.method === 'GET' && req.url === '/health') {
                 res.setHeader('Content-Type', 'application/json');
                 res.writeHead(200);
-                res.end(JSON.stringify({ status: 'ok', repos: repos.map(r => r.name) }));
+                res.end(JSON.stringify({ status: 'ok', repos: repos.map((r) => r.name) }));
                 return;
             }
             // Shutdown