@simonren/quorum 0.7.0

package/dist/adapters/claude.js

@@ -0,0 +1,217 @@
+/**
+ * Claude CLI Adapter
+ *
+ * Implements the ReviewerAdapter interface for Anthropic's Claude CLI.
+ * Spawns a FRESH Claude Code instance with zero session context.
+ * Returns raw text — CC handles interpretation.
+ *
+ * Read-only enforcement (defense-in-depth):
+ *   1. --permission-mode plan     (CLI-level read-only)
+ *   2. --disallowed-tools         (write tools explicitly blocked)
+ *   3. Handoff prompt             (explicit READ-ONLY instruction)
+ */
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { registerAdapter, } from './base.js';
+import { CliExecutor } from '../executor.js';
+import { ClaudeEventDecoder } from '../decoders/index.js';
+import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildConsultPrompt } from '../consult-prompt.js';
+import { getConfig } from '../config.js';
+// Write tools explicitly blocked as defense-in-depth
+const DISALLOWED_TOOLS = 'Edit Write NotebookEdit';
+// =============================================================================
+// CLAUDE ADAPTER
+// =============================================================================
+export class ClaudeAdapter {
+    id = 'claude';
+    getCapabilities() {
+        return {
+            name: 'Claude',
+            description: 'Anthropic Claude (Opus) - fresh instance with clean context, excels at deep analysis across all dimensions',
+            strengths: ['correctness', 'security', 'architecture', 'maintainability'],
+            weaknesses: [],
+            hasFilesystemAccess: true,
+            supportsStructuredOutput: false,
+            maxContextTokens: 200000,
+            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('claude', ['--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: 'Claude 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().claude;
+        const args = [
+            '-p', // Non-interactive, print and exit
+            '--model', cfg.model, // Model from config (default: opus)
+            '--setting-sources', '', // Skip hooks, plugins, CLAUDE.md (preserves OAuth auth; --bare kills keychain)
+            '--permission-mode', 'plan', // Read-only enforcement (layer 1)
+            '--verbose', // Required for stream-json
+            '--output-format', 'stream-json', // Structured streaming events
+            '--no-session-persistence', // Ephemeral — no trace
+            '--disable-slash-commands', // No skills — minimal startup
+            '--disallowed-tools', DISALLOWED_TOOLS, // Block write tools (layer 2)
+            '-', // Read prompt from stdin
+        ];
+        const decoder = new ClaudeEventDecoder();
+        const cliStartTime = Date.now();
+        console.error('[claude] Running Opus review...');
+        decoder.onProgress = (eventType, detail) => {
+            const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
+            const detailStr = detail ? ` — ${detail}` : '';
+            console.error(`[claude] ${eventType}${detailStr} (${elapsed}s)`);
+        };
+        const executor = new CliExecutor({
+            command: 'claude',
+            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(`[claude] ✓ complete (${elapsed}s)`);
+        // Check for errors captured from stream events
+        const decoderError = decoder.getError();
+        if (decoderError) {
+            const combined = result.stderr ? `${decoderError}\n\nCLI stderr: ${result.stderr}` : decoderError;
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        const finalResponse = decoder.getFinalResponse();
+        if (!finalResponse && decoder.hasNoOutput()) {
+            const combined = result.stderr ? `No output from Claude\n\nCLI stderr: ${result.stderr}` : 'No output from Claude';
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        if (!finalResponse) {
+            const combined = result.stderr ? `No result event from Claude\n\nCLI stderr: ${result.stderr}` : 'No result event from Claude';
+            return { stdout: '', stderr: combined, 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: 'Claude CLI not found' },
+                suggestion: 'Install Claude Code: https://docs.anthropic.com/en/docs/claude-code', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Claude 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('rate_limit') || lower.includes('quota')) {
+            return { type: 'rate_limit', message: `Claude rate limit: ${stderr.slice(0, 500)}` };
+        }
+        if (lower.includes('unauthorized') || lower.includes('authentication') || lower.includes('not logged in') || 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 `claude auth` to authenticate';
+            case 'cli_not_found': return 'Install Claude Code: https://docs.anthropic.com/en/docs/claude-code';
+            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: 'Claude 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 ClaudeAdapter());
+export const claudeAdapter = new ClaudeAdapter();

package/dist/adapters/codex.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Codex CLI Adapter
+ *
+ * Implements the ReviewerAdapter interface for OpenAI's Codex CLI.
+ * Returns raw text — no JSON parsing or schema enforcement.
+ * CC handles interpretation of the reviewer's response.
+ */
+import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult, ConsultRequest, ConsultResult } from './base.js';
+export declare class CodexAdapter implements ReviewerAdapter {
+    readonly id = "codex";
+    getCapabilities(): ReviewerCapabilities;
+    isAvailable(): Promise<boolean>;
+    runReview(request: ReviewRequest): Promise<ReviewResult>;
+    private runCli;
+    private handleException;
+    private categorizeError;
+    private getSuggestion;
+    runConsult(request: ConsultRequest): Promise<ConsultResult>;
+}
+export declare const codexAdapter: CodexAdapter;

package/dist/adapters/codex.js

@@ -0,0 +1,227 @@
+/**
+ * Codex CLI Adapter
+ *
+ * Implements the ReviewerAdapter interface for OpenAI's Codex 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 { CodexEventDecoder } from '../decoders/index.js';
+import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildConsultPrompt } from '../consult-prompt.js';
+import { getConfig } from '../config.js';
+// =============================================================================
+// CODEX ADAPTER
+// =============================================================================
+export class CodexAdapter {
+    id = 'codex';
+    getCapabilities() {
+        return {
+            name: 'Codex',
+            description: 'OpenAI Codex - excels at correctness analysis, edge cases, and performance optimization',
+            strengths: ['correctness', 'performance', 'security', 'testing'],
+            weaknesses: ['documentation'],
+            hasFilesystemAccess: true,
+            supportsStructuredOutput: false,
+            maxContextTokens: 128000,
+            reasoningLevels: ['high', 'xhigh'],
+        };
+    }
+    async isAvailable() {
+        return new Promise((resolve) => {
+            let settled = false;
+            const done = (result) => { if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve(result);
+            } };
+            const proc = spawn('codex', ['--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 cfg = getConfig().codex;
+            const result = await this.runCli(prompt, request.workingDir, request.reasoningEffort ?? cfg.reasoningEffort, request.serviceTier);
+            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: 'Codex 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, reasoningEffort, serviceTier) {
+        const cfg = getConfig().codex;
+        const args = [
+            'exec',
+            '--json', // JSONL streaming events
+            '-m', cfg.model,
+            '-c', `model_reasoning_effort=${reasoningEffort}`,
+            '-c', 'model_reasoning_summary_format=experimental',
+            '--full-auto',
+            '--sandbox', 'read-only',
+            '--skip-git-repo-check',
+            '-C', workingDir,
+            '-', // Read prompt from stdin
+        ];
+        // Caller-supplied serviceTier overrides config. Explicit 'default' is an
+        // opt-out and emits no flag (uses Codex API default).
+        const effectiveTier = serviceTier ?? cfg.serviceTier;
+        if (effectiveTier !== 'default') {
+            args.push('-c', `service_tier=${effectiveTier}`);
+        }
+        const decoder = new CodexEventDecoder();
+        const cliStartTime = Date.now();
+        const tierLabel = effectiveTier !== 'default' ? ` [${effectiveTier}]` : '';
+        console.error(`[codex] Running with ${reasoningEffort} reasoning${tierLabel}...`);
+        decoder.onProgress = (eventType, detail) => {
+            const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
+            const detailStr = detail ? ` — ${detail}` : '';
+            console.error(`[codex] ${eventType}${detailStr} (${elapsed}s)`);
+        };
+        const executor = new CliExecutor({
+            command: 'codex',
+            args,
+            cwd: workingDir,
+            stdin: prompt,
+            inactivityTimeoutMs: cfg.inactivityTimeoutMs[reasoningEffort] ?? cfg.inactivityTimeoutMs.high,
+            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(`[codex] ✓ complete (${elapsed}s)`);
+        // Check for errors captured from JSONL events
+        const decoderError = decoder.getError();
+        if (decoderError) {
+            const combined = result.stderr ? `${decoderError}\n\nCLI stderr: ${result.stderr}` : decoderError;
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        const finalResponse = decoder.getFinalResponse();
+        if (!finalResponse && decoder.hasNoOutput()) {
+            const combined = result.stderr ? `No output from Codex\n\nCLI stderr: ${result.stderr}` : 'No output from Codex';
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        if (!finalResponse) {
+            const combined = result.stderr ? `No result event from Codex\n\nCLI stderr: ${result.stderr}` : 'No result event from Codex';
+            return { stdout: '', stderr: combined, 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: 'Codex CLI not found' },
+                suggestion: 'Install with: npm install -g @openai/codex-cli', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Codex 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('rate_limit')) {
+            return { type: 'rate_limit', message: `Codex rate limit: ${stderr.slice(0, 500)}` };
+        }
+        if (lower.includes('unauthorized') || lower.includes('authentication') || stderr.includes('401') || stderr.includes('403')) {
+            return { type: 'auth_error', message: `Authentication failed: ${stderr.slice(0, 500)}`, details: { stderr } };
+        }
+        if (lower.includes('invalid_json_schema') || lower.includes('invalid_request_error')) {
+            return { type: 'cli_error', message: `API error: ${stderr.slice(0, 500)}` };
+        }
+        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 `codex login` to authenticate';
+            case 'cli_not_found': return 'Install with: npm install -g @openai/codex-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);
+            // Consult-specific defaults live in config (Zod defaults to xhigh + fast).
+            // Request value > config value > Zod default. Users who want to cap cost
+            // can set codex.consultServiceTier: "flex" without touching review.
+            const cfg = getConfig().codex;
+            const reasoningEffort = request.reasoningEffort ?? cfg.consultReasoningEffort;
+            const serviceTier = request.serviceTier ?? cfg.consultServiceTier;
+            const result = await this.runCli(prompt, request.workingDir, reasoningEffort, serviceTier);
+            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: 'Codex 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 CodexAdapter());
+export const codexAdapter = new CodexAdapter();

package/dist/adapters/gemini.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult, ConsultRequest, ConsultResult } from './base.js';
+export declare class GeminiAdapter implements ReviewerAdapter {
+    readonly id = "gemini";
+    getCapabilities(): ReviewerCapabilities;
+    isAvailable(): Promise<boolean>;
+    runReview(request: ReviewRequest): Promise<ReviewResult>;
+    private runCli;
+    private handleException;
+    private categorizeError;
+    private getSuggestion;
+    runConsult(request: ConsultRequest): Promise<ConsultResult>;
+}
+export declare const geminiAdapter: GeminiAdapter;