cc-reviewer 2.0.0 → 3.0.0

package/dist/adapters/gemini.js

@@ -2,22 +2,20 @@
  * Gemini CLI Adapter
  *
  * Implements the ReviewerAdapter interface for Google's Gemini CLI.
- * Specializes in architecture, design patterns, and large-context analysis.
+ * 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 { parseReviewOutput, parseLegacyMarkdownOutput, parsePeerOutput, isSubstantiveReview } from '../schema.js';
 import { CliExecutor } from '../executor.js';
 import { GeminiEventDecoder } from '../decoders/index.js';
-import { buildSimpleHandoff, buildHandoffPrompt, buildPeerPrompt, selectRole, } from '../handoff.js';
+import { buildSimpleHandoff, buildHandoffPrompt, selectRole, } from '../handoff.js';
 // =============================================================================
 // CONFIGURATION
 // =============================================================================
-const COLD_START_TIMEOUT_MS = 300_000; // 5 min — waiting for first JSONL event
-const STREAMING_TIMEOUT_MS = 90_000; // 90s — if events stop mid-stream
+const INACTIVITY_TIMEOUT_MS = 300_000; // 5 min — covers reasoning gaps between tool use
 const MAX_TIMEOUT_MS = 3_600_000; // 60 min absolute max
-const MAX_RETRIES = 2;
 const MAX_BUFFER_SIZE = 1024 * 1024; // 1MB max buffer
 // =============================================================================
 // GEMINI ADAPTER
@@ -31,9 +29,9 @@ export class GeminiAdapter {
             strengths: ['architecture', 'maintainability', 'scalability', 'documentation'],
             weaknesses: ['security'],
             hasFilesystemAccess: true,
-            supportsStructuredOutput: true,
-            maxContextTokens: 2000000, // Gemini has very large context
-            reasoningLevels: undefined, // Gemini doesn't have configurable reasoning
+            supportsStructuredOutput: false,
+            maxContextTokens: 2000000,
+            reasoningLevels: undefined,
         };
     }
     async isAvailable() {
@@ -41,273 +39,54 @@ export class GeminiAdapter {
             const proc = spawn('gemini', ['--version'], {
                 stdio: ['ignore', 'pipe', 'pipe'],
             });
-            proc.on('close', (code) => {
-                resolve(code === 0);
-            });
-            proc.on('error', () => {
-                resolve(false);
-            });
-            // Timeout after 5s
-            setTimeout(() => {
-                proc.kill();
-                resolve(false);
-            }, 5000);
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+            setTimeout(() => { proc.kill(); resolve(false); }, 5000);
         });
     }
     async runReview(request) {
         const startTime = Date.now();
-        // Validate working directory
         if (!existsSync(request.workingDir)) {
             return {
                 success: false,
-                error: {
-                    type: 'cli_error',
-                    message: `Working directory does not exist: ${request.workingDir}`,
-                },
+                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,
             };
         }
-        return this.runWithRetry(request, 0, startTime);
-    }
-    async runWithRetry(request, attempt, startTime, previousError, previousOutput) {
         try {
-            // Build the prompt using handoff protocol
             const handoff = buildSimpleHandoff(request.workingDir, request.ccOutput, request.analyzedFiles, request.focusAreas, request.customPrompt);
-            // Select role based on focus areas (Gemini defaults to architect)
             const role = selectRole(request.focusAreas);
-            // Build prompt with retry context if needed
-            let prompt = buildHandoffPrompt({
-                handoff,
-                role,
-                outputFormat: 'json',
-            });
-            // Add retry context if this is a retry attempt
-            if (attempt > 0) {
-                prompt += `\n\n---\n\n# RETRY ATTEMPT ${attempt + 1}\n\n` +
-                    `Previous output had issues: ${previousError}\n` +
-                    `Please fix these issues and provide valid JSON output.\n` +
-                    (previousOutput ? `\nPrevious output (for reference):\n${previousOutput.slice(0, 500)}...` : '');
-            }
-            // Run the CLI
-            const result = await this.runCli(prompt, request.workingDir);
-            // Handle CLI errors
-            if (result.exitCode !== 0) {
-                const error = this.categorizeError(result.stderr);
-                return {
-                    success: false,
-                    error,
-                    suggestion: this.getSuggestion(error),
-                    rawOutput: result.stderr,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            // Handle buffer truncation
-            if (result.truncated) {
-                return {
-                    success: false,
-                    error: {
-                        type: 'cli_error',
-                        message: 'Output exceeded maximum buffer size (1MB) and was truncated',
-                    },
-                    suggestion: 'Try reviewing a smaller scope with --focus',
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            // Parse the output
-            let output = parseReviewOutput(result.stdout);
-            let usedFallback = false;
-            // If JSON parsing fails, try legacy markdown
-            if (!output) {
-                output = parseLegacyMarkdownOutput(result.stdout, 'gemini');
-                usedFallback = true;
-            }
-            // If no valid output, retry or fail
-            if (!output) {
-                if (attempt < MAX_RETRIES) {
-                    return this.runWithRetry(request, attempt + 1, startTime, 'Output did not match expected JSON schema', result.stdout);
-                }
-                return {
-                    success: false,
-                    error: {
-                        type: 'parse_error',
-                        message: 'Failed to parse reviewer output after retries',
-                        details: { rawOutput: result.stdout.slice(0, 1000) },
-                    },
-                    suggestion: 'The model may not be following the output format. Try a different focus area.',
-                    rawOutput: result.stdout,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            // Check for empty/minimal output — centralized substance check
-            if (!isSubstantiveReview(output)) {
-                if (attempt < MAX_RETRIES) {
-                    console.error(`[gemini] Received empty output, retrying...`);
-                    return this.runWithRetry(request, attempt + 1, startTime, usedFallback
-                        ? 'Received markdown output instead of JSON. Please provide valid JSON output.'
-                        : 'Output contained no substantive review content. Please provide findings or analysis.', result.stdout);
-                }
-                return {
-                    success: false,
-                    error: {
-                        type: 'parse_error',
-                        message: 'Reviewer returned empty output after retries',
-                        details: { rawOutput: result.stdout.slice(0, 1000) },
-                    },
-                    suggestion: 'The model returned no substantive review. Try a different focus area.',
-                    rawOutput: result.stdout,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            return {
-                success: true,
-                output,
-                rawOutput: result.stdout,
-                executionTimeMs: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            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: 'No output for 10 minutes - process may be hung',
-                    },
-                    suggestion: 'Try a smaller scope or use --focus',
-                    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,
-            };
-        }
-    }
-    async runPeerRequest(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,
-            };
-        }
-        return this.runPeerWithRetry(request, 0, startTime);
-    }
-    async runPeerWithRetry(request, attempt, startTime, previousError, previousOutput) {
-        try {
-            let prompt = buildPeerPrompt({
-                workingDir: request.workingDir,
-                prompt: request.prompt,
-                taskType: request.taskType,
-                relevantFiles: request.relevantFiles,
-                context: request.context,
-                focusAreas: request.focusAreas,
-                customInstructions: request.customPrompt,
-                outputFormat: 'json',
-            });
-            if (attempt > 0) {
-                prompt += `\n\n---\n\n# RETRY ATTEMPT ${attempt + 1}\n\n` +
-                    `Previous output had issues: ${previousError}\n` +
-                    `Please fix these issues and provide valid JSON output.\n` +
-                    (previousOutput ? `\nPrevious output (for reference):\n${previousOutput.slice(0, 500)}...` : '');
-            }
+            const prompt = buildHandoffPrompt({ handoff, role });
             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),
-                    rawOutput: result.stderr,
-                    executionTimeMs: Date.now() - startTime,
-                };
-            }
-            if (result.truncated) {
-                return {
-                    success: false,
-                    error: { type: 'cli_error', message: 'Output exceeded maximum buffer size (1MB)' },
-                    suggestion: 'Try a more focused request',
-                    executionTimeMs: Date.now() - startTime,
-                };
+                return { success: false, error, suggestion: this.getSuggestion(error), executionTimeMs: Date.now() - startTime };
             }
-            const output = parsePeerOutput(result.stdout);
-            if (!output) {
-                if (attempt < MAX_RETRIES) {
-                    return this.runPeerWithRetry(request, attempt + 1, startTime, 'Output did not match expected JSON schema', result.stdout);
-                }
+            if (!result.stdout.trim()) {
                 return {
                     success: false,
-                    error: { type: 'parse_error', message: 'Failed to parse peer output after retries',
-                        details: { rawOutput: result.stdout.slice(0, 1000) } },
-                    suggestion: 'The model may not be following the output format.',
-                    rawOutput: result.stdout,
+                    error: { type: 'cli_error', message: 'Gemini returned empty response' },
+                    suggestion: 'Try again or use /codex-review instead',
                     executionTimeMs: Date.now() - startTime,
                 };
             }
-            return {
-                success: true, output,
-                rawOutput: result.stdout,
-                executionTimeMs: Date.now() - startTime,
-            };
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
         }
         catch (error) {
-            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: 'No output for 10 minutes' },
-                    suggestion: 'Try a simpler request', 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 };
+            return this.handleException(error, startTime);
         }
     }
     async runCli(prompt, workingDir) {
         const args = [
             '--yolo',
-            '--output-format', 'stream-json', // JSONL streaming events (was: json)
+            '--output-format', 'stream-json',
             '--include-directories', workingDir,
-            '-p', '', // Headless mode; prompt via stdin
+            '-p', '',
         ];
         const decoder = new GeminiEventDecoder();
         const cliStartTime = Date.now();
-        let firstEventReceived = false;
-        console.error('[gemini] Running review...');
+        console.error('[gemini] Running...');
         decoder.onProgress = (eventType, detail) => {
             const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
             const detailStr = detail ? ` — ${detail}` : '';
@@ -318,15 +97,11 @@ export class GeminiAdapter {
             args,
             cwd: workingDir,
             stdin: prompt,
-            inactivityTimeoutMs: COLD_START_TIMEOUT_MS,
+            inactivityTimeoutMs: INACTIVITY_TIMEOUT_MS,
             maxTimeoutMs: MAX_TIMEOUT_MS,
             maxBufferSize: MAX_BUFFER_SIZE,
             onLine: (line) => {
                 decoder.processLine(line);
-                if (!firstEventReceived) {
-                    firstEventReceived = true;
-                    executor.setInactivityTimeout(STREAMING_TIMEOUT_MS);
-                }
             },
         });
         const result = await executor.run();
@@ -340,46 +115,41 @@ export class GeminiAdapter {
             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 /codex-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',
-                details: { retryAfterMs: this.parseRetryAfter(stderr) },
-            };
+            return { type: 'rate_limit', message: 'Rate limit or quota exceeded' };
         }
-        if (lower.includes('unauthorized') || lower.includes('authentication') ||
-            lower.includes('api key') || stderr.includes('401') || stderr.includes('403')) {
-            return {
-                type: 'auth_error',
-                message: 'Authentication failed',
-                details: { stderr },
-            };
+        if (lower.includes('unauthorized') || lower.includes('authentication') || lower.includes('api key') || stderr.includes('401') || stderr.includes('403')) {
+            return { type: 'auth_error', message: 'Authentication failed', details: { stderr } };
         }
-        return {
-            type: 'cli_error',
-            message: stderr || 'Unknown error',
-        };
+        return { type: 'cli_error', message: stderr || 'Unknown error' };
     }
     getSuggestion(error) {
         switch (error.type) {
-            case 'rate_limit':
-                return 'Wait and retry, or use /codex 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';
+            case 'rate_limit': return 'Wait and retry, or use /codex-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';
         }
     }
-    parseRetryAfter(errorMessage) {
-        const match = errorMessage.match(/retry[- ]?after[:\s]+(\d+)/i);
-        return match ? parseInt(match[1]) * 1000 : undefined;
-    }
 }
 // Register the adapter
 registerAdapter(new GeminiAdapter());
-// Export for direct use
 export const geminiAdapter = new GeminiAdapter();

package/dist/commands.d.ts

@@ -1,13 +1,12 @@
 /**
  * Shared module for slash command installation
  *
- * Used by both:
- * - setup.ts (manual CLI tool: npx cc-reviewer-setup)
- * - index.ts (auto-install on MCP server startup)
+ * Used by index.ts (auto-install on MCP server startup and `update` subcommand)
  */
 export interface InstallResult {
     success: boolean;
     installed: string[];
+    removed: string[];
     error?: string;
 }
 /**

package/dist/commands.js

@@ -1,16 +1,24 @@
 /**
  * Shared module for slash command installation
  *
- * Used by both:
- * - setup.ts (manual CLI tool: npx cc-reviewer-setup)
- * - index.ts (auto-install on MCP server startup)
+ * Used by index.ts (auto-install on MCP server startup and `update` subcommand)
  */
-import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync } from 'fs';
+import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, unlinkSync } 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',
+];
 /**
  * Get source and target paths for command files
  */
@@ -29,13 +37,13 @@ export function installCommands() {
     const { source, target } = getCommandPaths();
     // Check source exists
     if (!existsSync(source)) {
-        return { success: false, installed: [], error: 'Commands directory not found' };
+        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: [], error: `${target} exists but is not a directory` };
+                return { success: false, installed: [], removed: [], error: `${target} exists but is not a directory` };
             }
         }
         else {
@@ -44,13 +52,27 @@ export function installCommands() {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return { success: false, installed: [], error: `Cannot create target directory: ${msg}` };
+        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: [], error: 'No command files found' };
+        return { success: false, installed: [], removed: [], error: 'No command files found' };
     }
-    // Copy files, handle errors
+    // Prune deprecated commands from target
+    const removed = [];
+    for (const oldFile of DEPRECATED_COMMANDS) {
+        const oldPath = join(target, oldFile);
+        if (existsSync(oldPath)) {
+            try {
+                unlinkSync(oldPath);
+                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) {
@@ -60,7 +82,7 @@ export function installCommands() {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return { success: false, installed, error: `Copy failed: ${msg}` };
+        return { success: false, installed, removed, error: `Copy failed: ${msg}` };
     }
-    return { success: true, installed };
+    return { success: true, installed, removed };
 }

package/dist/decoders/codex.d.ts

@@ -42,6 +42,8 @@ export declare class CodexEventDecoder {
     onProgress?: (eventType: string, detail?: string) => void;
     private _finalResponse;
     private _usage;
+    private _error;
+    private _eventCount;
     /**
      * Parse a single JSONL line. Silently skips malformed or empty input.
      */
@@ -56,5 +58,14 @@ export declare class CodexEventDecoder {
      * `null` if no such event has been seen.
      */
     getUsage(): CodexEvent['usage'] | null;
+    /**
+     * Returns the error message from `error` or `turn.failed` events, or `null`.
+     */
+    getError(): string | null;
+    /**
+     * Returns true if events were received but no agent_message was produced.
+     * Combined with a fast exit, this indicates rate limiting or instant rejection.
+     */
+    hasNoOutput(): boolean;
     private _handleEvent;
 }

package/dist/decoders/codex.js

@@ -25,6 +25,10 @@ export class CodexEventDecoder {
     _finalResponse = null;
     // Token usage from the most recently seen turn.completed
     _usage = null;
+    // Error message from error/turn.failed events
+    _error = null;
+    // Count of events received (0 = possible rate limit / instant rejection)
+    _eventCount = 0;
     // =============================================================================
     // PUBLIC API
     // =============================================================================
@@ -63,10 +67,24 @@ export class CodexEventDecoder {
     getUsage() {
         return this._usage;
     }
+    /**
+     * Returns the error message from `error` or `turn.failed` events, or `null`.
+     */
+    getError() {
+        return this._error;
+    }
+    /**
+     * Returns true if events were received but no agent_message was produced.
+     * Combined with a fast exit, this indicates rate limiting or instant rejection.
+     */
+    hasNoOutput() {
+        return this._eventCount > 0 && this._finalResponse === null;
+    }
     // =============================================================================
     // PRIVATE HELPERS
     // =============================================================================
     _handleEvent(event) {
+        this._eventCount++;
         // Track the last agent_message text
         if (event.type === 'item.completed' &&
             event.item?.type === 'agent_message' &&
@@ -77,6 +95,17 @@ export class CodexEventDecoder {
         if (event.type === 'turn.completed' && event.usage != null) {
             this._usage = event.usage;
         }
+        // Capture errors from error/turn.failed events
+        if (event.type === 'error') {
+            this._error = event.message || 'Unknown error from Codex';
+        }
+        if (event.type === 'turn.failed') {
+            this._error = event.error?.message || 'Turn failed';
+        }
+        // Capture error items (e.g. model errors reported as item.completed with type=error)
+        if (event.type === 'item.completed' && event.item?.type === 'error') {
+            this._error = event.item.message || event.item.text || 'Model error';
+        }
         // Notify caller
         this.onProgress?.(event.type, describeEvent(event));
     }

package/dist/handoff.d.ts

@@ -214,10 +214,10 @@ export declare function selectRole(focusAreas?: FocusArea[]): ReviewerRole;
 export interface PromptOptions {
     handoff: Handoff;
     role?: ReviewerRole;
-    outputFormat: 'json' | 'markdown' | 'schema-enforced';
 }
 /**
- * Build the review prompt using minimal, targeted context
+ * Build the review prompt using minimal, targeted context.
+ * No output format constraints — reviewer responds naturally, CC interprets.
  */
 export declare function buildHandoffPrompt(options: PromptOptions): string;
 /**
@@ -229,18 +229,3 @@ export declare function buildSimpleHandoff(workingDir: string, ccOutput: string,
  * CC should call this to add its specific concerns
  */
 export declare function enhanceHandoff(handoff: Handoff, uncertainties?: Uncertainty[], questions?: Question[], decisions?: Decision[]): Handoff;
-export interface PeerPromptOptions {
-    workingDir: string;
-    prompt: string;
-    taskType?: string;
-    relevantFiles?: string[];
-    context?: string;
-    focusAreas?: FocusArea[];
-    customInstructions?: string;
-    outputFormat: 'json' | 'schema-enforced';
-}
-/**
- * Build a prompt for general-purpose peer assistance (not review).
- * The peer acts as a collaborative coworker, not a critic.
- */
-export declare function buildPeerPrompt(options: PeerPromptOptions): string;