@simonren/quorum 0.7.0

package/dist/adapters/gemini.js

@@ -0,0 +1,197 @@
+/**
+ * Gemini CLI Adapter
+ *
+ * Implements the ReviewerAdapter interface for Google's Gemini CLI.
+ * Returns raw text — no JSON parsing or schema enforcement.
+ * CC handles interpretation of the reviewer's response.
+ */
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { registerAdapter, } from './base.js';
+import { CliExecutor } from '../executor.js';
+import { GeminiEventDecoder } from '../decoders/index.js';
+import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildConsultPrompt } from '../consult-prompt.js';
+import { getConfig } from '../config.js';
+// =============================================================================
+// GEMINI ADAPTER
+// =============================================================================
+export class GeminiAdapter {
+    id = 'gemini';
+    getCapabilities() {
+        return {
+            name: 'Gemini',
+            description: 'Google Gemini - excels at architecture analysis, design patterns, and large codebase understanding',
+            strengths: ['architecture', 'maintainability', 'scalability', 'documentation'],
+            weaknesses: ['security'],
+            hasFilesystemAccess: true,
+            supportsStructuredOutput: false,
+            maxContextTokens: 2000000,
+            reasoningLevels: undefined,
+        };
+    }
+    async isAvailable() {
+        return new Promise((resolve) => {
+            let settled = false;
+            const done = (result) => { if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(result);
+            } };
+            const proc = spawn('gemini', ['--version'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            proc.on('close', (code) => done(code === 0));
+            proc.on('error', () => done(false));
+            const timer = setTimeout(() => { proc.kill(); done(false); }, 5000);
+        });
+    }
+    async runReview(request) {
+        const startTime = Date.now();
+        if (!existsSync(request.workingDir)) {
+            return {
+                success: false,
+                error: { type: 'cli_error', message: `Working directory does not exist: ${request.workingDir}` },
+                suggestion: 'Check that the working directory path is correct',
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        try {
+            const handoff = buildSimpleHandoff(request.workingDir, request.ccOutput, request.analyzedFiles, request.focusAreas, request.customPrompt);
+            const prompt = request.reviewMode === 'adversarial'
+                ? buildAdversarialHandoffPrompt({ handoff })
+                : buildHandoffPrompt({ handoff, role: selectRole(request.focusAreas) });
+            const result = await this.runCli(prompt, request.workingDir);
+            if (result.exitCode !== 0) {
+                const error = this.categorizeError(result.stderr);
+                return { success: false, error, suggestion: this.getSuggestion(error), executionTimeMs: Date.now() - startTime };
+            }
+            if (!result.stdout.trim()) {
+                return {
+                    success: false,
+                    error: { type: 'cli_error', message: 'Gemini returned empty response' },
+                    suggestion: 'Try again or use /multi-review instead',
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
+        }
+        catch (error) {
+            return this.handleException(error, startTime);
+        }
+    }
+    async runCli(prompt, workingDir) {
+        const cfg = getConfig().gemini;
+        const args = [
+            '--sandbox',
+            '--approval-mode', 'plan',
+            '--output-format', 'stream-json',
+            '--include-directories', workingDir,
+            '-p', '',
+        ];
+        if (cfg.model) {
+            args.push('--model', cfg.model);
+        }
+        const decoder = new GeminiEventDecoder();
+        const cliStartTime = Date.now();
+        console.error('[gemini] Running...');
+        decoder.onProgress = (eventType, detail) => {
+            const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
+            const detailStr = detail ? ` — ${detail}` : '';
+            console.error(`[gemini] ${eventType}${detailStr} (${elapsed}s)`);
+        };
+        const executor = new CliExecutor({
+            command: 'gemini',
+            args,
+            cwd: workingDir,
+            stdin: prompt,
+            inactivityTimeoutMs: cfg.inactivityTimeoutMs,
+            maxTimeoutMs: cfg.maxTimeoutMs,
+            maxBufferSize: cfg.maxBufferSize,
+            onLine: (line) => {
+                decoder.processLine(line);
+            },
+        });
+        const result = await executor.run();
+        const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
+        console.error(`[gemini] ✓ complete (${elapsed}s)`);
+        const finalResponse = decoder.getFinalResponse();
+        if (!finalResponse && result.exitCode === 0) {
+            return { stdout: '', stderr: 'Gemini produced no output — review may have failed silently', exitCode: 1, truncated: false };
+        }
+        return {
+            stdout: finalResponse || '',
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+            truncated: result.truncated,
+        };
+    }
+    handleException(error, startTime) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            return { success: false, error: { type: 'cli_not_found', message: 'Gemini CLI not found' },
+                suggestion: 'Install with: npm install -g @google/gemini-cli', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Gemini timed out — no events received' },
+                suggestion: 'Try a smaller scope or use /multi-review', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'MAX_TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Task exceeded 60 minute maximum' },
+                suggestion: 'Try a smaller scope', executionTimeMs: Date.now() - startTime };
+        }
+        return { success: false, error: { type: 'cli_error', message: err.message }, executionTimeMs: Date.now() - startTime };
+    }
+    categorizeError(stderr) {
+        const lower = stderr.toLowerCase();
+        if (lower.includes('rate limit') || lower.includes('quota')) {
+            return { type: 'rate_limit', message: `Rate limit or quota exceeded: ${stderr.slice(0, 500)}` };
+        }
+        if (lower.includes('unauthorized') || lower.includes('authentication') || lower.includes('api key') || stderr.includes('401') || stderr.includes('403')) {
+            return { type: 'auth_error', message: `Authentication failed: ${stderr.slice(0, 500)}`, details: { stderr } };
+        }
+        return { type: 'cli_error', message: stderr.slice(0, 500) || 'Unknown error' };
+    }
+    getSuggestion(error) {
+        switch (error.type) {
+            case 'rate_limit': return 'Wait and retry, or use /multi-review instead';
+            case 'auth_error': return 'Run `gemini` and follow auth prompts, or set GEMINI_API_KEY';
+            case 'cli_not_found': return 'Install with: npm install -g @google/gemini-cli';
+            default: return 'Check the error message and try again';
+        }
+    }
+    async runConsult(request) {
+        const startTime = Date.now();
+        if (!existsSync(request.workingDir)) {
+            return {
+                success: false,
+                error: { type: 'cli_error', message: `Working directory does not exist: ${request.workingDir}` },
+                suggestion: 'Check that the working directory path is correct',
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        try {
+            const prompt = buildConsultPrompt(request);
+            const result = await this.runCli(prompt, request.workingDir);
+            if (result.exitCode !== 0) {
+                const error = this.categorizeError(result.stderr);
+                return { success: false, error, suggestion: this.getSuggestion(error), executionTimeMs: Date.now() - startTime };
+            }
+            if (!result.stdout.trim()) {
+                return {
+                    success: false,
+                    error: { type: 'cli_error', message: 'Gemini returned empty response' },
+                    suggestion: 'Try again or use /multi-review instead',
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
+        }
+        catch (error) {
+            return this.handleException(error, startTime);
+        }
+    }
+}
+// Register the adapter
+registerAdapter(new GeminiAdapter());
+export const geminiAdapter = new GeminiAdapter();

package/dist/adapters/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Adapter Registry
+ *
+ * Exports all registered adapters and utility functions.
+ */
+import './codex.js';
+import './gemini.js';
+import './claude.js';
+export * from './base.js';
+export { codexAdapter } from './codex.js';
+export { geminiAdapter } from './gemini.js';
+export { claudeAdapter } from './claude.js';

package/dist/adapters/index.js

@@ -0,0 +1,15 @@
+/**
+ * Adapter Registry
+ *
+ * Exports all registered adapters and utility functions.
+ */
+// Import adapters to register them
+import './codex.js';
+import './gemini.js';
+import './claude.js';
+// Re-export everything from base
+export * from './base.js';
+// Export specific adapters
+export { codexAdapter } from './codex.js';
+export { geminiAdapter } from './gemini.js';
+export { claudeAdapter } from './claude.js';

package/dist/cli/check.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CLI Availability Checker
+ */
+import { CliStatus, CliType } from '../types.js';
+/**
+ * Check availability of all supported CLIs
+ */
+export declare function checkCliAvailability(): Promise<CliStatus>;
+/**
+ * Check if a specific CLI is available
+ */
+export declare function isCliAvailable(cli: CliType): Promise<boolean>;
+/**
+ * Get CLI version (for debugging)
+ */
+export declare function getCliVersion(cli: CliType): Promise<string | null>;
+/**
+ * Log CLI availability status (for startup debugging)
+ */
+export declare function logCliStatus(): Promise<void>;

package/dist/cli/check.js

@@ -0,0 +1,78 @@
+/**
+ * CLI Availability Checker
+ */
+import { spawn } from 'child_process';
+/**
+ * Check if a command exists on the system
+ */
+async function commandExists(command) {
+    return new Promise((resolve) => {
+        const proc = spawn('which', [command], {
+            stdio: ['ignore', 'pipe', 'ignore']
+        });
+        proc.on('close', (code) => {
+            resolve(code === 0);
+        });
+        proc.on('error', () => {
+            resolve(false);
+        });
+    });
+}
+/**
+ * Check availability of all supported CLIs
+ */
+export async function checkCliAvailability() {
+    const [codex, gemini, claude] = await Promise.all([
+        commandExists('codex'),
+        commandExists('gemini'),
+        commandExists('claude')
+    ]);
+    return { codex, gemini, claude };
+}
+/**
+ * Check if a specific CLI is available
+ */
+export async function isCliAvailable(cli) {
+    return commandExists(cli);
+}
+/**
+ * Get CLI version (for debugging)
+ */
+export async function getCliVersion(cli) {
+    return new Promise((resolve) => {
+        const proc = spawn(cli, ['--version'], {
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0 && stdout) {
+                resolve(stdout.trim().split('\n')[0]);
+            }
+            else {
+                resolve(null);
+            }
+        });
+        proc.on('error', () => {
+            resolve(null);
+        });
+    });
+}
+/**
+ * Log CLI availability status (for startup debugging)
+ */
+export async function logCliStatus() {
+    const status = await checkCliAvailability();
+    console.error('AI Reviewer CLI Status:');
+    console.error(`  - Codex: ${status.codex ? '✓ Available' : '✗ Not found'}`);
+    console.error(`  - Gemini: ${status.gemini ? '✓ Available' : '✗ Not found'}`);
+    console.error(`  - Claude: ${status.claude ? '✓ Available' : '✗ Not found'}`);
+    if (!status.codex && !status.gemini && !status.claude) {
+        console.error('\nWarning: No AI CLIs found. Install at least one:');
+        console.error('  npm install -g @openai/codex-cli');
+        console.error('  npm install -g @google/gemini-cli');
+        console.error('  Claude Code: https://docs.anthropic.com/en/docs/claude-code');
+    }
+}

package/dist/cli/codex.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Codex CLI Wrapper
+ *
+ * Uses OpenAI's Codex CLI in non-interactive mode (codex exec)
+ * Reference: https://developers.openai.com/codex/cli/reference/
+ */
+import { FeedbackRequest, FeedbackResult } from '../types.js';
+/**
+ * Run Codex CLI with the given request
+ */
+export declare function runCodexReview(request: FeedbackRequest): Promise<FeedbackResult>;

package/dist/cli/codex.js

@@ -0,0 +1,255 @@
+/**
+ * Codex CLI Wrapper
+ *
+ * Uses OpenAI's Codex CLI in non-interactive mode (codex exec)
+ * Reference: https://developers.openai.com/codex/cli/reference/
+ */
+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 Codex CLI with the given request
+ */
+export async function runCodexReview(request) {
+    // Validate workingDir exists before running
+    if (!existsSync(request.workingDir)) {
+        return {
+            success: false,
+            error: {
+                type: 'cli_error',
+                cli: 'codex',
+                exitCode: -1,
+                stderr: `Working directory does not exist: ${request.workingDir}`
+            },
+            suggestion: 'Check that the working directory path is correct',
+            model: 'codex'
+        };
+    }
+    return runWithRetry(request, 0);
+}
+/**
+ * Run Codex 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('codex');
+        // Combine developer instructions with the prompt for Codex
+        // Codex exec doesn't have a separate system instruction flag
+        const fullPrompt = `${developerInstructions}\n\n---\n\n${basePrompt}`;
+        // Run the CLI
+        const result = await runCodexCli(fullPrompt, request.workingDir, request.reasoningEffort || 'high');
+        // Check for CLI errors
+        if (result.exitCode !== 0) {
+            // Check for specific error patterns in stderr
+            if (result.stderr.toLowerCase().includes('rate limit')) {
+                return {
+                    success: false,
+                    error: {
+                        type: 'rate_limit',
+                        cli: 'codex',
+                        retryAfterMs: parseRetryAfter(result.stderr)
+                    },
+                    suggestion: 'Wait and retry, or use /gemini-review instead',
+                    model: 'codex'
+                };
+            }
+            if (result.stderr.toLowerCase().includes('unauthorized') ||
+                result.stderr.toLowerCase().includes('authentication') ||
+                result.stderr.includes('401') ||
+                result.stderr.includes('403')) {
+                return {
+                    success: false,
+                    error: {
+                        type: 'auth_error',
+                        cli: 'codex',
+                        message: result.stderr
+                    },
+                    suggestion: 'Run `codex login` to authenticate',
+                    model: 'codex'
+                };
+            }
+            return {
+                success: false,
+                error: {
+                    type: 'cli_error',
+                    cli: 'codex',
+                    exitCode: result.exitCode,
+                    stderr: result.stderr
+                },
+                model: 'codex'
+            };
+        }
+        // Check for buffer truncation warning
+        if (result.truncated) {
+            return {
+                success: false,
+                error: {
+                    type: 'cli_error',
+                    cli: 'codex',
+                    exitCode: 0,
+                    stderr: 'Output exceeded maximum buffer size (1MB) and was truncated'
+                },
+                suggestion: 'Try reviewing a smaller scope with --focus',
+                model: 'codex'
+            };
+        }
+        // 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: 'codex',
+                    rawOutput: result.stdout
+                },
+                suggestion: getSuggestion({ type: 'invalid_response', cli: 'codex', rawOutput: result.stdout }),
+                model: 'codex'
+            };
+        }
+        return {
+            success: true,
+            feedback: result.stdout,
+            model: 'codex'
+        };
+    }
+    catch (error) {
+        const err = error;
+        // Handle CLI not found (ENOENT for the codex binary itself)
+        if (err.code === 'ENOENT') {
+            return {
+                success: false,
+                error: createCliNotFoundError('codex'),
+                suggestion: getSuggestion(createCliNotFoundError('codex')),
+                model: 'codex'
+            };
+        }
+        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('codex', 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: 'codex'
+            };
+        }
+        // Generic error
+        return {
+            success: false,
+            error: {
+                type: 'cli_error',
+                cli: 'codex',
+                exitCode: -1,
+                stderr: err.message
+            },
+            model: 'codex'
+        };
+    }
+}
+/**
+ * Execute the Codex CLI in non-interactive mode
+ *
+ * Uses: codex exec -m gpt-5.2-codex -c model_reasoning_effort="high|xhigh" \
+ *   -c model_reasoning_summary_format=experimental \
+ *   --dangerously-bypass-approvals-and-sandbox "<prompt>"
+ */
+function runCodexCli(prompt, workingDir, reasoningEffort = 'high') {
+    return new Promise((resolve, reject) => {
+        // Build CLI arguments for non-interactive execution
+        const args = [
+            'exec',
+            '-m', 'gpt-5.2-codex',
+            '-c', `model_reasoning_effort=${reasoningEffort}`,
+            '-c', 'model_reasoning_summary_format=experimental',
+            '--dangerously-bypass-approvals-and-sandbox',
+            '--skip-git-repo-check',
+            '-C', workingDir,
+            prompt
+        ];
+        const proc = spawn('codex', 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/cli/gemini.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { FeedbackRequest, FeedbackResult } from '../types.js';
+/**
+ * Run Gemini CLI with the given request
+ */
+export declare function runGeminiReview(request: FeedbackRequest): Promise<FeedbackResult>;