pi-gitnexus-fork 0.7.0

package/dist/index.js

@@ -0,0 +1,479 @@
+import { delimiter } from 'node:path';
+import spawn from 'cross-spawn';
+import { clearIndexCache, DEFAULT_SERVER_URL, extractFilePatternsFromContent, extractFilesFromReadMany, extractPattern, findGitNexusIndex, findGitNexusRoot, gitnexusCmd, loadSavedConfig, resolveGitNexusCmd, runAugment, setAugmentTimeout, setGitnexusCmd, spawnEnv, updateSpawnEnv } from './gitnexus';
+import { createMcpClient, mcpClient } from './mcp-client';
+import { registerTools } from './tools';
+import { openMainMenu } from './ui/main-menu';
+const SEARCH_TOOLS = new Set(['grep', 'find', 'bash', 'read', 'read_many']);
+/**
+ * Run augment via remote MCP query tool instead of local subprocess.
+ * Falls back to empty string on any error (graceful degradation).
+ */
+async function remoteAugment(pattern, cwd) {
+    if (!augmentMcpClient)
+        return '';
+    try {
+        const repo = findGitNexusRoot(cwd) ?? cwd;
+        return await augmentMcpClient.callTool('query', { query: pattern, repo, limit: 3 }, cwd);
+    }
+    catch {
+        return '';
+    }
+}
+/** Run augment: local subprocess or remote MCP depending on mode. */
+function augment(pattern, cwd) {
+    return isRemoteMode ? remoteAugment(pattern, cwd) : runAugment(pattern, cwd);
+}
+/**
+ * Merge two PATH values, preferring the agent's PATH over the login shell's PATH
+ * while preserving order.  Any shell-only directories (e.g. nvm/fnm/volta paths
+ * that the agent didn't inherit) are appended at the end so they are still found.
+ *
+ * This prevents the agent's existing PATH entries (such as ~/.local/share/nvm/…)
+ * from being silently dropped when the login shell reports a different PATH.
+ */
+function mergePaths(agent, shell) {
+    const seen = new Set();
+    const out = [];
+    for (const dir of [...agent.split(delimiter), ...shell.split(delimiter)]) {
+        if (!dir)
+            continue;
+        const key = process.platform === 'win32' ? dir.toLowerCase() : dir;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(dir);
+    }
+    return out.join(delimiter);
+}
+/**
+ * Resolve PATH from a login shell so nvm/fnm/volta binaries are visible.
+ * Merges with the agent's current PATH so directories already present
+ * (e.g. ~/.local/share/nvm/…) are never lost.
+ *
+ * On Windows the agent's PATH is already correct so we skip the probe entirely.
+ * On macOS/Linux we use the user's login shell ($SHELL) to read login startup
+ * files (.zprofile, .bash_profile, .profile), which is where most package
+ * managers place their PATH setup.
+ *
+ * The probe is bounded by a timeout to prevent a slow or broken startup file
+ * from stalling session initialization.
+ */
+async function resolveShellPath() {
+    if (process.platform === 'win32')
+        return;
+    const loginShell = process.env.SHELL ?? '/bin/sh';
+    const shellPath = await new Promise((resolve_) => {
+        let out = '';
+        let done = false;
+        const finish = (value) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve_(value);
+        };
+        const proc = spawn(loginShell, ['-lc', 'printf %s "$PATH"'], {
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const timer = setTimeout(() => {
+            proc.kill();
+            finish(process.env.PATH ?? '');
+        }, 3_000);
+        proc.stdout.on('data', (d) => { out += d.toString(); });
+        proc.on('close', () => finish(out.trim() || (process.env.PATH ?? '')));
+        proc.on('error', () => finish(process.env.PATH ?? ''));
+    });
+    const merged = mergePaths(process.env.PATH ?? '', shellPath);
+    updateSpawnEnv({ ...process.env, PATH: merged });
+}
+function trySpawn(bin, args) {
+    return new Promise((resolve_) => {
+        const proc = spawn(bin, args, { stdio: 'ignore', env: spawnEnv });
+        proc.on('close', (code) => resolve_(code === 0));
+        proc.on('error', () => resolve_(false));
+    });
+}
+/** Probe for gitnexus using the configured command. */
+async function probeGitNexusBinary() {
+    const [bin, ...args] = gitnexusCmd;
+    return trySpawn(bin, [...args, '--version']);
+}
+/** Cached from session_start/session_switch — avoids re-probing on every /gitnexus status. */
+let binaryAvailable = false;
+/** Working directory of the current session — ctx.cwd in tool_result events may differ. */
+let sessionCwd = '';
+/** Persisted config — loaded on session_start, mutated by the settings menu. */
+let cfg = {};
+/** The active MCP client for augment hooks — may be remote or stdio. */
+let augmentMcpClient = null;
+/** Whether the augment hook should use remote MCP instead of local runAugment. */
+let isRemoteMode = false;
+/** Controls whether the tool_result hook auto-appends graph context. Tools are unaffected. */
+let augmentEnabled = true;
+/** Number of successful augmentations this session. Shown in /gitnexus status. */
+let augmentHits = 0;
+/** Number of times the tool_result hook intercepted a search tool result this session. */
+let hookFires = 0;
+/**
+ * Patterns already augmented this session (with non-empty results).
+ * Prevents the same symbol/file from being looked up repeatedly.
+ * Keys are lowercased for case-insensitive dedup.
+ */
+const augmentedCache = new Set();
+/**
+ * Patterns that returned empty results on first attempt.
+ * Prevents unbounded retries. Cleared on session reset (index rebuild).
+ */
+const emptyCache = new Set();
+export default function (pi) {
+    registerTools(pi);
+    pi.registerFlag('gitnexus-cmd', {
+        type: 'string',
+        default: '',
+        description: 'Command used to invoke gitnexus, e.g. "npx gitnexus@latest". Empty uses saved config or plain "gitnexus".',
+    });
+    // Append a one-liner so the agent understands graph context in search results.
+    pi.on('before_agent_start', async (event, ctx) => {
+        if (!findGitNexusIndex(ctx.cwd))
+            return;
+        if (event.systemPrompt == null)
+            return;
+        return {
+            systemPrompt: event.systemPrompt +
+                '\n\n[GitNexus active] Graph context will appear after search results. ' +
+                'Use gitnexus_query, gitnexus_context, gitnexus_impact, gitnexus_detect_changes, ' +
+                'gitnexus_list_repos, gitnexus_rename, and gitnexus_cypher for deeper analysis. ' +
+                'If the index is stale after code changes, run /gitnexus analyze to rebuild it.',
+        };
+    });
+    // Core hook: mirrors the Claude Code PreToolUse integration.
+    // Intercepts grep/find/bash/read results, appends knowledge graph context.
+    pi.on('tool_result', async (event, ctx) => {
+        if (!augmentEnabled)
+            return;
+        if (!SEARCH_TOOLS.has(event.toolName))
+            return;
+        // Guard: event.content may be undefined for error results.
+        if (!event.content || !Array.isArray(event.content))
+            return;
+        hookFires++;
+        const cwd = sessionCwd || ctx.cwd;
+        if (!findGitNexusIndex(cwd))
+            return;
+        // read_many: per-file labeled context so the agent knows which context belongs to which file.
+        if (event.toolName === 'read_many') {
+            const files = extractFilesFromReadMany(event.input, event.content);
+            const fresh = files.filter(f => {
+                const key = f.pattern.toLowerCase();
+                return !augmentedCache.has(key) && !emptyCache.has(key);
+            }).slice(0, 5);
+            if (fresh.length === 0)
+                return;
+            const results = await Promise.all(fresh.map(f => augment(f.pattern, cwd).then(out => ({ f, out }))));
+            // Cache based on results: successful → augmentedCache, empty → emptyCache
+            for (const r of results) {
+                const key = r.f.pattern.toLowerCase();
+                if (r.out) {
+                    augmentedCache.add(key);
+                }
+                else {
+                    emptyCache.add(key);
+                }
+            }
+            const sections = results.filter(r => r.out);
+            if (sections.length === 0)
+                return;
+            augmentHits++;
+            const body = sections.length === 1
+                ? sections[0].out
+                : sections.map(({ f, out }) => `### ${f.path.split('/').pop()}\n${out}`).join('\n\n');
+            const label = body.startsWith('[GitNexus]') ? '' : (sections.length === 1
+                ? `[GitNexus: ${sections[0].f.path.split('/').pop()}]\n`
+                : '[GitNexus]\n');
+            return {
+                content: [
+                    ...event.content,
+                    { type: 'text', text: `\n\n---\n${label}${body}\n---` },
+                ],
+            };
+        }
+        // Early-exit: skip enrichment when the tool returned no meaningful content.
+        const contentText = event.content.map((c) => c.text ?? '').join('');
+        if (contentText.length < 10)
+            return;
+        // Collect patterns: primary from input, secondary filenames from result content.
+        const primary = extractPattern(event.toolName, event.input);
+        const secondaryLimit = cfg.maxSecondaryPatterns ?? 2;
+        const secondary = (event.toolName === 'grep' || event.toolName === 'bash')
+            ? extractFilePatternsFromContent(event.content, secondaryLimit)
+            : [];
+        const candidates = [...new Set([primary, ...secondary].filter((p) => !!p))];
+        // Filter patterns already augmented or known-empty this session (case-insensitive).
+        const fresh = candidates.filter(p => {
+            const key = p.toLowerCase();
+            return !augmentedCache.has(key) && !emptyCache.has(key);
+        });
+        if (fresh.length === 0)
+            return;
+        // Run augments in parallel, merge results.
+        const maxAugments = cfg.maxAugmentsPerResult ?? 3;
+        const toRun = fresh.slice(0, maxAugments);
+        const results = await Promise.all(toRun.map(p => augment(p, cwd).then(out => ({ p, out }))));
+        // Cache based on results: successful → augmentedCache, empty → emptyCache
+        for (const r of results) {
+            const key = r.p.toLowerCase();
+            if (r.out) {
+                augmentedCache.add(key);
+            }
+            else {
+                emptyCache.add(key);
+            }
+        }
+        const combined = results.filter(r => r.out).map(r => r.out).join('\n\n');
+        if (!combined)
+            return;
+        augmentHits++;
+        const label = combined.startsWith('[GitNexus]') ? '' : `[GitNexus: ${toRun.join(', ')}]\n`;
+        return {
+            content: [
+                ...event.content,
+                { type: 'text', text: `\n\n---\n${label}${combined}\n---` },
+            ],
+        };
+    });
+    async function onSession(ctx) {
+        mcpClient.stop();
+        augmentMcpClient?.stop();
+        augmentMcpClient = null;
+        isRemoteMode = false;
+        clearIndexCache();
+        augmentHits = 0;
+        hookFires = 0;
+        augmentedCache.clear();
+        emptyCache.clear();
+        sessionCwd = ctx.cwd;
+        await resolveShellPath();
+        // Load persisted config
+        cfg = loadSavedConfig();
+        augmentEnabled = cfg.autoAugment !== false;
+        if (cfg.augmentTimeout)
+            setAugmentTimeout(cfg.augmentTimeout);
+        // Resolve command: default → saved config → CLI flag (highest precedence)
+        const flag = pi.getFlag('gitnexus-cmd');
+        setGitnexusCmd(resolveGitNexusCmd(flag, cfg.cmd));
+        binaryAvailable = await probeGitNexusBinary();
+        if (!findGitNexusIndex(ctx.cwd))
+            return;
+        // Determine transport mode for augment hook
+        const mode = cfg.mode ?? 'auto';
+        const serverUrl = cfg.serverUrl || DEFAULT_SERVER_URL;
+        if (mode === 'remote' || (mode === 'auto' && !binaryAvailable)) {
+            isRemoteMode = true;
+            augmentMcpClient = createMcpClient('remote', serverUrl);
+            ctx.ui.notify(`GitNexus: using remote MCP backend (${serverUrl}).`, 'info');
+        }
+        else if (binaryAvailable) {
+            ctx.ui.notify('GitNexus: knowledge graph active — searches will be enriched automatically.', 'info');
+        }
+        else {
+            ctx.ui.notify('GitNexus index found but gitnexus is not on PATH. Install: npm i -g gitnexus', 'warning');
+        }
+    }
+    pi.on('session_start', (_event, ctx) => {
+        void onSession(ctx).catch(err => {
+            ctx.ui.notify(`GitNexus session init failed: ${err.message}`, 'error');
+        });
+    });
+    const subcommands = ['status', 'analyze', 'on', 'off', 'settings', 'query', 'context', 'impact', 'help'];
+    pi.registerCommand('gitnexus', {
+        description: 'GitNexus knowledge graph. Type /gitnexus help for usage.',
+        getArgumentCompletions: (prefix) => {
+            const items = subcommands
+                .filter(s => s.startsWith(prefix))
+                .map(s => ({ value: s, label: s }));
+            return items.length > 0 ? items : null;
+        },
+        handler: async (args, ctx) => {
+            const parts = args.trim().split(/\s+/);
+            const sub = parts[0] ?? '';
+            const rest = parts.slice(1).join(' ');
+            // /gitnexus status
+            if (sub === 'status') {
+                if (!binaryAvailable) {
+                    ctx.ui.notify('gitnexus is not installed. Install: npm i -g gitnexus', 'warning');
+                    return;
+                }
+                if (!findGitNexusIndex(ctx.cwd)) {
+                    ctx.ui.notify('No GitNexus index found. Run: /gitnexus analyze', 'info');
+                    return;
+                }
+                const out = await new Promise((resolve_) => {
+                    let stdout = '';
+                    const [bin, ...baseArgs] = gitnexusCmd;
+                    const proc = spawn(bin, [...baseArgs, 'status'], {
+                        cwd: ctx.cwd,
+                        stdio: ['ignore', 'pipe', 'ignore'],
+                        env: spawnEnv,
+                    });
+                    proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+                    proc.on('close', () => resolve_(stdout.trim()));
+                    proc.on('error', () => resolve_(''));
+                });
+                const augmentLine = augmentEnabled
+                    ? `Auto-augment: on (${hookFires} intercepted, ${augmentHits} enriched this session)`
+                    : 'Auto-augment: off';
+                ctx.ui.notify((out ? out + '\n' : '') + augmentLine, 'info');
+                return;
+            }
+            // /gitnexus help
+            if (sub === 'help') {
+                ctx.ui.notify('/gitnexus — GitNexus knowledge graph\n' +
+                    '\n' +
+                    'Commands:\n' +
+                    '  /gitnexus             — interactive menu (status & settings)\n' +
+                    '  /gitnexus status      — show status\n' +
+                    '  /gitnexus analyze     — index the codebase\n' +
+                    '  /gitnexus on|off      — enable/disable auto-augment on searches\n' +
+                    '  /gitnexus <pattern>   — manual graph lookup\n' +
+                    '  /gitnexus query <q>   — search execution flows\n' +
+                    '  /gitnexus context <n> — callers/callees of a symbol\n' +
+                    '  /gitnexus impact <n>  — blast radius of a change\n' +
+                    '\n' +
+                    'Tools (always available to the agent):\n' +
+                    '  gitnexus_list_repos, gitnexus_query, gitnexus_context,\n' +
+                    '  gitnexus_impact, gitnexus_detect_changes,\n' +
+                    '  gitnexus_rename, gitnexus_cypher', 'info');
+                return;
+            }
+            // /gitnexus on | off
+            if (sub === 'on' || sub === 'off') {
+                augmentEnabled = sub === 'on';
+                ctx.ui.notify(`GitNexus auto-augment ${augmentEnabled ? 'enabled' : 'disabled'}.`, 'info');
+                return;
+            }
+            // /gitnexus  or  /gitnexus config | settings — main menu
+            if (!sub || sub === 'config' || sub === 'settings') {
+                const state = { augmentEnabled };
+                await openMainMenu({
+                    ui: ctx.ui,
+                    cwd: ctx.cwd,
+                    cfg,
+                    state,
+                    binaryAvailable,
+                    gitnexusCmd,
+                    spawnEnv,
+                    getHookFires: () => hookFires,
+                    getAugmentHits: () => augmentHits,
+                    findGitNexusIndex,
+                    clearIndexCache,
+                    setGitnexusCmd,
+                    setAugmentTimeout,
+                    syncState: () => {
+                        augmentEnabled = state.augmentEnabled;
+                        if (cfg.cmd)
+                            setGitnexusCmd(cfg.cmd.trim().split(/\s+/));
+                        if (cfg.augmentTimeout)
+                            setAugmentTimeout(cfg.augmentTimeout);
+                    },
+                });
+                return;
+            }
+            // /gitnexus analyze
+            if (sub === 'analyze') {
+                if (!binaryAvailable) {
+                    ctx.ui.notify('gitnexus is not installed. Install: npm i -g gitnexus', 'warning');
+                    return;
+                }
+                augmentEnabled = false;
+                ctx.ui.notify('GitNexus: analyzing codebase, this may take a while…', 'info');
+                const exitCode = await new Promise((resolve_) => {
+                    const [bin, ...baseArgs] = gitnexusCmd;
+                    const proc = spawn(bin, [...baseArgs, 'analyze'], {
+                        cwd: ctx.cwd,
+                        stdio: 'ignore',
+                        env: spawnEnv,
+                    });
+                    proc.on('close', resolve_);
+                    proc.on('error', () => resolve_(null));
+                });
+                if (exitCode === 0) {
+                    clearIndexCache();
+                    augmentEnabled = true;
+                    ctx.ui.notify('GitNexus: analysis complete. Knowledge graph ready.', 'info');
+                }
+                else {
+                    augmentEnabled = true;
+                    ctx.ui.notify('GitNexus: analysis failed. Check the terminal for details.', 'error');
+                }
+                return;
+            }
+            const repo = findGitNexusRoot(ctx.cwd) ?? ctx.cwd;
+            // /gitnexus query <text>
+            if (sub === 'query') {
+                if (!rest) {
+                    ctx.ui.notify('Usage: /gitnexus query <text>', 'info');
+                    return;
+                }
+                try {
+                    const out = await mcpClient.callTool('query', { query: rest, repo }, ctx.cwd);
+                    if (out)
+                        pi.sendUserMessage(out, { deliverAs: 'followUp' });
+                    else
+                        ctx.ui.notify('No results.', 'info');
+                }
+                catch (error) {
+                    ctx.ui.notify(error instanceof Error ? error.message : 'GitNexus query failed.', 'error');
+                }
+                return;
+            }
+            // /gitnexus context <name>
+            if (sub === 'context') {
+                if (!rest) {
+                    ctx.ui.notify('Usage: /gitnexus context <name>', 'info');
+                    return;
+                }
+                try {
+                    const out = await mcpClient.callTool('context', { name: rest, repo }, ctx.cwd);
+                    if (out)
+                        pi.sendUserMessage(out, { deliverAs: 'followUp' });
+                    else
+                        ctx.ui.notify('No results.', 'info');
+                }
+                catch (error) {
+                    ctx.ui.notify(error instanceof Error ? error.message : 'GitNexus context lookup failed.', 'error');
+                }
+                return;
+            }
+            // /gitnexus impact <name>
+            if (sub === 'impact') {
+                if (!rest) {
+                    ctx.ui.notify('Usage: /gitnexus impact <name>', 'info');
+                    return;
+                }
+                try {
+                    const out = await mcpClient.callTool('impact', { target: rest, direction: 'upstream', repo }, ctx.cwd);
+                    if (out)
+                        pi.sendUserMessage(out, { deliverAs: 'followUp' });
+                    else
+                        ctx.ui.notify('No results.', 'info');
+                }
+                catch (error) {
+                    ctx.ui.notify(error instanceof Error ? error.message : 'GitNexus impact analysis failed.', 'error');
+                }
+                return;
+            }
+            // /gitnexus <pattern>  — manual augment lookup
+            const pattern = sub + (rest ? ' ' + rest : '');
+            if (pattern.length < 3) {
+                ctx.ui.notify('Pattern too short (min 3 chars).', 'info');
+                return;
+            }
+            const out = await runAugment(pattern, ctx.cwd);
+            if (out)
+                pi.sendUserMessage('[GitNexus]\n' + out, { deliverAs: 'followUp' });
+            else
+                ctx.ui.notify('No graph context found for: ' + pattern, 'info');
+        },
+    });
+}

package/dist/mcp-client-factory.d.ts

@@ -0,0 +1,19 @@
+import type { McpClient } from './mcp-client';
+export interface McpClientFactoryConfig {
+    mode?: 'auto' | 'local' | 'remote';
+    serverUrl?: string;
+}
+export declare class McpClientFactory {
+    /**
+     * Create an MCP client based on the given configuration.
+     * For mode='auto', this is async (probes local binary first).
+     */
+    static createClient(config: McpClientFactoryConfig): Promise<McpClient>;
+    /**
+     * Load config from ~/.pi/pi-gitnexus.json with env var overrides.
+     */
+    static loadConfig(): {
+        mode: 'auto' | 'local' | 'remote';
+        serverUrl?: string;
+    };
+}

package/dist/mcp-client-factory.js

@@ -0,0 +1,78 @@
+import spawn from 'cross-spawn';
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { gitnexusCmd, spawnEnv, validateMcpMode } from './gitnexus';
+/** Default remote MCP server URL. */
+const DEFAULT_SERVER_URL = 'http://100.114.135.99:4747/api/mcp';
+const CONFIG_PATH = `${homedir()}/.pi/pi-gitnexus.json`;
+export class McpClientFactory {
+    /**
+     * Create an MCP client based on the given configuration.
+     * For mode='auto', this is async (probes local binary first).
+     */
+    static async createClient(config) {
+        const mode = config.mode ?? 'auto';
+        const serverUrl = config.serverUrl || DEFAULT_SERVER_URL;
+        if (mode === 'local') {
+            const mod = await import('./mcp-client');
+            return construct(mod.StdioMcpClient);
+        }
+        if (mode === 'remote') {
+            const mod = await import('./remote-mcp-client');
+            return construct(mod.RemoteMcpClient, { serverUrl });
+        }
+        // mode === 'auto': probe local binary first
+        const localWorks = await probeLocalBinary();
+        if (localWorks) {
+            const mod = await import('./mcp-client');
+            return construct(mod.StdioMcpClient);
+        }
+        const mod = await import('./remote-mcp-client');
+        return construct(mod.RemoteMcpClient, { serverUrl });
+    }
+    /**
+     * Load config from ~/.pi/pi-gitnexus.json with env var overrides.
+     */
+    static loadConfig() {
+        let raw = {};
+        try {
+            if (existsSync(CONFIG_PATH)) {
+                raw = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+            }
+        }
+        catch {
+            // ignore read errors
+        }
+        const envMode = process.env.GITNEXUS_MODE ? validateMcpMode(process.env.GITNEXUS_MODE) : undefined;
+        const envUrl = process.env.GITNEXUS_SERVER_URL || undefined;
+        return {
+            mode: envMode ?? validateMcpMode(raw.mode),
+            serverUrl: envUrl ?? (typeof raw.serverUrl === 'string' && raw.serverUrl.trim() ? raw.serverUrl.trim() : DEFAULT_SERVER_URL),
+        };
+    }
+}
+/**
+ * Construct an instance from a class or mock function.
+ * Works with both real ES classes and vi.fn() mocks.
+ */
+function construct(Ctor, ...args) {
+    // For vi.fn() mocks, calling without new returns the mock value.
+    // For real classes, we need new. Try both.
+    try {
+        return new Ctor(...args);
+    }
+    catch {
+        return Ctor(...args);
+    }
+}
+function probeLocalBinary() {
+    return new Promise((resolve_) => {
+        const [bin, ...baseArgs] = gitnexusCmd;
+        const proc = spawn(bin, [...baseArgs, '--version'], {
+            stdio: 'ignore',
+            env: spawnEnv,
+        });
+        proc.on('close', (code) => resolve_(code === 0));
+        proc.on('error', () => resolve_(false));
+    });
+}

package/dist/mcp-client-stdio.d.ts

@@ -0,0 +1,35 @@
+import type { McpClient } from './mcp-client';
+/**
+ * Thin stdio JSON-RPC 2.0 client for `gitnexus mcp`.
+ *
+ * Communication is exclusively over the spawned process's stdin/stdout pipe —
+ * no network socket, no port. Only our process can write to the pipe.
+ *
+ * The MCP process is started lazily on the first callTool() invocation and
+ * kept alive for the session lifetime. stop() terminates it; the next callTool()
+ * re-spawns with the new cwd.
+ */
+export declare class StdioMcpClient implements McpClient {
+    private proc;
+    private buffer;
+    private pending;
+    private nextId;
+    private startPromise;
+    /**
+     * Probe the local gitnexus binary. Returns true if it responds to --version.
+     * Static method for use by AutoMcpClient without instantiating.
+     */
+    static probeLocalBinary(): Promise<boolean>;
+    /**
+     * Lazily spawn `gitnexus mcp` and complete the MCP initialize handshake.
+     * Idempotent — concurrent calls await the same promise; only one process spawns.
+     */
+    private ensureStarted;
+    /**
+     * Call a gitnexus MCP tool and return its formatted text response.
+     * Starts the MCP process lazily if not already running.
+     */
+    callTool(name: string, args: Record<string, unknown>, cwd: string): Promise<string>;
+    /** Terminate the MCP process. Called on session_start so the next session gets a fresh process. */
+    stop(): void;
+}