gitnexus 1.4.10 → 1.5.0

package/dist/mcp/resources.js

@@ -81,10 +81,18 @@ function parseUri(uri) {
         const repoName = decodeURIComponent(repoMatch[1]);
         const rest = repoMatch[2];
         if (rest.startsWith('cluster/')) {
-            return { repoName, resourceType: 'cluster', param: decodeURIComponent(rest.replace('cluster/', '')) };
+            return {
+                repoName,
+                resourceType: 'cluster',
+                param: decodeURIComponent(rest.replace('cluster/', '')),
+            };
         }
         if (rest.startsWith('process/')) {
-            return { repoName, resourceType: 'process', param: decodeURIComponent(rest.replace('process/', '')) };
+            return {
+                repoName,
+                resourceType: 'process',
+                param: decodeURIComponent(rest.replace('process/', '')),
+            };
         }
         return { repoName, resourceType: rest };
     }
@@ -163,10 +171,10 @@ async function getContextResource(backend, repoName) {
     // Check staleness
     const repoPath = repo.repoPath;
     const lastCommit = repo.lastCommit || 'HEAD';
-    const staleness = repoPath ? checkStaleness(repoPath, lastCommit) : { isStale: false, commitsBehind: 0 };
-    const lines = [
-        `project: ${context.projectName}`,
-    ];
+    const staleness = repoPath
+        ? checkStaleness(repoPath, lastCommit)
+        : { isStale: false, commitsBehind: 0 };
+    const lines = [`project: ${context.projectName}`];
     if (staleness.isStale && staleness.hint) {
         lines.push('');
         lines.push(`staleness: "${staleness.hint}"`);

package/dist/mcp/server.js

@@ -77,7 +77,7 @@ export function createMCPServer(backend) {
     server.setRequestHandler(ListResourcesRequestSchema, async () => {
         const resources = getResourceDefinitions();
         return {
-            resources: resources.map(r => ({
+            resources: resources.map((r) => ({
                 uri: r.uri,
                 name: r.name,
                 description: r.description,
@@ -89,7 +89,7 @@ export function createMCPServer(backend) {
     server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
         const templates = getResourceTemplates();
         return {
-            resourceTemplates: templates.map(t => ({
+            resourceTemplates: templates.map((t) => ({
                 uriTemplate: t.uriTemplate,
                 name: t.name,
                 description: t.description,
@@ -168,7 +168,11 @@ export function createMCPServer(backend) {
                 name: 'detect_impact',
                 description: 'Analyze the impact of your current changes before committing. Guides through scope selection, change detection, process analysis, and risk assessment.',
                 arguments: [
-                    { name: 'scope', description: 'What to analyze: unstaged, staged, all, or compare', required: false },
+                    {
+                        name: 'scope',
+                        description: 'What to analyze: unstaged, staged, all, or compare',
+                        required: false,
+                    },
                     { name: 'base_ref', description: 'Branch/commit for compare scope', required: false },
                 ],
             },
@@ -176,7 +180,11 @@ export function createMCPServer(backend) {
                 name: 'generate_map',
                 description: 'Generate architecture documentation from the knowledge graph. Creates a codebase overview with execution flows and mermaid diagrams.',
                 arguments: [
-                    { name: 'repo', description: 'Repository name (omit if only one indexed)', required: false },
+                    {
+                        name: 'repo',
+                        description: 'Repository name (omit if only one indexed)',
+                        required: false,
+                    },
                 ],
             },
         ],
@@ -247,7 +255,7 @@ export async function startMCPServer(backend) {
                 return realStdoutWrite;
             const val = Reflect.get(target, prop, receiver);
             return typeof val === 'function' ? val.bind(target) : val;
-        }
+        },
     });
     const transport = new CompatibleStdioServerTransport(process.stdin, _safeStdout);
     await server.connect(transport);

package/dist/mcp/staleness.js

@@ -11,7 +11,11 @@ import { execFileSync } from 'child_process';
 export function checkStaleness(repoPath, lastCommit) {
     try {
         // Get count of commits between lastCommit and HEAD
-        const result = execFileSync('git', ['rev-list', '--count', `${lastCommit}..HEAD`], { cwd: repoPath, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const result = execFileSync('git', ['rev-list', '--count', `${lastCommit}..HEAD`], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
         const commitsBehind = parseInt(result, 10) || 0;
         if (commitsBehind > 0) {
             return {

package/dist/mcp/tools.js

@@ -40,12 +40,29 @@ Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank
             type: 'object',
             properties: {
                 query: { type: 'string', description: 'Natural language or keyword search query' },
-                task_context: { type: 'string', description: 'What you are working on (e.g., "adding OAuth support"). Helps ranking.' },
-                goal: { type: 'string', description: 'What you want to find (e.g., "existing auth validation logic"). Helps ranking.' },
+                task_context: {
+                    type: 'string',
+                    description: 'What you are working on (e.g., "adding OAuth support"). Helps ranking.',
+                },
+                goal: {
+                    type: 'string',
+                    description: 'What you want to find (e.g., "existing auth validation logic"). Helps ranking.',
+                },
                 limit: { type: 'number', description: 'Max processes to return (default: 5)', default: 5 },
-                max_symbols: { type: 'number', description: 'Max symbols per process (default: 10)', default: 10 },
-                include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                max_symbols: {
+                    type: 'number',
+                    description: 'Max symbols per process (default: 10)',
+                    default: 10,
+                },
+                include_content: {
+                    type: 'boolean',
+                    description: 'Include full symbol source code (default: false)',
+                    default: false,
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: ['query'],
         },
@@ -100,7 +117,10 @@ TIPS:
             type: 'object',
             properties: {
                 query: { type: 'string', description: 'Cypher query to execute' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: ['query'],
         },
@@ -120,10 +140,20 @@ NOTE: ACCESSES edges (field read/write tracking) are included in context results
             type: 'object',
             properties: {
                 name: { type: 'string', description: 'Symbol name (e.g., "validateUser", "AuthService")' },
-                uid: { type: 'string', description: 'Direct symbol UID from prior tool results (zero-ambiguity lookup)' },
+                uid: {
+                    type: 'string',
+                    description: 'Direct symbol UID from prior tool results (zero-ambiguity lookup)',
+                },
                 file_path: { type: 'string', description: 'File path to disambiguate common names' },
-                include_content: { type: 'boolean', description: 'Include full symbol source code (default: false)', default: false },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                include_content: {
+                    type: 'boolean',
+                    description: 'Include full symbol source code (default: false)',
+                    default: false,
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: [],
         },
@@ -140,9 +170,20 @@ Returns: changed symbols, affected processes, and a risk summary.`,
         inputSchema: {
             type: 'object',
             properties: {
-                scope: { type: 'string', description: 'What to analyze: "unstaged" (default), "staged", "all", or "compare"', enum: ['unstaged', 'staged', 'all', 'compare'], default: 'unstaged' },
-                base_ref: { type: 'string', description: 'Branch/commit for "compare" scope (e.g., "main")' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                scope: {
+                    type: 'string',
+                    description: 'What to analyze: "unstaged" (default), "staged", "all", or "compare"',
+                    enum: ['unstaged', 'staged', 'all', 'compare'],
+                    default: 'unstaged',
+                },
+                base_ref: {
+                    type: 'string',
+                    description: 'Branch/commit for "compare" scope (e.g., "main")',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: [],
         },
@@ -162,11 +203,21 @@ Each edit is tagged with confidence:
             type: 'object',
             properties: {
                 symbol_name: { type: 'string', description: 'Current symbol name to rename' },
-                symbol_uid: { type: 'string', description: 'Direct symbol UID from prior tool results (zero-ambiguity)' },
+                symbol_uid: {
+                    type: 'string',
+                    description: 'Direct symbol UID from prior tool results (zero-ambiguity)',
+                },
                 new_name: { type: 'string', description: 'The new name for the symbol' },
                 file_path: { type: 'string', description: 'File path to disambiguate common names' },
-                dry_run: { type: 'boolean', description: 'Preview edits without modifying files (default: true)', default: true },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                dry_run: {
+                    type: 'boolean',
+                    description: 'Preview edits without modifying files (default: true)',
+                    default: true,
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: ['new_name'],
         },
@@ -199,12 +250,26 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
             type: 'object',
             properties: {
                 target: { type: 'string', description: 'Name of function, class, or file to analyze' },
-                direction: { type: 'string', description: 'upstream (what depends on this) or downstream (what this depends on)' },
-                maxDepth: { type: 'number', description: 'Max relationship depth (default: 3)', default: 3 },
-                relationTypes: { type: 'array', items: { type: 'string' }, description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, OVERRIDES, ACCESSES (default: usage-based, ACCESSES excluded by default)' },
+                direction: {
+                    type: 'string',
+                    description: 'upstream (what depends on this) or downstream (what this depends on)',
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: 'Max relationship depth (default: 3)',
+                    default: 3,
+                },
+                relationTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, OVERRIDES, ACCESSES (default: usage-based, ACCESSES excluded by default)',
+                },
                 includeTests: { type: 'boolean', description: 'Include test files (default: false)' },
                 minConfidence: { type: 'number', description: 'Minimum confidence 0-1 (default: 0.7)' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: ['target', 'direction'],
         },
@@ -220,8 +285,14 @@ Returns: route nodes with their handlers, middleware wrapper chains (e.g., withA
         inputSchema: {
             type: 'object',
             properties: {
-                route: { type: 'string', description: 'Filter by route path (e.g., "/api/grants"). Omit for all routes.' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                route: {
+                    type: 'string',
+                    description: 'Filter by route path (e.g., "/api/grants"). Omit for all routes.',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: [],
         },
@@ -253,8 +324,14 @@ Returns routes that have both detected response keys AND consumers. Shows top-le
         inputSchema: {
             type: 'object',
             properties: {
-                route: { type: 'string', description: 'Check a specific route (e.g., "/api/grants"). Omit to check all routes.' },
-                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+                route: {
+                    type: 'string',
+                    description: 'Check a specific route (e.g., "/api/grants"). Omit to check all routes.',
+                },
+                repo: {
+                    type: 'string',
+                    description: 'Repository name or path. Omit if only one repo is indexed.',
+                },
             },
             required: [],
         },

package/dist/server/analyze-job.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Analyze Job Manager
+ *
+ * Tracks server-side analysis jobs with:
+ * - In-memory Map storage
+ * - Single-slot concurrency (one active job at a time)
+ * - Same-repo deduplication (returns existing job)
+ * - Progress event emission for SSE relay
+ * - 1-hour TTL cleanup for completed/failed jobs
+ */
+import type { ChildProcess } from 'child_process';
+export interface AnalyzeJobProgress {
+    phase: string;
+    percent: number;
+    message: string;
+}
+export interface AnalyzeJob {
+    id: string;
+    status: 'queued' | 'cloning' | 'analyzing' | 'loading' | 'complete' | 'failed';
+    repoUrl?: string;
+    repoPath?: string;
+    repoName?: string;
+    progress: AnalyzeJobProgress;
+    error?: string;
+    startedAt: number;
+    completedAt?: number;
+    /** Number of times the worker has been retried after a crash. */
+    retryCount: number;
+}
+export declare class JobManager {
+    private jobs;
+    private children;
+    private timeouts;
+    private emitter;
+    private cleanupTimer;
+    constructor();
+    /** Create a new job, or return existing active job for the same repo. */
+    createJob(params: {
+        repoUrl?: string;
+        repoPath?: string;
+    }): AnalyzeJob;
+    getJob(id: string): AnalyzeJob | undefined;
+    updateJob(id: string, update: Partial<Pick<AnalyzeJob, 'status' | 'progress' | 'error' | 'repoPath' | 'repoName' | 'completedAt'>>): void;
+    /** Register a child process for a job — enables cancellation and timeout. */
+    registerChild(jobId: string, child: ChildProcess): void;
+    /** Cancel a running job — sends SIGTERM to child process. */
+    cancelJob(jobId: string, reason?: string): boolean;
+    /** Subscribe to progress events for a job. Returns unsubscribe function. */
+    onProgress(jobId: string, listener: (progress: AnalyzeJobProgress) => void): () => void;
+    dispose(): void;
+    private isTerminal;
+    private cleanup;
+}

package/dist/server/analyze-job.js

@@ -0,0 +1,146 @@
+/**
+ * Analyze Job Manager
+ *
+ * Tracks server-side analysis jobs with:
+ * - In-memory Map storage
+ * - Single-slot concurrency (one active job at a time)
+ * - Same-repo deduplication (returns existing job)
+ * - Progress event emission for SSE relay
+ * - 1-hour TTL cleanup for completed/failed jobs
+ */
+import { randomUUID } from 'crypto';
+import { EventEmitter } from 'events';
+const JOB_TTL_MS = 60 * 60 * 1000; // 1 hour
+const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+const JOB_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+export class JobManager {
+    jobs = new Map();
+    children = new Map();
+    timeouts = new Map();
+    emitter = new EventEmitter();
+    cleanupTimer;
+    constructor() {
+        this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+    }
+    /** Create a new job, or return existing active job for the same repo. */
+    createJob(params) {
+        // Dedup: return existing active job for the same repo (by URL or path)
+        for (const job of this.jobs.values()) {
+            if (!this.isTerminal(job.status)) {
+                const isSameRepo = (params.repoUrl && job.repoUrl === params.repoUrl) ||
+                    (params.repoPath && job.repoPath === params.repoPath);
+                if (isSameRepo) {
+                    return job;
+                }
+            }
+        }
+        // Single-slot: reject if another job is active (different repo)
+        for (const job of this.jobs.values()) {
+            if (!this.isTerminal(job.status)) {
+                throw new Error(`Analysis already in progress (job ${job.id})`);
+            }
+        }
+        const job = {
+            id: randomUUID(),
+            status: 'queued',
+            repoUrl: params.repoUrl,
+            repoPath: params.repoPath,
+            progress: { phase: 'queued', percent: 0, message: 'Waiting to start...' },
+            startedAt: Date.now(),
+            retryCount: 0,
+        };
+        this.jobs.set(job.id, job);
+        return job;
+    }
+    getJob(id) {
+        return this.jobs.get(id);
+    }
+    updateJob(id, update) {
+        const job = this.jobs.get(id);
+        if (!job)
+            return;
+        Object.assign(job, update);
+        if (this.isTerminal(job.status)) {
+            job.completedAt = job.completedAt ?? Date.now();
+        }
+        // Emit exactly one event per updateJob call to prevent SSE double-write
+        if (update.status === 'complete' || update.status === 'failed') {
+            // Terminal event takes precedence — don't also emit the progress event
+            this.emitter.emit(`progress:${id}`, {
+                phase: update.status,
+                percent: update.status === 'complete' ? 100 : job.progress.percent,
+                message: update.status === 'complete' ? 'Complete' : update.error || 'Failed',
+            });
+        }
+        else if (update.progress) {
+            this.emitter.emit(`progress:${id}`, update.progress);
+        }
+    }
+    /** Register a child process for a job — enables cancellation and timeout. */
+    registerChild(jobId, child) {
+        this.children.set(jobId, child);
+        // 30-minute timeout
+        const timer = setTimeout(() => {
+            const job = this.jobs.get(jobId);
+            if (job && !this.isTerminal(job.status)) {
+                this.cancelJob(jobId, 'Analysis timed out (30 minute limit)');
+            }
+        }, JOB_TIMEOUT_MS);
+        this.timeouts.set(jobId, timer);
+        // Clean up tracking when child exits
+        child.on('exit', () => {
+            this.children.delete(jobId);
+            const t = this.timeouts.get(jobId);
+            if (t) {
+                clearTimeout(t);
+                this.timeouts.delete(jobId);
+            }
+        });
+    }
+    /** Cancel a running job — sends SIGTERM to child process. */
+    cancelJob(jobId, reason) {
+        const job = this.jobs.get(jobId);
+        if (!job || this.isTerminal(job.status))
+            return false;
+        const child = this.children.get(jobId);
+        if (child) {
+            child.kill('SIGTERM');
+        }
+        this.updateJob(jobId, {
+            status: 'failed',
+            error: reason || 'Analysis cancelled',
+        });
+        return true;
+    }
+    /** Subscribe to progress events for a job. Returns unsubscribe function. */
+    onProgress(jobId, listener) {
+        const event = `progress:${jobId}`;
+        this.emitter.on(event, listener);
+        return () => this.emitter.off(event, listener);
+    }
+    dispose() {
+        // Kill all active child processes
+        for (const child of this.children.values()) {
+            child.kill('SIGTERM');
+        }
+        this.children.clear();
+        // Clear all timeouts
+        for (const timer of this.timeouts.values()) {
+            clearTimeout(timer);
+        }
+        this.timeouts.clear();
+        clearInterval(this.cleanupTimer);
+        this.emitter.removeAllListeners();
+    }
+    isTerminal(status) {
+        return status === 'complete' || status === 'failed';
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [id, job] of this.jobs) {
+            if (this.isTerminal(job.status) && job.completedAt && now - job.completedAt > JOB_TTL_MS) {
+                this.jobs.delete(id);
+            }
+        }
+    }
+}

package/dist/server/analyze-worker.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Analyze Worker — Forked Child Process
+ *
+ * This file is the entry point for `child_process.fork()`.
+ * It runs runFullAnalysis in an isolated process with 8GB heap.
+ *
+ * IPC Protocol:
+ *   Parent -> Child: { type: 'start', repoPath: string, options: AnalyzeOptions }
+ *   Child -> Parent: { type: 'progress', phase: string, percent: number, message: string }
+ *   Child -> Parent: { type: 'complete', result: AnalyzeResult }
+ *   Child -> Parent: { type: 'error', message: string }
+ */
+export {};

package/dist/server/analyze-worker.js

@@ -0,0 +1,59 @@
+/**
+ * Analyze Worker — Forked Child Process
+ *
+ * This file is the entry point for `child_process.fork()`.
+ * It runs runFullAnalysis in an isolated process with 8GB heap.
+ *
+ * IPC Protocol:
+ *   Parent -> Child: { type: 'start', repoPath: string, options: AnalyzeOptions }
+ *   Child -> Parent: { type: 'progress', phase: string, percent: number, message: string }
+ *   Child -> Parent: { type: 'complete', result: AnalyzeResult }
+ *   Child -> Parent: { type: 'error', message: string }
+ */
+import { runFullAnalysis } from '../core/run-analyze.js';
+import { closeLbug } from '../core/lbug/lbug-adapter.js';
+function send(msg) {
+    process.send?.(msg);
+}
+// Catch uncaught exceptions and unhandled rejections — report to parent
+process.on('uncaughtException', (err) => {
+    send({ type: 'error', message: err?.message || 'Uncaught exception in worker' });
+    setTimeout(() => process.exit(1), 500);
+});
+process.on('unhandledRejection', (reason) => {
+    send({ type: 'error', message: reason?.message || 'Unhandled rejection in worker' });
+    setTimeout(() => process.exit(1), 500);
+});
+// Handle graceful shutdown — notify parent before exit
+process.on('SIGTERM', async () => {
+    send({ type: 'error', message: 'Analysis cancelled (worker received SIGTERM)' });
+    try {
+        await closeLbug();
+    }
+    catch { }
+    process.exit(0);
+});
+// Listen for start command from parent — guarded against re-entry
+let started = false;
+process.on('message', async (msg) => {
+    if (msg.type !== 'start' || started)
+        return;
+    started = true;
+    try {
+        const result = await runFullAnalysis(msg.repoPath, msg.options, {
+            onProgress: (phase, percent, message) => {
+                send({ type: 'progress', phase, percent, message });
+            },
+            onLog: (message) => {
+                send({ type: 'progress', phase: 'log', percent: -1, message });
+            },
+        });
+        send({ type: 'complete', result });
+    }
+    catch (err) {
+        send({ type: 'error', message: err?.message || 'Analysis failed' });
+    }
+    // LadybugDB's native module prevents clean exit — force it
+    // (same reason the CLI uses process.exit(0))
+    setTimeout(() => process.exit(0), 500);
+});