@simonren/quorum 0.7.0

package/dist/cli/gemini.js

@@ -0,0 +1,253 @@
+/**
+ * Gemini CLI Wrapper
+ *
+ * Uses Google's Gemini CLI in non-interactive mode (gemini -p)
+ * Reference: https://github.com/google-gemini/gemini-cli
+ * Package: @google/gemini-cli
+ */
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { build7SectionPrompt, buildDeveloperInstructions, buildRetryPrompt, isValidFeedbackOutput } from '../prompt.js';
+import { createTimeoutError, createCliNotFoundError, getSuggestion } from '../errors.js';
+// Activity-based timeout: reset on output, kill on silence
+const INACTIVITY_TIMEOUT_MS = 120000; // 2 min of no output = timeout
+const MAX_TIMEOUT_MS = 3600000; // 60 min absolute max (edge case safety)
+const MAX_RETRIES = 2;
+const MAX_BUFFER_SIZE = 1024 * 1024; // 1MB max buffer to prevent memory issues
+/**
+ * Run Gemini CLI with the given request
+ */
+export async function runGeminiReview(request) {
+    // Validate workingDir exists before running
+    if (!existsSync(request.workingDir)) {
+        return {
+            success: false,
+            error: {
+                type: 'cli_error',
+                cli: 'gemini',
+                exitCode: -1,
+                stderr: `Working directory does not exist: ${request.workingDir}`
+            },
+            suggestion: 'Check that the working directory path is correct',
+            model: 'gemini'
+        };
+    }
+    return runWithRetry(request, 0);
+}
+/**
+ * Run Gemini with retry logic
+ */
+async function runWithRetry(request, attempt, previousError, previousOutput) {
+    try {
+        // Build the prompt (use retry prompt if this is a retry)
+        const basePrompt = attempt === 0
+            ? build7SectionPrompt(request)
+            : buildRetryPrompt(request, attempt + 1, previousError, previousOutput);
+        const developerInstructions = buildDeveloperInstructions('gemini');
+        // Combine developer instructions with the prompt
+        // Gemini CLI doesn't have a separate system instruction flag in non-interactive mode
+        const fullPrompt = `${developerInstructions}\n\n---\n\n${basePrompt}`;
+        // Run the CLI
+        const result = await runGeminiCli(fullPrompt, request.workingDir);
+        // Check for CLI errors
+        if (result.exitCode !== 0) {
+            // Check for specific error patterns in stderr
+            if (result.stderr.toLowerCase().includes('rate limit') ||
+                result.stderr.toLowerCase().includes('quota')) {
+                return {
+                    success: false,
+                    error: {
+                        type: 'rate_limit',
+                        cli: 'gemini',
+                        retryAfterMs: parseRetryAfter(result.stderr)
+                    },
+                    suggestion: 'Wait and retry, or use /codex-review instead',
+                    model: 'gemini'
+                };
+            }
+            if (result.stderr.toLowerCase().includes('unauthorized') ||
+                result.stderr.toLowerCase().includes('authentication') ||
+                result.stderr.toLowerCase().includes('api key') ||
+                result.stderr.includes('401') ||
+                result.stderr.includes('403')) {
+                return {
+                    success: false,
+                    error: {
+                        type: 'auth_error',
+                        cli: 'gemini',
+                        message: result.stderr
+                    },
+                    suggestion: 'Run `gemini` and follow the authentication prompts, or set GEMINI_API_KEY',
+                    model: 'gemini'
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    type: 'cli_error',
+                    cli: 'gemini',
+                    exitCode: result.exitCode,
+                    stderr: result.stderr
+                },
+                model: 'gemini'
+            };
+        }
+        // Check for buffer truncation warning
+        if (result.truncated) {
+            return {
+                success: false,
+                error: {
+                    type: 'cli_error',
+                    cli: 'gemini',
+                    exitCode: 0,
+                    stderr: 'Output exceeded maximum buffer size (1MB) and was truncated'
+                },
+                suggestion: 'Try reviewing a smaller scope with --focus',
+                model: 'gemini'
+            };
+        }
+        // Validate the response structure
+        if (!isValidFeedbackOutput(result.stdout)) {
+            if (attempt < MAX_RETRIES) {
+                // Retry with history
+                return runWithRetry(request, attempt + 1, 'Output missing required sections (Agreements, Disagreements, Additions, Alternatives, Risk Assessment)', result.stdout);
+            }
+            // Max retries reached, return invalid response error
+            return {
+                success: false,
+                error: {
+                    type: 'invalid_response',
+                    cli: 'gemini',
+                    rawOutput: result.stdout
+                },
+                suggestion: getSuggestion({ type: 'invalid_response', cli: 'gemini', rawOutput: result.stdout }),
+                model: 'gemini'
+            };
+        }
+        return {
+            success: true,
+            feedback: result.stdout,
+            model: 'gemini'
+        };
+    }
+    catch (error) {
+        const err = error;
+        // Handle CLI not found (ENOENT for the gemini binary itself)
+        if (err.code === 'ENOENT') {
+            return {
+                success: false,
+                error: createCliNotFoundError('gemini'),
+                suggestion: getSuggestion(createCliNotFoundError('gemini')),
+                model: 'gemini'
+            };
+        }
+        if (err.message === 'TIMEOUT' || err.message === 'MAX_TIMEOUT') {
+            const isMaxTimeout = err.message === 'MAX_TIMEOUT';
+            const timeoutMs = isMaxTimeout ? MAX_TIMEOUT_MS : INACTIVITY_TIMEOUT_MS;
+            return {
+                success: false,
+                error: createTimeoutError('gemini', timeoutMs),
+                suggestion: isMaxTimeout
+                    ? 'Task exceeded 60 minute maximum. Try a smaller scope.'
+                    : 'No output for 2 minutes. Process may be hung. Try a smaller scope or use --focus.',
+                model: 'gemini'
+            };
+        }
+        // Generic error
+        return {
+            success: false,
+            error: {
+                type: 'cli_error',
+                cli: 'gemini',
+                exitCode: -1,
+                stderr: err.message
+            },
+            model: 'gemini'
+        };
+    }
+}
+/**
+ * Execute the Gemini CLI in non-interactive mode
+ *
+ * Uses: gemini --yolo --include-directories <workingDir> "<prompt>"
+ */
+function runGeminiCli(prompt, workingDir) {
+    return new Promise((resolve, reject) => {
+        // Build CLI arguments for non-interactive execution
+        // Use positional prompt (not deprecated -p flag) and --yolo for auto-approval
+        const args = [
+            '--yolo',
+            '--model', 'gemini-3.1-pro-preview',
+            '--include-directories', workingDir,
+            prompt
+        ];
+        const proc = spawn('gemini', args, {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env }
+        });
+        let stdout = '';
+        let stderr = '';
+        let truncated = false;
+        let inactivityTimer;
+        // Max timeout - absolute cap (60 min)
+        const maxTimer = setTimeout(() => {
+            proc.kill('SIGTERM');
+            reject(new Error('MAX_TIMEOUT'));
+        }, MAX_TIMEOUT_MS);
+        // Activity-based timeout - reset on any output
+        const resetInactivityTimer = () => {
+            clearTimeout(inactivityTimer);
+            inactivityTimer = setTimeout(() => {
+                proc.kill('SIGTERM');
+                reject(new Error('TIMEOUT'));
+            }, INACTIVITY_TIMEOUT_MS);
+        };
+        // Start inactivity timer
+        resetInactivityTimer();
+        proc.stdout.on('data', (data) => {
+            resetInactivityTimer(); // Still streaming = reset timer
+            if (stdout.length < MAX_BUFFER_SIZE) {
+                stdout += data.toString();
+                if (stdout.length > MAX_BUFFER_SIZE) {
+                    stdout = stdout.slice(0, MAX_BUFFER_SIZE);
+                    truncated = true;
+                }
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            resetInactivityTimer(); // Still streaming = reset timer
+            if (stderr.length < MAX_BUFFER_SIZE) {
+                stderr += data.toString();
+                if (stderr.length > MAX_BUFFER_SIZE) {
+                    stderr = stderr.slice(0, MAX_BUFFER_SIZE);
+                }
+            }
+        });
+        proc.on('close', (code) => {
+            clearTimeout(inactivityTimer);
+            clearTimeout(maxTimer);
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? -1,
+                truncated
+            });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(inactivityTimer);
+            clearTimeout(maxTimer);
+            reject(err);
+        });
+    });
+}
+/**
+ * Parse retry-after duration from error message
+ */
+function parseRetryAfter(errorMessage) {
+    const match = errorMessage.match(/retry[- ]?after[:\s]+(\d+)/i);
+    if (match) {
+        return parseInt(match[1]) * 1000; // Convert to ms
+    }
+    return undefined;
+}

package/dist/commands.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared module for slash command installation
+ *
+ * Used by index.ts (auto-install on MCP server startup and `update` subcommand)
+ */
+export interface InstallResult {
+    success: boolean;
+    installed: string[];
+    removed: string[];
+    error?: string;
+}
+/**
+ * Get source and target paths for command files
+ */
+export declare function getCommandPaths(): {
+    source: string;
+    target: string;
+};
+/**
+ * Install slash commands to ~/.claude/commands/
+ *
+ * @param overrides Test-only path overrides; production callers pass nothing.
+ * @returns Result object with success status and installed commands
+ */
+export declare function installCommands(overrides?: Partial<{
+    source: string;
+    target: string;
+}>): InstallResult;

package/dist/commands.js

@@ -0,0 +1,105 @@
+/**
+ * Shared module for slash command installation
+ *
+ * Used by index.ts (auto-install on MCP server startup and `update` subcommand)
+ */
+import { existsSync, mkdirSync, copyFileSync, readdirSync, renameSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/** Old command filenames that should be pruned on upgrade */
+const DEPRECATED_COMMANDS = [
+    'codex.md',
+    'gemini.md',
+    'multi.md',
+    'codex-xhigh.md',
+    'ask-codex.md',
+    'ask-gemini.md',
+    'ask-multi.md',
+    'multi-review-adv.md',
+    // Removed in favor of /multi-review and /multi-consult only:
+    'codex-review.md',
+    'codex-xhigh-review.md',
+    'gemini-review.md',
+    'claude-review.md',
+];
+/**
+ * Get source and target paths for command files
+ */
+export function getCommandPaths() {
+    return {
+        source: join(__dirname, '..', 'commands'),
+        target: join(homedir(), '.claude', 'commands'),
+    };
+}
+/**
+ * Install slash commands to ~/.claude/commands/
+ *
+ * @param overrides Test-only path overrides; production callers pass nothing.
+ * @returns Result object with success status and installed commands
+ */
+export function installCommands(overrides) {
+    const defaults = getCommandPaths();
+    const source = overrides?.source ?? defaults.source;
+    const target = overrides?.target ?? defaults.target;
+    // Check source exists
+    if (!existsSync(source)) {
+        return { success: false, installed: [], removed: [], error: 'Commands directory not found' };
+    }
+    // Create target directory, handle errors (not a dir, permission denied)
+    try {
+        if (existsSync(target)) {
+            if (!statSync(target).isDirectory()) {
+                return { success: false, installed: [], removed: [], error: `${target} exists but is not a directory` };
+            }
+        }
+        else {
+            mkdirSync(target, { recursive: true });
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, installed: [], removed: [], error: `Cannot create target directory: ${msg}` };
+    }
+    const files = readdirSync(source).filter(f => f.endsWith('.md'));
+    if (files.length === 0) {
+        return { success: false, installed: [], removed: [], error: 'No command files found' };
+    }
+    // Prune deprecated commands from target by renaming to .deprecated.bak
+    // (lossless — preserves any user edits the operator may have made). If the
+    // backup already exists from a previous upgrade, leave it alone.
+    const removed = [];
+    for (const oldFile of DEPRECATED_COMMANDS) {
+        const oldPath = join(target, oldFile);
+        if (existsSync(oldPath)) {
+            const backupPath = `${oldPath}.deprecated.bak`;
+            try {
+                if (!existsSync(backupPath)) {
+                    renameSync(oldPath, backupPath);
+                }
+                // If the backup already exists, the original was already moved on a
+                // prior install. The file we see now must be a recreation; leave it
+                // alone — the user clearly wants it.
+                removed.push(oldFile.replace('.md', ''));
+            }
+            catch {
+                // Best-effort removal — don't fail the install
+            }
+        }
+    }
+    // Copy current files
+    const installed = [];
+    try {
+        for (const file of files) {
+            copyFileSync(join(source, file), join(target, file));
+            installed.push(file.replace('.md', ''));
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { success: false, installed, removed, error: `Copy failed: ${msg}` };
+    }
+    return { success: true, installed, removed };
+}

package/dist/config.d.ts

@@ -0,0 +1,244 @@
+/**
+ * Runtime configuration for quorum.
+ *
+ * Config file: ~/.config/quorum/config.json
+ *
+ * Semantics:
+ *   - Lazy, cached load. `getConfig()` returns the cached config or reads once.
+ *   - Missing file → defaults in memory (no write). Use `initConfig()` from the
+ *     server entry point to create the file with defaults on first launch.
+ *   - Invalid JSON or schema violations → fall back to defaults, warn on stderr.
+ *   - Partial user configs are deep-merged against defaults via Zod `.default()`.
+ *   - Tool-call arguments still override config (e.g. `reasoningEffort` on a
+ *     single `codex_review` call). Config only sets defaults.
+ */
+import { z } from 'zod';
+export declare const CodexConfigSchema: z.ZodDefault<z.ZodObject<{
+    model: z.ZodDefault<z.ZodString>;
+    reasoningEffort: z.ZodDefault<z.ZodEnum<["high", "xhigh"]>>;
+    serviceTier: z.ZodDefault<z.ZodEnum<["default", "fast", "flex"]>>;
+    /** Consult-specific defaults — separate from review knobs because consult
+     * questions are deeper and warrant more reasoning. Users can override
+     * these to cap cost without affecting review behavior. */
+    consultReasoningEffort: z.ZodDefault<z.ZodEnum<["high", "xhigh"]>>;
+    consultServiceTier: z.ZodDefault<z.ZodEnum<["default", "fast", "flex"]>>;
+    inactivityTimeoutMs: z.ZodDefault<z.ZodObject<{
+        high: z.ZodDefault<z.ZodNumber>;
+        xhigh: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        high: number;
+        xhigh: number;
+    }, {
+        high?: number | undefined;
+        xhigh?: number | undefined;
+    }>>;
+    maxTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxBufferSize: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    reasoningEffort: "high" | "xhigh";
+    serviceTier: "default" | "fast" | "flex";
+    consultReasoningEffort: "high" | "xhigh";
+    consultServiceTier: "default" | "fast" | "flex";
+    inactivityTimeoutMs: {
+        high: number;
+        xhigh: number;
+    };
+    maxTimeoutMs: number;
+    maxBufferSize: number;
+}, {
+    model?: string | undefined;
+    reasoningEffort?: "high" | "xhigh" | undefined;
+    serviceTier?: "default" | "fast" | "flex" | undefined;
+    consultReasoningEffort?: "high" | "xhigh" | undefined;
+    consultServiceTier?: "default" | "fast" | "flex" | undefined;
+    inactivityTimeoutMs?: {
+        high?: number | undefined;
+        xhigh?: number | undefined;
+    } | undefined;
+    maxTimeoutMs?: number | undefined;
+    maxBufferSize?: number | undefined;
+}>>;
+export declare const ClaudeConfigSchema: z.ZodDefault<z.ZodObject<{
+    model: z.ZodDefault<z.ZodString>;
+    inactivityTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxBufferSize: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    inactivityTimeoutMs: number;
+    maxTimeoutMs: number;
+    maxBufferSize: number;
+}, {
+    model?: string | undefined;
+    inactivityTimeoutMs?: number | undefined;
+    maxTimeoutMs?: number | undefined;
+    maxBufferSize?: number | undefined;
+}>>;
+export declare const GeminiConfigSchema: z.ZodDefault<z.ZodObject<{
+    model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    inactivityTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxBufferSize: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    model: string | null;
+    inactivityTimeoutMs: number;
+    maxTimeoutMs: number;
+    maxBufferSize: number;
+}, {
+    model?: string | null | undefined;
+    inactivityTimeoutMs?: number | undefined;
+    maxTimeoutMs?: number | undefined;
+    maxBufferSize?: number | undefined;
+}>>;
+export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
+    codex: z.ZodDefault<z.ZodObject<{
+        model: z.ZodDefault<z.ZodString>;
+        reasoningEffort: z.ZodDefault<z.ZodEnum<["high", "xhigh"]>>;
+        serviceTier: z.ZodDefault<z.ZodEnum<["default", "fast", "flex"]>>;
+        /** Consult-specific defaults — separate from review knobs because consult
+         * questions are deeper and warrant more reasoning. Users can override
+         * these to cap cost without affecting review behavior. */
+        consultReasoningEffort: z.ZodDefault<z.ZodEnum<["high", "xhigh"]>>;
+        consultServiceTier: z.ZodDefault<z.ZodEnum<["default", "fast", "flex"]>>;
+        inactivityTimeoutMs: z.ZodDefault<z.ZodObject<{
+            high: z.ZodDefault<z.ZodNumber>;
+            xhigh: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            high: number;
+            xhigh: number;
+        }, {
+            high?: number | undefined;
+            xhigh?: number | undefined;
+        }>>;
+        maxTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxBufferSize: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        reasoningEffort: "high" | "xhigh";
+        serviceTier: "default" | "fast" | "flex";
+        consultReasoningEffort: "high" | "xhigh";
+        consultServiceTier: "default" | "fast" | "flex";
+        inactivityTimeoutMs: {
+            high: number;
+            xhigh: number;
+        };
+        maxTimeoutMs: number;
+        maxBufferSize: number;
+    }, {
+        model?: string | undefined;
+        reasoningEffort?: "high" | "xhigh" | undefined;
+        serviceTier?: "default" | "fast" | "flex" | undefined;
+        consultReasoningEffort?: "high" | "xhigh" | undefined;
+        consultServiceTier?: "default" | "fast" | "flex" | undefined;
+        inactivityTimeoutMs?: {
+            high?: number | undefined;
+            xhigh?: number | undefined;
+        } | undefined;
+        maxTimeoutMs?: number | undefined;
+        maxBufferSize?: number | undefined;
+    }>>;
+    claude: z.ZodDefault<z.ZodObject<{
+        model: z.ZodDefault<z.ZodString>;
+        inactivityTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxBufferSize: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        inactivityTimeoutMs: number;
+        maxTimeoutMs: number;
+        maxBufferSize: number;
+    }, {
+        model?: string | undefined;
+        inactivityTimeoutMs?: number | undefined;
+        maxTimeoutMs?: number | undefined;
+        maxBufferSize?: number | undefined;
+    }>>;
+    gemini: z.ZodDefault<z.ZodObject<{
+        model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        inactivityTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxBufferSize: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        model: string | null;
+        inactivityTimeoutMs: number;
+        maxTimeoutMs: number;
+        maxBufferSize: number;
+    }, {
+        model?: string | null | undefined;
+        inactivityTimeoutMs?: number | undefined;
+        maxTimeoutMs?: number | undefined;
+        maxBufferSize?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    codex: {
+        model: string;
+        reasoningEffort: "high" | "xhigh";
+        serviceTier: "default" | "fast" | "flex";
+        consultReasoningEffort: "high" | "xhigh";
+        consultServiceTier: "default" | "fast" | "flex";
+        inactivityTimeoutMs: {
+            high: number;
+            xhigh: number;
+        };
+        maxTimeoutMs: number;
+        maxBufferSize: number;
+    };
+    claude: {
+        model: string;
+        inactivityTimeoutMs: number;
+        maxTimeoutMs: number;
+        maxBufferSize: number;
+    };
+    gemini: {
+        model: string | null;
+        inactivityTimeoutMs: number;
+        maxTimeoutMs: number;
+        maxBufferSize: number;
+    };
+}, {
+    codex?: {
+        model?: string | undefined;
+        reasoningEffort?: "high" | "xhigh" | undefined;
+        serviceTier?: "default" | "fast" | "flex" | undefined;
+        consultReasoningEffort?: "high" | "xhigh" | undefined;
+        consultServiceTier?: "default" | "fast" | "flex" | undefined;
+        inactivityTimeoutMs?: {
+            high?: number | undefined;
+            xhigh?: number | undefined;
+        } | undefined;
+        maxTimeoutMs?: number | undefined;
+        maxBufferSize?: number | undefined;
+    } | undefined;
+    claude?: {
+        model?: string | undefined;
+        inactivityTimeoutMs?: number | undefined;
+        maxTimeoutMs?: number | undefined;
+        maxBufferSize?: number | undefined;
+    } | undefined;
+    gemini?: {
+        model?: string | null | undefined;
+        inactivityTimeoutMs?: number | undefined;
+        maxTimeoutMs?: number | undefined;
+        maxBufferSize?: number | undefined;
+    } | undefined;
+}>>;
+export type Config = z.infer<typeof ConfigSchema>;
+export type CodexConfig = z.infer<typeof CodexConfigSchema>;
+export type ClaudeConfig = z.infer<typeof ClaudeConfigSchema>;
+export type GeminiConfig = z.infer<typeof GeminiConfigSchema>;
+export declare const DEFAULT_CONFIG: Config;
+export declare function getConfigPath(): string;
+export declare function getConfig(): Config;
+/**
+ * Create the config file with defaults if it does not exist.
+ * Uses the exclusive `wx` flag for atomic creation — safe against TOCTOU races
+ * when multiple server instances start concurrently.
+ * Refreshes the cached config so subsequent `getConfig()` calls see disk state.
+ */
+export declare function initConfig(): {
+    path: string;
+    created: boolean;
+};
+/** Test-only hook. Redirects the config path and clears the cache. */
+export declare function setConfigPathForTesting(path: string | null): void;