git-ai-review 2.0.0 → 2.0.2

package/README.md

@@ -1,7 +1,34 @@
 <!-- SPDX-License-Identifier: MPL-2.0 -->
 # git-ai-review
 
-Review your git diff with your locally installed **Codex CLI** or **Copilot CLI** — run it manually in one command or automatically as a git pre-commit hook.
+[![npm](https://img.shields.io/npm/v/git-ai-review)](https://www.npmjs.com/package/git-ai-review)
+
+Review your git diff with your locally installed **Codex CLI**, **Copilot CLI**, or **Claude CLI** — run it manually in one command or automatically as a git pre-commit hook.
+
+## Quick start
+
+Install and set up the git hook:
+
+```bash
+npm i -D git-ai-review
+npx git-ai-review install
+```
+
+That's it. Every `git commit` will now run an AI review of your staged changes automatically.
+
+You can also run reviews manually:
+
+```bash
+npx git-ai-review review
+npx git-ai-review review --verbose
+npx git-ai-review review --codex
+npx git-ai-review review --copilot
+npx git-ai-review review --claude
+```
+
+Requirements for the target repo:
+- An `AGENTS.md` file must exist in the repo root (it's used as policy context for the review)
+- At least one reviewer CLI must be installed and authenticated: **Codex CLI** (`codex login`), **Copilot CLI** (`copilot auth`), or **Claude CLI** (`claude`)
 
 ## License
 
@@ -9,14 +36,14 @@ This package is licensed under **MPL-2.0**.
 
 ## What it does
 
-`git-ai-review` uses your local Codex CLI and Copilot CLI installations to AI-review staged changes before they are committed. You can run it on demand with a single command (`npx git-ai-review review`) or install it as a git hook so every commit is reviewed automatically.
+`git-ai-review` uses your locally installed AI CLIs to review staged changes before they are committed. You can run it on demand with a single command (`npx git-ai-review review`) or install it as a git hook so every commit is reviewed automatically.
 
 - Uses your local **Codex CLI** as the primary reviewer.
-- Falls back to your local **Copilot CLI** when Codex is unavailable.
+- Falls back to **Copilot CLI**, then **Claude CLI** when the previous reviewer is unavailable.
 - Blocks commit when:
   - any reviewer returns `status: fail`, or
   - any findings are returned (even with `status: pass`), or
-  - both reviewers are unavailable.
+  - all reviewers are unavailable.
 - Tracks consecutive failures and enables a hard lock after a limit (default `10`).
 - Builds prompt context from:
   - full `AGENTS.md`,
@@ -26,12 +53,13 @@ This package is licensed under **MPL-2.0**.
 ## Prerequisites
 
 At least one reviewer CLI must be installed and authenticated on each developer machine.
-Recommended: install both for resilient fallback behavior.
+Recommended: install multiple for resilient fallback behavior.
 
-- Codex CLI (`codex`) with active login (`codex login`)
+- Codex CLI (`codex`) with active login (`codex login`) — primary reviewer
 - Copilot CLI (`copilot`) with active login (`copilot auth`)
+- Claude CLI (`claude`)
 
-If Codex is unavailable, fallback to Copilot is used. If both are unavailable, review fails.
+Default fallback chain: Codex → Copilot → Claude. If all are unavailable, review fails.
 
 ## Install in another repository
 
@@ -60,6 +88,7 @@ npx git-ai-review review
 npx git-ai-review review --verbose
 npx git-ai-review review --codex
 npx git-ai-review review --copilot
+npx git-ai-review review --claude
 npx git-ai-review pre-commit
 npx git-ai-review pre-commit --verbose
 npx git-ai-review install
@@ -72,6 +101,7 @@ npm run git-ai-review -- review
 npm run git-ai-review -- review --verbose
 npm run git-ai-review -- review --codex
 npm run git-ai-review -- review --copilot
+npm run git-ai-review -- review --claude
 npm run git-ai-review -- pre-commit
 npm run git-ai-review -- pre-commit --verbose
 npm run git-ai-review -- install
@@ -80,14 +110,15 @@ npm run git-ai-review -- install
 `npm run ai-review` is an alias for `npm run git-ai-review` — both accept the same commands and flags.
 
 - `review`: run AI review against staged diff.
-- `review --verbose`: print full prompt plus raw Codex/Copilot outputs to stdout.
-- `review --codex`: force Codex reviewer only (skip Copilot fallback).
-- `review --copilot`: force Copilot reviewer only (skip Codex).
+- `review --verbose`: print full prompt plus raw model outputs to stdout.
+- `review --codex`: force Codex reviewer only (skip Copilot/Claude fallback).
+- `review --copilot`: force Copilot reviewer only (skip Codex/Claude).
+- `review --claude`: force Claude reviewer only (skip Codex/Copilot).
 - `pre-commit`: run lock-aware pre-commit flow (recommended for hooks).
 - `pre-commit --verbose`: same as pre-commit, but with detailed prompt/raw model logs.
 - `install`: install hook script and set `core.hooksPath`.
 
-The `--codex` and `--copilot` flags are mutually exclusive and can be combined with `--verbose`.
+The `--claude`, `--codex`, and `--copilot` flags are mutually exclusive and can be combined with `--verbose`.
 
 ## Repository requirements
 
@@ -109,8 +140,9 @@ In each target repository:
 
 - `CODEX_BIN`: custom Codex executable path/name.
 - `COPILOT_BIN`: custom Copilot executable path/name.
+- `CLAUDE_BIN`: custom Claude executable path/name.
 - `COPILOT_REVIEW_MODEL`: default `gpt-5.3-codex`.
-- `AI_REVIEW_TIMEOUT_MS`: default `180000`.
+- `AI_REVIEW_TIMEOUT_MS`: default `300000` (5 min).
 - `AI_REVIEW_PREFLIGHT_TIMEOUT_SEC`: default `8`.
 - `AI_REVIEW_FAIL_LIMIT`: default `10`.
 - `AI_REVIEW_REPORT_PATH`: custom report location.
@@ -125,7 +157,8 @@ Use `--verbose` to print:
 
 - full generated review prompt
 - raw Codex stdout/stderr and structured response file
-- raw Copilot stdout/stderr (when fallback runs)
+- raw Copilot stdout/stderr
+- raw Claude stdout/stderr
 
 This is useful for debugging prompt behavior and model integration issues.
 

package/dist/bin/git-ai-review.js

@@ -3,7 +3,11 @@
  * Copyright (c) 2026 ai-review contributors
  */
 import { runCli } from '../cli.js';
-const code = runCli(process.argv.slice(2));
-if (code !== 0) {
-    process.exit(code);
-}
+runCli(process.argv.slice(2)).then((code) => {
+    if (code !== 0) {
+        process.exit(code);
+    }
+}).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/cli.d.ts

@@ -9,6 +9,7 @@ export interface CliDeps {
     log: (message: string) => void;
 }
 export declare function hasVerboseFlag(args: string[]): boolean;
+export declare function hasClaudeFlag(args: string[]): boolean;
 export declare function hasCodexFlag(args: string[]): boolean;
 export declare function hasCopilotFlag(args: string[]): boolean;
-export declare function runCli(argv?: string[], deps?: CliDeps): number;
+export declare function runCli(argv?: string[], deps?: CliDeps): Promise<number>;

package/dist/cli.js

@@ -20,37 +20,43 @@ function printHelp(log) {
     log('  install     Install .githooks/pre-commit and set core.hooksPath');
     log('');
     log('Options:');
-    log('  --codex     Force Codex reviewer only (skip Copilot fallback)');
-    log('  --copilot   Force Copilot reviewer only (skip Codex)');
+    log('  --codex     Force Codex reviewer only (skip Copilot/Claude fallback)');
+    log('  --copilot   Force Copilot reviewer only (skip Codex/Claude)');
+    log('  --claude    Force Claude reviewer only (skip Codex/Copilot)');
     log('  --verbose   Print full prompt and raw model outputs to stdout');
 }
 export function hasVerboseFlag(args) {
     return args.includes('--verbose');
 }
+export function hasClaudeFlag(args) {
+    return args.includes('--claude');
+}
 export function hasCodexFlag(args) {
     return args.includes('--codex');
 }
 export function hasCopilotFlag(args) {
     return args.includes('--copilot');
 }
-export function runCli(argv = process.argv.slice(2), deps = DEFAULT_CLI_DEPS) {
+export async function runCli(argv = process.argv.slice(2), deps = DEFAULT_CLI_DEPS) {
     const command = argv[0] || 'help';
     const args = argv.slice(1);
     const verbose = hasVerboseFlag(args);
+    const useClaude = hasClaudeFlag(args);
     const useCodex = hasCodexFlag(args);
     const useCopilot = hasCopilotFlag(args);
     const cwd = deps.getCwd();
-    if (useCodex && useCopilot) {
-        deps.log('Error: --codex and --copilot are mutually exclusive.');
+    const selectedCount = [useClaude, useCodex, useCopilot].filter(Boolean).length;
+    if (selectedCount > 1) {
+        deps.log('Error: --claude, --codex, and --copilot are mutually exclusive.');
         return 1;
     }
-    const reviewer = useCodex ? 'codex' : useCopilot ? 'copilot' : undefined;
+    const reviewer = useClaude ? 'claude' : useCodex ? 'codex' : useCopilot ? 'copilot' : undefined;
     if (command === 'review') {
-        const result = deps.runReview(cwd, { verbose, reviewer });
+        const result = await deps.runReview(cwd, { verbose, reviewer });
         return result.pass ? 0 : 1;
     }
     if (command === 'pre-commit') {
-        return deps.runPreCommit(cwd, { verbose, reviewer });
+        return await deps.runPreCommit(cwd, { verbose, reviewer });
     }
     if (command === 'install') {
         deps.installPreCommitHook();

package/dist/precommit.d.ts

@@ -1,9 +1,9 @@
 import { runReview } from './review.js';
 export interface PreCommitOptions {
     verbose?: boolean;
-    reviewer?: 'codex' | 'copilot';
+    reviewer?: 'claude' | 'codex' | 'copilot';
 }
 export interface PreCommitDeps {
     runReviewFn: typeof runReview;
 }
-export declare function runPreCommit(cwd?: string, options?: PreCommitOptions, deps?: Partial<PreCommitDeps>): number;
+export declare function runPreCommit(cwd?: string, options?: PreCommitOptions, deps?: Partial<PreCommitDeps>): Promise<number>;

package/dist/precommit.js

@@ -25,7 +25,7 @@ function printLastReport(reportPath) {
         console.log('Review output: report file not found.');
     }
 }
-export function runPreCommit(cwd = process.cwd(), options = {}, deps = {}) {
+export async function runPreCommit(cwd = process.cwd(), options = {}, deps = {}) {
     const verbose = options.verbose === true;
     const runReviewFn = deps.runReviewFn ?? runReview;
     if (isCiEnvironment()) {
@@ -42,7 +42,7 @@ export function runPreCommit(cwd = process.cwd(), options = {}, deps = {}) {
         printLastReport(reportPath);
         return 1;
     }
-    const review = runReviewFn(cwd, { verbose, reviewer: options.reviewer });
+    const review = await runReviewFn(cwd, { verbose, reviewer: options.reviewer });
     if (review.pass) {
         rmSync(failCountPath, { force: true });
         return 0;

package/dist/review.d.ts

@@ -1,13 +1,14 @@
 import type { ParsedReview, ReviewReport, ReviewRunnerResult } from './types.js';
 export interface RunReviewOptions {
     verbose?: boolean;
-    reviewer?: 'codex' | 'copilot';
+    reviewer?: 'claude' | 'codex' | 'copilot';
 }
 export interface RunReviewDeps {
     getStagedDiff: () => string;
     buildPrompt: (diff: string, cwd: string) => string;
-    runCodex: (prompt: string, verbose: boolean) => ReviewRunnerResult;
-    runCopilot: (prompt: string, verbose: boolean) => ReviewRunnerResult;
+    runClaude: (prompt: string, verbose: boolean) => Promise<ReviewRunnerResult>;
+    runCodex: (prompt: string, verbose: boolean) => Promise<ReviewRunnerResult>;
+    runCopilot: (prompt: string, verbose: boolean) => Promise<ReviewRunnerResult>;
     writeReport: (reportPath: string, report: ReviewReport) => void;
     log: (message: string) => void;
 }
@@ -28,12 +29,19 @@ export interface ResolveBinaryOptions {
 }
 export declare function resolveBinary(envName: string, candidates: string[], options?: ResolveBinaryOptions): string | null;
 export declare function parseSubagentOutput(raw: string): ParsedReview;
-export declare function evaluateResults(codex: ReviewRunnerResult, copilot: ReviewRunnerResult): {
+export declare function buildSpawnOptions(cwd: string, env: Record<string, string>, osPlatform?: NodeJS.Platform): {
+    cwd: string;
+    env: Record<string, string>;
+    stdio: ['pipe', 'pipe', 'pipe'];
+    detached: boolean;
+    windowsHide: boolean;
+};
+export declare function evaluateResults(claude: ReviewRunnerResult, codex: ReviewRunnerResult, copilot: ReviewRunnerResult): {
     pass: boolean;
     reason: string;
 };
-export declare function runReview(cwd?: string, options?: RunReviewOptions, deps?: Partial<RunReviewDeps>): {
+export declare function runReview(cwd?: string, options?: RunReviewOptions, deps?: Partial<RunReviewDeps>): Promise<{
     pass: boolean;
     reportPath: string;
     reason: string;
-};
+}>;

package/dist/review.js

@@ -4,13 +4,13 @@
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { platform, tmpdir } from 'node:os';
-import { execFileSync, spawnSync } from 'node:child_process';
+import { execFileSync, spawn, spawnSync } from 'node:child_process';
 import { pathToFileURL } from 'node:url';
 import { REVIEW_SCHEMA } from './schema.js';
 import { buildAgentsContext, resolvePromptHeaderLines } from './prompt.js';
 import { getGitPath, git } from './git.js';
 const COPILOT_MODEL = process.env.COPILOT_REVIEW_MODEL || 'gpt-5.3-codex';
-const TIMEOUT_MS = Number(process.env.AI_REVIEW_TIMEOUT_MS || 180000);
+const TIMEOUT_MS = Number(process.env.AI_REVIEW_TIMEOUT_MS || 300000);
 const PREFLIGHT_TIMEOUT_SEC = Number(process.env.AI_REVIEW_PREFLIGHT_TIMEOUT_SEC || 8);
 export function logVerboseRunnerOutput(output, log = console.log) {
     const label = output.model.toUpperCase();
@@ -118,28 +118,148 @@ function buildPrompt(diff, cwd = process.cwd()) {
         diff,
     ].join('\n');
 }
+function validateParsedReview(parsed) {
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error('Subagent output is not a JSON object.');
+    }
+    if (!['pass', 'fail'].includes(parsed.status)) {
+        throw new Error('Subagent output has an invalid status.');
+    }
+    if (!Array.isArray(parsed.findings)) {
+        throw new Error('Subagent output has an invalid findings list.');
+    }
+    return parsed;
+}
 export function parseSubagentOutput(raw) {
     const trimmed = String(raw || '').trim();
     if (!trimmed) {
         throw new Error('Subagent returned an empty response.');
     }
     let cleaned = trimmed.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '');
+    // Try direct parse first (handles clean JSON without extraction)
+    try {
+        return validateParsedReview(JSON.parse(cleaned));
+    }
+    catch {
+        // not valid or not a review — try extraction
+    }
+    // Extract JSON object from surrounding text
     const jsonStart = cleaned.indexOf('{');
     const jsonEnd = cleaned.lastIndexOf('}');
     if (jsonStart !== -1 && jsonEnd > jsonStart) {
         cleaned = cleaned.slice(jsonStart, jsonEnd + 1);
     }
-    const parsed = JSON.parse(cleaned);
-    if (!parsed || typeof parsed !== 'object') {
-        throw new Error('Subagent output is not a JSON object.');
+    return validateParsedReview(JSON.parse(cleaned));
+}
+export function buildSpawnOptions(cwd, env, osPlatform = process.platform) {
+    return {
+        cwd,
+        env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: osPlatform !== 'win32',
+        windowsHide: true,
+    };
+}
+function spawnClaude(bin, args, prompt, env, cwd, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, buildSpawnOptions(cwd, env));
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                try {
+                    if (process.platform !== 'win32' && child.pid) {
+                        process.kill(-child.pid, 'SIGTERM');
+                    }
+                    else {
+                        child.kill();
+                    }
+                }
+                catch { /* ignore */ }
+                reject(new Error(`spawn ${bin} ETIMEDOUT`));
+            }
+        }, timeoutMs);
+        child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+        child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+        child.on('error', (err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(err);
+            }
+        });
+        child.on('close', (code) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve({ stdout, stderr, exitCode: code ?? 1 });
+            }
+        });
+        child.stdin.on('error', () => { });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+async function runClaude(prompt, verbose) {
+    const claude = resolveBinary('CLAUDE_BIN', ['claude']);
+    if (!claude) {
+        console.error('Claude: binary not found in PATH (or CLAUDE_BIN not set) — skipping.');
+        return { available: false };
     }
-    if (!['pass', 'fail'].includes(parsed.status)) {
-        throw new Error('Subagent output has an invalid status.');
+    if (!canReach('https://api.anthropic.com')) {
+        console.error('Claude: network preflight failed (api.anthropic.com) — skipping.');
+        return { available: false };
     }
-    if (!Array.isArray(parsed.findings)) {
-        throw new Error('Subagent output has an invalid findings list.');
+    try {
+        const claudeArgs = [
+            '--print',
+            '--output-format', 'json',
+            '--no-session-persistence',
+            '--max-turns', '1',
+            '--allowedTools', '',
+        ];
+        if (verbose) {
+            console.log(claude, claudeArgs.join(' '), '< <prompt via stdin>');
+        }
+        const cleanEnv = {};
+        for (const [key, val] of Object.entries(process.env)) {
+            if (val !== undefined && !(key.toUpperCase().startsWith('CLAUDE') && key.toUpperCase() !== 'CLAUDE_BIN')) {
+                cleanEnv[key] = val;
+            }
+        }
+        const { stdout, stderr, exitCode } = await spawnClaude(claude, claudeArgs, prompt, cleanEnv, process.cwd(), TIMEOUT_MS);
+        if (verbose) {
+            logVerboseRunnerOutput({ model: 'Claude', stdout, stderr });
+        }
+        if (exitCode !== 0) {
+            const err = stderr.trim() || stdout.trim();
+            console.error(`Claude: execution failed${err ? `: ${err}` : ''} — skipping.`);
+            return { available: false };
+        }
+        const trimmed = stdout.trim();
+        if (!trimmed) {
+            console.error('Claude: empty response — skipping.');
+            return { available: false };
+        }
+        let reviewPayload = trimmed;
+        try {
+            const envelope = JSON.parse(trimmed);
+            if (envelope && typeof envelope === 'object' && typeof envelope.result === 'string') {
+                reviewPayload = envelope.result;
+            }
+        }
+        catch {
+            // not an envelope — use raw output
+        }
+        return { available: true, result: parseSubagentOutput(reviewPayload) };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Claude: ${message} — skipping.`);
+        return { available: false };
     }
-    return parsed;
 }
 function runCodex(prompt, verbose) {
     const codex = resolveBinary('CODEX_BIN', ['codex']);
@@ -243,31 +363,32 @@ function runCopilot(prompt, verbose) {
         return { available: false };
     }
 }
-export function evaluateResults(codex, copilot) {
-    if (!codex.available && !copilot.available) {
-        return { pass: false, reason: 'Both Codex and Copilot are unavailable. At least one AI review is required.' };
+export function evaluateResults(claude, codex, copilot) {
+    if (!claude.available && !codex.available && !copilot.available) {
+        return { pass: false, reason: 'All reviewers (Claude, Codex, Copilot) are unavailable. At least one AI review is required.' };
     }
+    const runners = [['Claude', claude], ['Codex', codex], ['Copilot', copilot]];
     const failures = [];
-    if (codex.available && codex.result.status === 'fail')
-        failures.push('Codex');
-    if (copilot.available && copilot.result.status === 'fail')
-        failures.push('Copilot');
+    for (const [name, runner] of runners) {
+        if (runner.available && runner.result.status === 'fail')
+            failures.push(name);
+    }
     if (failures.length > 0) {
         return { pass: false, reason: `AI review rejected by: ${failures.join(', ')}.` };
     }
     const withFindings = [];
-    if (codex.available && codex.result.findings.length > 0)
-        withFindings.push('Codex');
-    if (copilot.available && copilot.result.findings.length > 0)
-        withFindings.push('Copilot');
+    for (const [name, runner] of runners) {
+        if (runner.available && runner.result.findings.length > 0)
+            withFindings.push(name);
+    }
     if (withFindings.length > 0) {
         return { pass: false, reason: `AI review has unresolved findings from: ${withFindings.join(', ')}. Pass requires zero findings.` };
     }
     const passed = [];
-    if (codex.available)
-        passed.push('Codex');
-    if (copilot.available)
-        passed.push('Copilot');
+    for (const [name, runner] of runners) {
+        if (runner.available)
+            passed.push(name);
+    }
     return { pass: true, reason: `AI review approved by: ${passed.join(', ')}.` };
 }
 function printReview(model, result) {
@@ -284,14 +405,15 @@ function printReview(model, result) {
         console.log(`  ${finding.details}`);
     }
 }
-export function runReview(cwd = process.cwd(), options = {}, deps = {}) {
+export async function runReview(cwd = process.cwd(), options = {}, deps = {}) {
     const verbose = options.verbose === true;
     const reviewer = options.reviewer;
     const runtimeDeps = {
         getStagedDiff,
         buildPrompt,
-        runCodex,
-        runCopilot,
+        runClaude,
+        runCodex: (p, v) => Promise.resolve(runCodex(p, v)),
+        runCopilot: (p, v) => Promise.resolve(runCopilot(p, v)),
         writeReport: (reportPath, report) => {
             writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf8');
         },
@@ -309,31 +431,47 @@ export function runReview(cwd = process.cwd(), options = {}, deps = {}) {
         runtimeDeps.log(prompt);
         runtimeDeps.log('----- END REVIEW PROMPT -----');
     }
+    let claude = { available: false };
     let codex = { available: false };
     let copilot = { available: false };
-    if (reviewer === 'copilot') {
+    if (reviewer === 'claude') {
+        runtimeDeps.log('Running Claude review (--claude)...');
+        claude = await runtimeDeps.runClaude(prompt, verbose);
+    }
+    else if (reviewer === 'copilot') {
         runtimeDeps.log('Running Copilot review (--copilot)...');
-        copilot = runtimeDeps.runCopilot(prompt, verbose);
+        copilot = await runtimeDeps.runCopilot(prompt, verbose);
     }
     else if (reviewer === 'codex') {
         runtimeDeps.log('Running Codex review (--codex)...');
-        codex = runtimeDeps.runCodex(prompt, verbose);
+        codex = await runtimeDeps.runCodex(prompt, verbose);
     }
     else {
         runtimeDeps.log('Running Codex review...');
-        codex = runtimeDeps.runCodex(prompt, verbose);
+        codex = await runtimeDeps.runCodex(prompt, verbose);
         if (!codex.available) {
             runtimeDeps.log('Codex unavailable — falling back to Copilot review...');
-            copilot = runtimeDeps.runCopilot(prompt, verbose);
+            copilot = await runtimeDeps.runCopilot(prompt, verbose);
+            if (!copilot.available) {
+                runtimeDeps.log('Copilot unavailable — falling back to Claude review...');
+                claude = await runtimeDeps.runClaude(prompt, verbose);
+            }
         }
     }
     const report = {
+        claude: claude.available ? claude.result : { status: 'unavailable' },
         codex: codex.available ? codex.result : { status: 'unavailable' },
         copilot: copilot.available ? copilot.result : { status: 'unavailable' },
     };
     const reportPath = resolve(cwd, process.env.AI_REVIEW_REPORT_PATH || getGitPath('ai-review-last.json'));
     runtimeDeps.writeReport(reportPath, report);
     runtimeDeps.log(`AI review raw report saved: ${reportPath}`);
+    if (claude.available) {
+        printReview('Claude', claude.result);
+    }
+    else {
+        console.log('\nClaude: unavailable — skipped.');
+    }
     if (codex.available) {
         printReview('Codex', codex.result);
     }
@@ -346,12 +484,16 @@ export function runReview(cwd = process.cwd(), options = {}, deps = {}) {
     else {
         console.log('\nCopilot: unavailable — skipped.');
     }
-    const verdict = evaluateResults(codex, copilot);
+    const verdict = evaluateResults(claude, codex, copilot);
     console.log(`\n${verdict.reason}`);
     return { pass: verdict.pass, reportPath, reason: verdict.reason };
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
-    const result = runReview();
-    if (!result.pass)
+    runReview().then((result) => {
+        if (!result.pass)
+            process.exit(1);
+    }).catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
         process.exit(1);
+    });
 }

package/dist/types.d.ts

@@ -17,6 +17,9 @@ export type ReviewRunnerResult = {
     result: ParsedReview;
 };
 export interface ReviewReport {
+    claude: ParsedReview | {
+        status: 'unavailable';
+    };
     codex: ParsedReview | {
         status: 'unavailable';
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-ai-review",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Review your git diff with local Codex CLI or Copilot CLI — run manually in one command or automatically as a git hook",
   "type": "module",
   "main": "dist/cli.js",