git-ai-review 2.1.0 → 2.2.0

package/README.md

@@ -26,6 +26,13 @@ npx git-ai-review review --copilot
 npx git-ai-review review --claude
 ```
 
+Or review the diff between two branches:
+
+```bash
+npx git-ai-review diff main
+npx git-ai-review diff main feature-branch
+```
+
 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`)
@@ -61,7 +68,9 @@ Recommended: install multiple for resilient fallback behavior.
 
 When an API token env var is set, the network preflight check for that reviewer is skipped — this is useful in CI environments or when interactive OAuth login is not available.
 
-Default fallback chain: Codex → Copilot → Claude. If all are unavailable, review fails.
+Default fallback chain: Codex → Copilot → Claude. If a provider was unavailable on the previous run, it is rotated to the end of the chain on the next attempt (state stored in `.git/ai-review-last-unavailable`, cleared on success). If all are unavailable, review fails.
+
+When a reviewer is explicitly selected via `--claude`, `--codex`, or `--copilot`, the preflight check is skipped entirely — the CLI tool handles its own authentication.
 
 ## Install in another repository
 
@@ -142,6 +151,7 @@ In each target repository:
 
 - In CI (`CI=true|1|yes`) pre-commit review is skipped.
 - Report is written to `.git/ai-review-last.json` by default.
+- Last-unavailable provider state: `.git/ai-review-last-unavailable` (used for fallback rotation).
 - Failure counter file: `.git/ai-review-fail-count`.
 - Lock file after repeated failures: `.git/ai-review.lock`.
 - Unlock manually by removing lock and fail-count files.

package/dist/review.d.ts

@@ -1,4 +1,9 @@
 import type { ParsedReview, ReviewReport, ReviewRunnerResult } from './types.js';
+export type ReviewerName = 'codex' | 'copilot' | 'claude';
+export declare function buildFallbackOrder(lastUnavailable: string | null): ReviewerName[];
+export declare function readLastUnavailable(cwd: string): string | null;
+export declare function writeLastUnavailable(cwd: string, reviewer: string): void;
+export declare function clearLastUnavailable(cwd: string): void;
 export interface RunReviewOptions {
     verbose?: boolean;
     reviewer?: 'claude' | 'codex' | 'copilot';
@@ -6,9 +11,9 @@ export interface RunReviewOptions {
 export interface RunReviewDeps {
     getStagedDiff: () => string;
     buildPrompt: (diff: string, cwd: string) => string;
-    runClaude: (prompt: string, verbose: boolean) => Promise<ReviewRunnerResult>;
-    runCodex: (prompt: string, verbose: boolean) => Promise<ReviewRunnerResult>;
-    runCopilot: (prompt: string, verbose: boolean) => Promise<ReviewRunnerResult>;
+    runClaude: (prompt: string, verbose: boolean, skipPreflight?: boolean) => Promise<ReviewRunnerResult>;
+    runCodex: (prompt: string, verbose: boolean, skipPreflight?: boolean) => Promise<ReviewRunnerResult>;
+    runCopilot: (prompt: string, verbose: boolean, skipPreflight?: boolean) => Promise<ReviewRunnerResult>;
     writeReport: (reportPath: string, report: ReviewReport) => void;
     log: (message: string) => void;
 }

package/dist/review.js

@@ -12,6 +12,45 @@ 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 || 300000);
 const PREFLIGHT_TIMEOUT_SEC = Number(process.env.AI_REVIEW_PREFLIGHT_TIMEOUT_SEC || 8);
+const DEFAULT_FALLBACK_ORDER = ['codex', 'copilot', 'claude'];
+export function buildFallbackOrder(lastUnavailable) {
+    if (!lastUnavailable || !DEFAULT_FALLBACK_ORDER.includes(lastUnavailable)) {
+        return [...DEFAULT_FALLBACK_ORDER];
+    }
+    const order = DEFAULT_FALLBACK_ORDER.filter((r) => r !== lastUnavailable);
+    order.push(lastUnavailable);
+    return order;
+}
+export function readLastUnavailable(cwd) {
+    try {
+        const filePath = resolve(cwd, getGitPath('ai-review-last-unavailable'));
+        if (!existsSync(filePath))
+            return null;
+        const value = readFileSync(filePath, 'utf8').trim();
+        return value || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeLastUnavailable(cwd, reviewer) {
+    const filePath = resolve(cwd, getGitPath('ai-review-last-unavailable'));
+    try {
+        writeFileSync(filePath, reviewer, 'utf8');
+    }
+    catch {
+        console.error(`Warning: could not write last-unavailable state to ${filePath}`);
+    }
+}
+export function clearLastUnavailable(cwd) {
+    const filePath = resolve(cwd, getGitPath('ai-review-last-unavailable'));
+    try {
+        rmSync(filePath, { force: true });
+    }
+    catch {
+        console.error(`Warning: could not clear last-unavailable state at ${filePath}`);
+    }
+}
 export function logVerboseRunnerOutput(output, log = console.log) {
     const label = output.model.toUpperCase();
     log(`\n----- ${label} STDOUT (RAW) -----`);
@@ -216,13 +255,13 @@ function spawnClaude(bin, args, prompt, env, cwd, timeoutMs) {
         child.stdin.end();
     });
 }
-async function runClaude(prompt, verbose) {
+async function runClaude(prompt, verbose, skipPreflight = false) {
     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 (!checkPreflight('Claude', 'ANTHROPIC_API_KEY', ['https://api.anthropic.com'], verbose)) {
+    if (!skipPreflight && !checkPreflight('Claude', 'ANTHROPIC_API_KEY', ['https://api.anthropic.com'], verbose)) {
         return { available: false };
     }
     try {
@@ -274,13 +313,13 @@ async function runClaude(prompt, verbose) {
         return { available: false };
     }
 }
-function runCodex(prompt, verbose) {
+function runCodex(prompt, verbose, skipPreflight = false) {
     const codex = resolveBinary('CODEX_BIN', ['codex']);
     if (!codex) {
         console.error('Codex: binary not found in PATH (or CODEX_BIN not set) — skipping.');
         return { available: false };
     }
-    if (!checkPreflight('Codex', 'OPENAI_API_KEY', ['https://api.openai.com/v1/models', 'https://chatgpt.com'], verbose)) {
+    if (!skipPreflight && !checkPreflight('Codex', 'OPENAI_API_KEY', ['https://api.openai.com/v1/models', 'https://chatgpt.com'], verbose)) {
         return { available: false };
     }
     const tempDir = mkdtempSync(join(tmpdir(), 'ai-review-codex-'));
@@ -332,13 +371,13 @@ function runCodex(prompt, verbose) {
         rmSync(tempDir, { recursive: true, force: true });
     }
 }
-function runCopilot(prompt, verbose) {
+function runCopilot(prompt, verbose, skipPreflight = false) {
     const copilot = resolveBinary('COPILOT_BIN', ['copilot']);
     if (!copilot) {
         console.error('Copilot: binary not found in PATH (or COPILOT_BIN not set) — skipping.');
         return { available: false };
     }
-    if (!checkPreflight('Copilot', 'GITHUB_TOKEN', ['https://api.github.com'], verbose)) {
+    if (!skipPreflight && !checkPreflight('Copilot', 'GITHUB_TOKEN', ['https://api.github.com'], verbose)) {
         return { available: false };
     }
     try {
@@ -423,8 +462,8 @@ export async function runReview(cwd = process.cwd(), options = {}, deps = {}) {
         getStagedDiff,
         buildPrompt,
         runClaude,
-        runCodex: (p, v) => Promise.resolve(runCodex(p, v)),
-        runCopilot: (p, v) => Promise.resolve(runCopilot(p, v)),
+        runCodex: (p, v, s) => Promise.resolve(runCodex(p, v, s)),
+        runCopilot: (p, v, s) => Promise.resolve(runCopilot(p, v, s)),
         writeReport: (reportPath, report) => {
             writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf8');
         },
@@ -432,9 +471,9 @@ export async function runReview(cwd = process.cwd(), options = {}, deps = {}) {
         ...deps,
     };
     const diff = runtimeDeps.getStagedDiff();
-    if (!diff) {
-        runtimeDeps.log('AI review: no staged changes.');
-        return { pass: true, reportPath: resolve(cwd, getGitPath('ai-review-last.json')), reason: 'No staged changes.' };
+    if (!diff || !diff.trim()) {
+        runtimeDeps.log('AI review: diff is empty — nothing to review.');
+        return { pass: true, reportPath: resolve(cwd, getGitPath('ai-review-last.json')), reason: 'Empty diff.' };
     }
     const prompt = runtimeDeps.buildPrompt(diff, cwd);
     if (verbose) {
@@ -447,26 +486,53 @@ export async function runReview(cwd = process.cwd(), options = {}, deps = {}) {
     let copilot = { available: false };
     if (reviewer === 'claude') {
         runtimeDeps.log('Running Claude review (--claude)...');
-        claude = await runtimeDeps.runClaude(prompt, verbose);
+        claude = await runtimeDeps.runClaude(prompt, verbose, true);
     }
     else if (reviewer === 'copilot') {
         runtimeDeps.log('Running Copilot review (--copilot)...');
-        copilot = await runtimeDeps.runCopilot(prompt, verbose);
+        copilot = await runtimeDeps.runCopilot(prompt, verbose, true);
     }
     else if (reviewer === 'codex') {
         runtimeDeps.log('Running Codex review (--codex)...');
-        codex = await runtimeDeps.runCodex(prompt, verbose);
+        codex = await runtimeDeps.runCodex(prompt, verbose, true);
     }
     else {
-        runtimeDeps.log('Running Codex review...');
-        codex = await runtimeDeps.runCodex(prompt, verbose);
-        if (!codex.available) {
-            runtimeDeps.log('Codex unavailable — falling back to Copilot review...');
-            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 lastUnavailable = readLastUnavailable(cwd);
+        const fallbackOrder = buildFallbackOrder(lastUnavailable);
+        const runners = {
+            codex: runtimeDeps.runCodex,
+            copilot: runtimeDeps.runCopilot,
+            claude: runtimeDeps.runClaude,
+        };
+        const results = {
+            codex: { available: false },
+            copilot: { available: false },
+            claude: { available: false },
+        };
+        const labels = { codex: 'Codex', copilot: 'Copilot', claude: 'Claude' };
+        let firstUnavailable = null;
+        for (let i = 0; i < fallbackOrder.length; i++) {
+            const name = fallbackOrder[i];
+            if (i === 0) {
+                runtimeDeps.log(`Running ${labels[name]} review...`);
+            }
+            else {
+                runtimeDeps.log(`${labels[fallbackOrder[i - 1]]} unavailable — falling back to ${labels[name]} review...`);
             }
+            results[name] = await runners[name](prompt, verbose);
+            if (results[name].available)
+                break;
+            if (!firstUnavailable)
+                firstUnavailable = name;
+        }
+        claude = results.claude;
+        codex = results.codex;
+        copilot = results.copilot;
+        if (firstUnavailable) {
+            writeLastUnavailable(cwd, firstUnavailable);
+        }
+        else {
+            clearLastUnavailable(cwd);
         }
     }
     const report = {

package/package.json

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