cc-reviewer 1.0.0

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,75 @@
+/**
+ * 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] = await Promise.all([
+        commandExists('codex'),
+        commandExists('gemini')
+    ]);
+    return { codex, gemini };
+}
+/**
+ * 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'}`);
+    if (!status.codex && !status.gemini) {
+        console.error('\nWarning: No AI CLIs found. Install with:');
+        console.error('  npm install -g @openai/codex-cli');
+        console.error('  npm install -g @google/gemini-cli');
+    }
+}

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,236 @@
+/**
+ * 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';
+const TIMEOUT_MS = 180000; // 3 minutes (Codex can be slow)
+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);
+        // 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') {
+            return {
+                success: false,
+                error: createTimeoutError('codex', TIMEOUT_MS),
+                suggestion: getSuggestion(createTimeoutError('codex', TIMEOUT_MS)),
+                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 user's preferred flags:
+ * codex exec -m gpt-5.2-codex -c model_reasoning_effort="xhigh" \
+ *   -c model_reasoning_summary_format=experimental --search \
+ *   --dangerously-bypass-approvals-and-sandbox "<prompt>"
+ */
+function runCodexCli(prompt, workingDir) {
+    return new Promise((resolve, reject) => {
+        // Build CLI arguments for non-interactive execution
+        // Uses: codex exec -m gpt-5.2-codex -c model_reasoning_effort="xhigh" ...
+        const args = [
+            'exec',
+            '-m', 'gpt-5.2-codex',
+            '-c', 'model_reasoning_effort=xhigh',
+            '-c', 'model_reasoning_summary_format=experimental',
+            '--search',
+            '--dangerously-bypass-approvals-and-sandbox',
+            '-C', workingDir,
+            prompt
+        ];
+        const proc = spawn('codex', args, {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env }
+        });
+        let stdout = '';
+        let stderr = '';
+        let truncated = false;
+        proc.stdout.on('data', (data) => {
+            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) => {
+            if (stderr.length < MAX_BUFFER_SIZE) {
+                stderr += data.toString();
+                if (stderr.length > MAX_BUFFER_SIZE) {
+                    stderr = stderr.slice(0, MAX_BUFFER_SIZE);
+                }
+            }
+        });
+        // Timeout handling
+        const timeout = setTimeout(() => {
+            proc.kill('SIGTERM');
+            reject(new Error('TIMEOUT'));
+        }, TIMEOUT_MS);
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? -1,
+                truncated
+            });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeout);
+            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>;

package/dist/cli/gemini.js

@@ -0,0 +1,229 @@
+/**
+ * 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';
+const TIMEOUT_MS = 180000; // 3 minutes
+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') {
+            return {
+                success: false,
+                error: createTimeoutError('gemini', TIMEOUT_MS),
+                suggestion: getSuggestion(createTimeoutError('gemini', TIMEOUT_MS)),
+                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 -p "<prompt>" --include-directories <workingDir>
+ */
+function runGeminiCli(prompt, workingDir) {
+    return new Promise((resolve, reject) => {
+        // Build CLI arguments for non-interactive execution
+        const args = [
+            '-p', prompt,
+            '--include-directories', workingDir
+        ];
+        const proc = spawn('gemini', args, {
+            cwd: workingDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env }
+        });
+        let stdout = '';
+        let stderr = '';
+        let truncated = false;
+        proc.stdout.on('data', (data) => {
+            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) => {
+            if (stderr.length < MAX_BUFFER_SIZE) {
+                stderr += data.toString();
+                if (stderr.length > MAX_BUFFER_SIZE) {
+                    stderr = stderr.slice(0, MAX_BUFFER_SIZE);
+                }
+            }
+        });
+        // Timeout handling
+        const timeout = setTimeout(() => {
+            proc.kill('SIGTERM');
+            reject(new Error('TIMEOUT'));
+        }, TIMEOUT_MS);
+        proc.on('close', (code) => {
+            clearTimeout(timeout);
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? -1,
+                truncated
+            });
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timeout);
+            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/errors.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Error Handling for AI Reviewer MCP Server
+ */
+import { FeedbackError, CliType } from './types.js';
+/**
+ * Create a CLI not found error
+ */
+export declare function createCliNotFoundError(cli: CliType): FeedbackError;
+/**
+ * Create a timeout error
+ */
+export declare function createTimeoutError(cli: CliType, durationMs: number): FeedbackError;
+/**
+ * Create a rate limit error
+ */
+export declare function createRateLimitError(cli: CliType, retryAfterMs?: number): FeedbackError;
+/**
+ * Create an auth error
+ */
+export declare function createAuthError(cli: CliType, message: string): FeedbackError;
+/**
+ * Create an invalid response error
+ */
+export declare function createInvalidResponseError(cli: CliType, rawOutput: string): FeedbackError;
+/**
+ * Create a CLI crash error
+ */
+export declare function createCliError(cli: CliType, exitCode: number, stderr: string): FeedbackError;
+/**
+ * Format an error for user display
+ */
+export declare function formatErrorForUser(error: FeedbackError): string;
+/**
+ * Detect error type from CLI output and error messages
+ */
+export declare function detectErrorType(cli: CliType, error: Error & {
+    code?: string;
+}, stdout: string, stderr: string, exitCode: number | null): FeedbackError;
+/**
+ * Parse retry-after from error response
+ */
+export declare function parseRetryAfter(errorMessage: string): number | undefined;
+/**
+ * Generate suggestion based on error type
+ */
+export declare function getSuggestion(error: FeedbackError): string | undefined;