pull-request-review 1.0.0

package/README.md

@@ -0,0 +1,336 @@
+# pr-review
+
+> AI-powered Pull Request reviews — pick your AI, get a structured Markdown report, right from your terminal.
+
+`pr-review` diffs two branches, sends the diff to your chosen AI, and saves a structured Markdown review to a file. If a GitHub PR is open, the file is automatically named `pr-<number>-review.md`.
+
+**No API keys required.** All providers use their official CLI tools with your existing authenticated sessions.
+
+---
+
+## Installation
+
+```bash
+npm install -g pull-request-review
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/hardik-143/pull-request-review
+cd pr-review
+npm install
+npm install -g .
+```
+
+---
+
+## Requirements
+
+- Node.js ≥ 18
+- Git in `PATH`
+- At least one AI provider CLI installed and authenticated (see [Providers](#providers))
+
+---
+
+## Quickstart
+
+```bash
+# Run inside any git repository
+cd your-project
+pr-review
+```
+
+You'll be prompted to pick an AI provider, a model, and your branches. That's it.
+
+---
+
+## Providers
+
+All five providers use their official CLI — no API keys, no environment variables.
+
+| Provider | CLI binary | Auth |
+|---|---|---|
+| **Claude** | `claude` | Already logged in via Claude Code |
+| **GitHub Copilot** | `copilot` | `copilot /login` |
+| **OpenAI Codex** | `codex` | Sign in on first `codex` run |
+| **Google Gemini** | `gemini` | Sign in on first `gemini` run |
+| **Cursor** | `agent` | Install Cursor → Cmd+Shift+P → *Install agent in PATH* |
+
+### Installing provider CLIs
+
+```bash
+# Claude
+# Already installed if you're using Claude Code
+
+# GitHub Copilot
+npm install -g @github/copilot
+copilot /login
+
+# OpenAI Codex
+npm install -g @openai/codex
+codex   # sign in on first launch
+
+# Google Gemini
+npm install -g @google/gemini-cli
+gemini  # sign in on first launch
+
+# Cursor
+# Install Cursor app → Cmd+Shift+P → "Install cursor/agent in PATH"
+```
+
+---
+
+## Usage
+
+### Interactive review
+
+```bash
+pr-review
+```
+
+Flow:
+
+```
+  Select AI provider:
+
+    1) Claude (Anthropic)   — Uses local claude CLI — no API key needed
+    2) GitHub Copilot       — Uses copilot CLI — run `copilot /login` first
+    3) OpenAI Codex         — Uses codex CLI — run `codex` to sign in
+    4) Google Gemini        — Uses gemini CLI — run `gemini` to authenticate
+    5) Cursor               — Uses agent CLI — install Cursor + add agent to PATH
+
+  Choice [1]:
+
+  Select Claude model:
+
+    1) claude-sonnet-4-5  · Recommended
+    2) claude-opus-4-5   · Most capable
+    3) claude-haiku-3-5  · Fastest
+    ...
+
+  Choice [1]:
+
+  Source branch     (default: feature/auth):
+  Destination branch (default: main):
+
+  🔗 PR #42 detected → output: pr-42-review.md
+
+✔ Diff fetched — 4,821 chars
+✔ Claude review received
+✔ Report saved → /your/project/pr-42-review.md
+
+✅ PR Review complete!
+   PR #42 · Claude · claude-sonnet-4-5
+```
+
+---
+
+### Commands & flags
+
+```
+pr-review                              Interactive PR review
+pr-review review                       Explicit review subcommand (same as above)
+pr-review config                       View and edit global config
+pr-review review --staged              Review staged (uncommitted) changes
+pr-review review --provider=<provider> Skip provider prompt
+pr-review review --model=<model>       Skip model prompt
+pr-review review --base=<branch>       Override destination/base branch
+pr-review review --focus=<area>        Focus: security, performance, etc.
+pr-review review --output=<file>       Override output file name
+pr-review --help                       Show help
+pr-review --version                    Show version
+```
+
+### Examples
+
+```bash
+# Standard interactive review
+pr-review
+
+# Explicit review subcommand
+pr-review review
+
+# Non-interactive — skip all prompts
+pr-review review --provider=claude --model=claude-sonnet-4-5 --base=main
+
+# Security-focused review of staged changes
+pr-review review --staged --focus=security
+
+# Use Gemini's most capable model
+pr-review review --provider=gemini --model=pro
+
+# Review with GitHub Copilot, custom output file
+pr-review review --provider=copilot --output=review-$(date +%Y%m%d).md
+
+# View and update config
+pr-review config
+```
+
+---
+
+## PR Number Detection
+
+If a GitHub PR is open for the current branch, `pr-review` automatically detects it via `gh pr view` and names the output file:
+
+```
+pr-42-review.md
+```
+
+Falls back to `pr-review-review.md` (from config) if no PR is found or `gh` is not installed.
+
+---
+
+## Models
+
+### Claude
+| Model | Description |
+|---|---|
+| `claude-sonnet-4-5` | Recommended (default) |
+| `claude-opus-4-5` | Most capable |
+| `claude-haiku-3-5` | Fastest |
+| `claude-sonnet-4` | Previous Sonnet |
+| `claude-opus-4` | Previous Opus |
+
+### GitHub Copilot
+| Model | Description |
+|---|---|
+| `default` | Your Copilot plan's default (recommended) |
+| `gpt-4.1` | GPT-4.1 |
+| `gpt-4o` | GPT-4o |
+| `claude-sonnet-4-5` | Claude via Copilot |
+| `o3` | Reasoning model |
+| `o4-mini` | Fast reasoning |
+
+### OpenAI Codex
+| Model | Description |
+|---|---|
+| `default` | Your Codex plan's default (recommended) |
+| `gpt-4o` | GPT-4o |
+| `o3` | Reasoning |
+| `o4-mini` | Fast reasoning |
+
+### Google Gemini
+| Model alias | Resolves to | Description |
+|---|---|---|
+| `flash` | gemini-2.5-flash | Recommended (default) |
+| `pro` | gemini-2.5-pro | Most capable |
+| `flash-lite` | gemini-2.5-flash-lite | Fastest |
+| `auto` | auto-select | Best available |
+
+### Cursor
+| Model | Description |
+|---|---|
+| `default` | Your Cursor plan's default (recommended) |
+| `gpt-4o` | GPT-4o |
+| `claude-sonnet-4-5` | Claude via Cursor |
+| `gemini-2.5-pro` | Gemini via Cursor |
+| `o3` | Reasoning |
+
+---
+
+## Global Config
+
+Auto-created at `~/.pr-review/config.json` on first run.
+
+**Default config:**
+
+```json
+{
+  "defaultProvider": "claude",
+  "defaultModels": {
+    "claude":  "claude-sonnet-4-5",
+    "copilot": "default",
+    "codex":   "default",
+    "gemini":  "flash",
+    "cursor":  "default"
+  },
+  "defaultBaseBranch": "main",
+  "maxDiffLength": 100000,
+  "ignoreFiles": ["package-lock.json", "yarn.lock"],
+  "outputFile": "pr-review-review.md",
+  "strictMode": true
+}
+```
+
+The last-used provider and model per provider are automatically remembered.
+
+**Edit interactively:**
+
+```bash
+pr-review config
+```
+
+**Or edit directly:**
+
+```bash
+nano ~/.pr-review/config.json
+```
+
+### Config options
+
+| Key | Description | Default |
+|---|---|---|
+| `defaultProvider` | AI provider to pre-select | `claude` |
+| `defaultModels` | Last-used model per provider | see above |
+| `defaultBaseBranch` | Branch to diff against | `main` |
+| `maxDiffLength` | Max diff characters sent to AI | `100000` |
+| `ignoreFiles` | Files excluded from diff | `[package-lock.json, yarn.lock]` |
+| `outputFile` | Fallback report filename | `pr-review-review.md` |
+| `strictMode` | Strict review mode in prompt | `true` |
+
+---
+
+## Output format
+
+Every generated report has this structure:
+
+```markdown
+---
+<!-- Generated by pr-review on 2026-04-03T18:00:00.000Z -->
+<!-- Provider: Claude | Model: claude-sonnet-4-5 | Diff: 4821 chars | feature/auth → main -->
+<!-- PR: #42 -->
+---
+
+# PR Review: `feature/auth` → `main`
+
+## Summary
+## Critical Issues
+## Security
+## Performance
+## Code Quality & Improvements
+## Test Coverage
+## Suggestions
+## Final Verdict
+```
+
+---
+
+## Project structure
+
+```
+pr-review/
+├── src/
+│   ├── cli.js              Main entry point, argument parsing, user prompts
+│   ├── ai.js               Provider dispatcher
+│   ├── config.js           Config manager (~/.pr-review/config.json)
+│   ├── git.js              Git diff + PR number detection
+│   ├── prompt.js           PR review prompt builder + system prompt
+│   ├── file.js             Report file writer
+│   └── providers/
+│       ├── index.js        Provider registry (models, labels, descriptions)
+│       ├── claude.js       claude CLI adapter
+│       ├── copilot.js      copilot CLI adapter
+│       ├── codex.js        codex CLI adapter
+│       ├── gemini.js       gemini CLI adapter
+│       └── cursor.js       agent CLI adapter (Cursor)
+├── package.json
+└── README.md
+```
+
+---
+
+## License
+
+MIT
+

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "pull-request-review",
+  "version": "1.0.0",
+  "description": "AI-powered Pull Request reviews using Claude",
+  "type": "module",
+  "author": "Hardik <dhardik1430@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hardik-143/pull-request-review.git"
+  },
+  "homepage": "https://github.com/hardik-143/pull-request-review#readme",
+  "bugs": {
+    "url": "https://github.com/hardik-143/pull-request-review/issues"
+  },
+  "files": [
+    "src"
+  ],
+  "bin": {
+    "pr-review": "./src/cli.js"
+  },
+  "scripts": {
+    "start": "node src/cli.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "ora": "^8.1.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "pr-review",
+    "code-review",
+    "claude",
+    "anthropic",
+    "ai",
+    "git",
+    "cli"
+  ],
+  "license": "MIT"
+}

package/src/ai.js

@@ -0,0 +1,23 @@
+import { callClaude }  from './providers/claude.js';
+import { callCopilot } from './providers/copilot.js';
+import { callCodex }   from './providers/codex.js';
+import { callGemini }  from './providers/gemini.js';
+import { callCursor }  from './providers/cursor.js';
+
+const DISPATCH = {
+  claude:  callClaude,
+  copilot: callCopilot,
+  codex:   callCodex,
+  gemini:  callGemini,
+  cursor:  callCursor,
+};
+
+export async function callAI(prompt, provider, model) {
+  const fn = DISPATCH[provider];
+  if (!fn) {
+    throw new Error(
+      `Unknown provider: "${provider}". Valid providers: ${Object.keys(DISPATCH).join(', ')}`
+    );
+  }
+  return fn(prompt, model);
+}

package/src/claude.js

@@ -0,0 +1,59 @@
+import { execFileSync } from 'child_process';
+import { SYSTEM_PROMPT } from './prompt.js';
+
+// Map friendly short names → claude CLI model aliases
+const MODEL_ALIASES = {
+  'sonnet-4.5':       'claude-sonnet-4-5',
+  'sonnet-4':         'claude-sonnet-4',
+  'opus-4.5':         'claude-opus-4-5',
+  'opus-4':           'claude-opus-4',
+  'haiku-3.5':        'claude-haiku-3-5',
+  'haiku-3':          'claude-haiku-3',
+  // short aliases the claude CLI itself accepts
+  'sonnet':           'sonnet',
+  'opus':             'opus',
+  'haiku':            'haiku',
+};
+
+function resolveModel(model) {
+  return MODEL_ALIASES[model] ?? model;
+}
+
+export async function callClaude(prompt, model) {
+  const resolvedModel = resolveModel(model);
+
+  // Full prompt = system prompt + user prompt, joined clearly
+  const fullPrompt = `${SYSTEM_PROMPT}\n\n---\n\n${prompt}`;
+
+  let output;
+  try {
+    output = execFileSync(
+      'claude',
+      [
+        '--print',                        // non-interactive, print and exit
+        '--output-format', 'text',        // plain text output
+        '--model', resolvedModel,
+        '--no-session-persistence',       // don't pollute session history
+        fullPrompt,
+      ],
+      {
+        encoding: 'utf8',
+        maxBuffer: 50 * 1024 * 1024,     // 50 MB
+        timeout:   120_000,              // 2 min timeout
+      }
+    );
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(
+        '`claude` command not found. Install Claude Code: https://claude.ai/code'
+      );
+    }
+    if (err.signal === 'SIGTERM') {
+      throw new Error('Claude timed out after 2 minutes. Try reducing the diff size.');
+    }
+    const stderr = err.stderr?.trim();
+    throw new Error(`claude CLI error: ${stderr || err.message}`);
+  }
+
+  return output.trim();
+}

package/src/cli.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+
+import readline from 'readline';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { loadConfig, saveConfig, showAndEditConfig } from './config.js';
+import { isGitRepo, getCurrentBranch, getDiff, getStagedDiff, getPRNumber } from './git.js';
+import { buildReviewPrompt } from './prompt.js';
+import { callAI } from './ai.js';
+import { saveReport, addMetadata } from './file.js';
+import { PROVIDERS, PROVIDER_LIST } from './providers/index.js';
+
+// ─── Argument parsing ────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+
+const flags = {
+  staged:   args.includes('--staged'),
+  help:     args.includes('--help') || args.includes('-h'),
+  version:  args.includes('--version') || args.includes('-v'),
+  config:   args[0] === 'config',
+  review:   args[0] === 'review',  // explicit subcommand (optional, same as default)
+  provider: args.find((a) => a.startsWith('--provider='))?.split('=')[1] ?? null,
+  model:    args.find((a) => a.startsWith('--model='))?.split('=')[1] ?? null,
+  focus:    args.find((a) => a.startsWith('--focus='))?.split('=')[1] ?? null,
+  output:   args.find((a) => a.startsWith('--output='))?.split('=')[1] ?? null,
+  base:     args.find((a) => a.startsWith('--base='))?.split('=')[1] ?? null,
+};
+
+// ─── Subcommand routing ───────────────────────────────────────────────────────
+
+if (flags.version) {
+  const { createRequire } = await import('module');
+  const require = createRequire(import.meta.url);
+  const pkg = require('../package.json');
+  console.log(`pr-review v${pkg.version}`);
+  process.exit(0);
+}
+
+if (flags.help) {
+  printHelp();
+  process.exit(0);
+}
+
+if (flags.config) {
+  await showAndEditConfig(chalk);
+  process.exit(0);
+}
+
+// ─── Main flow ────────────────────────────────────────────────────────────────
+
+await main();
+
+async function main() {
+  console.log(chalk.bold.cyan('\n┌─────────────────────────────────────┐'));
+  console.log(chalk.bold.cyan('   🔍  pr-review — AI Code Review         '));
+  console.log(chalk.bold.cyan('└─────────────────────────────────────┘\n'));
+
+  if (!isGitRepo()) {
+    fatal('Not inside a git repository. Run pr-review from your project root.');
+  }
+
+  const config = loadConfig();
+  console.log(chalk.dim('  Config: ~/.pr-review/config.json\n'));
+
+  // ── Select AI provider ─────────────────────────────────────────────────────
+
+  const selectedProviderKey = flags.provider
+    ? flags.provider
+    : await selectProvider(config.defaultProvider ?? 'claude');
+
+  const provider = PROVIDERS[selectedProviderKey];
+  if (!provider) fatal(`Unknown provider: "${selectedProviderKey}". Valid: ${Object.keys(PROVIDERS).join(', ')}`);
+
+  // ── Select model ───────────────────────────────────────────────────────────
+
+  const defaultModelForProvider =
+    config.defaultModels?.[selectedProviderKey] ?? provider.defaultModel;
+
+  const selectedModel = flags.model
+    ? flags.model
+    : await selectModel(provider, defaultModelForProvider);
+
+  // Persist last-used provider + model per provider
+  const updatedModels = { ...(config.defaultModels ?? {}), [selectedProviderKey]: selectedModel };
+  saveConfig({ ...config, defaultProvider: selectedProviderKey, defaultModels: updatedModels });
+
+  console.log('');
+
+  // ── Select branches ────────────────────────────────────────────────────────
+
+  let sourceBranch, destBranch;
+  const currentBranch = getCurrentBranch();
+
+  if (flags.staged) {
+    sourceBranch = '(staged changes)';
+    destBranch   = '(index)';
+  } else {
+    sourceBranch = await prompt(
+      `  Source branch     ${chalk.dim(`(default: ${chalk.yellow(currentBranch)})`)}: `,
+      currentBranch
+    );
+    destBranch = flags.base ?? await prompt(
+      `  Destination branch ${chalk.dim(`(default: ${chalk.yellow(config.defaultBaseBranch)})`)}: `,
+      config.defaultBaseBranch
+    );
+  }
+
+  // ── Detect PR number → determine output filename ───────────────────────────
+
+  const prNumber  = getPRNumber();
+  const outputFile = flags.output
+    ?? (prNumber ? `pr-${prNumber}-review.md` : config.outputFile);
+
+  if (prNumber) {
+    console.log(chalk.dim(`\n  🔗 PR #${prNumber} detected → output: ${chalk.yellow(outputFile)}`));
+  }
+
+  console.log('');
+
+  // ── Fetch diff ─────────────────────────────────────────────────────────────
+
+  let diff;
+  const spinner1 = ora({ text: 'Fetching git diff…', color: 'cyan' }).start();
+
+  try {
+    diff = flags.staged
+      ? getStagedDiff(config.ignoreFiles)
+      : getDiff(sourceBranch, destBranch, config.ignoreFiles);
+  } catch (err) {
+    spinner1.fail(chalk.red(`Diff failed: ${err.message}`));
+    process.exit(1);
+  }
+
+  if (!diff || diff.trim().length === 0) {
+    spinner1.warn(chalk.yellow('No changes found between the selected branches.'));
+    process.exit(0);
+  }
+
+  let truncated = false;
+  if (diff.length > config.maxDiffLength) {
+    diff      = diff.slice(0, config.maxDiffLength) + '\n\n[DIFF TRUNCATED — exceeded maxDiffLength]\n';
+    truncated = true;
+  }
+
+  spinner1.succeed(
+    chalk.green('Diff fetched') +
+    chalk.dim(` — ${diff.length.toLocaleString()} chars${truncated ? ' (truncated)' : ''}`)
+  );
+
+  // ── Build prompt ───────────────────────────────────────────────────────────
+
+  const reviewPrompt = buildReviewPrompt(sourceBranch, destBranch, diff, flags.focus);
+
+  // ── Call AI ────────────────────────────────────────────────────────────────
+
+  const spinner2 = ora({
+    text: `Calling ${provider.name} (${selectedModel})…`,
+    color: 'cyan',
+  }).start();
+
+  let reviewText;
+  try {
+    reviewText = await callAI(reviewPrompt, selectedProviderKey, selectedModel);
+    spinner2.succeed(chalk.green(`${provider.name} review received`));
+  } catch (err) {
+    spinner2.fail(chalk.red(`${provider.name} error: ${err.message}`));
+    process.exit(1);
+  }
+
+  // ── Write report ───────────────────────────────────────────────────────────
+
+  const spinner3 = ora({ text: 'Writing report…', color: 'cyan' }).start();
+  let outputPath;
+
+  try {
+    const finalContent = addMetadata(reviewText, {
+      sourceBranch,
+      destBranch,
+      provider:   provider.name,
+      model:      selectedModel,
+      prNumber,
+      diffLength: diff.length,
+      generatedAt: new Date().toISOString(),
+    });
+
+    outputPath = saveReport(finalContent, outputFile);
+    spinner3.succeed(chalk.green('Report saved') + chalk.dim(` → ${outputPath}`));
+  } catch (err) {
+    spinner3.fail(chalk.red(`Failed to write report: ${err.message}`));
+    process.exit(1);
+  }
+
+  // ── Done ───────────────────────────────────────────────────────────────────
+
+  console.log('');
+  console.log(chalk.bold.green('✅ PR Review complete!'));
+  if (prNumber) {
+    console.log(chalk.dim(`   PR #${prNumber} · ${provider.name} · ${selectedModel}`));
+  }
+  console.log(chalk.dim(`   Open ${outputPath} to read the review.\n`));
+}
+
+// ─── Provider selection ───────────────────────────────────────────────────────
+
+async function selectProvider(defaultProvider) {
+  const defaultIndex = PROVIDER_LIST.findIndex((p) => p.key === defaultProvider);
+  const safeDefault  = defaultIndex >= 0 ? defaultIndex : 0;
+
+  const items = PROVIDER_LIST.map((p) => ({ label: p.label, description: p.description }));
+  const idx   = await arrowSelect('Select AI provider:', items, safeDefault);
+
+  const chosen = PROVIDER_LIST[idx];
+  console.log(chalk.dim(`  → ${chosen.label}\n`));
+  return chosen.key;
+}
+
+// ─── Model selection ──────────────────────────────────────────────────────────
+
+async function selectModel(provider, defaultModel) {
+  const defaultIndex = provider.models.findIndex((m) => m.id === defaultModel);
+  const safeDefault  = defaultIndex >= 0 ? defaultIndex : 0;
+
+  const items = provider.models.map((m) => ({ label: m.label }));
+  const idx   = await arrowSelect(`Select ${provider.name} model:`, items, safeDefault);
+
+  const chosen = provider.models[idx];
+  console.log(chalk.dim(`  → ${chosen.id}\n`));
+  return chosen.id;
+}
+
+// ─── Arrow-key list selector ──────────────────────────────────────────────────
+
+function arrowSelect(title, items, defaultIdx = 0) {
+  console.log(chalk.bold(`  ${title}\n`));
+
+  // Fallback to plain prompt when stdin is not a TTY (e.g. piped)
+  if (!process.stdin.isTTY) {
+    items.forEach((item, i) => {
+      const marker = i === defaultIdx ? chalk.cyan('❯') : ' ';
+      const label  = chalk.dim(item.label) + (item.description ? chalk.dim(` — ${item.description}`) : '');
+      console.log(`  ${marker} ${label}`);
+    });
+    return Promise.resolve(defaultIdx);
+  }
+
+  let idx = defaultIdx;
+
+  const render = (first) => {
+    if (!first) process.stdout.write(`\x1b[${items.length}A`);
+    for (let i = 0; i < items.length; i++) {
+      const active = i === idx;
+      const cursor = active ? chalk.cyan('❯') : ' ';
+      const label  = active ? chalk.bold.white(items[i].label) : chalk.dim(items[i].label);
+      const desc   = items[i].description ? chalk.dim(` — ${items[i].description}`) : '';
+      process.stdout.write(`  ${cursor} ${label}${desc}\x1b[K\n`);
+    }
+  };
+
+  render(true);
+
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    const onData = (key) => {
+      if (key === '\u0003') {                        // Ctrl-C
+        process.stdin.setRawMode(false);
+        process.exit(0);
+      } else if (key === '\u001b[A' || key === 'k') { // Up / k
+        idx = (idx - 1 + items.length) % items.length;
+        render(false);
+      } else if (key === '\u001b[B' || key === 'j') { // Down / j
+        idx = (idx + 1) % items.length;
+        render(false);
+      } else if (key === '\r' || key === '\n') {     // Enter
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('data', onData);
+        process.stdin.pause();
+        process.stdout.write('\n');
+        resolve(idx);
+      }
+    };
+
+    process.stdin.on('data', onData);
+  });
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function prompt(question, defaultValue = '') {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+function fatal(message) {
+  console.error('\n' + chalk.red('✖ ') + message + '\n');
+  process.exit(1);
+}
+
+function printHelp() {
+  console.log(`
+${chalk.bold.cyan('pr-review')} — AI-powered Pull Request reviews
+
+${chalk.bold('USAGE')}
+  ${chalk.cyan('pr-review')}                                 Interactive PR review
+  ${chalk.cyan('pr-review review')}                          Explicit review subcommand (same as above)
+  ${chalk.cyan('pr-review config')}                          View and edit global config
+  ${chalk.cyan('pr-review review --staged')}                 Review staged (uncommitted) changes
+  ${chalk.cyan('pr-review review --provider=<provider>')}    Skip provider prompt
+  ${chalk.cyan('pr-review review --model=<model>')}          Skip model prompt
+  ${chalk.cyan('pr-review review --base=<branch>')}          Override destination/base branch
+  ${chalk.cyan('pr-review review --focus=<area>')}           Focus: security, performance, etc.
+  ${chalk.cyan('pr-review review --output=<file>')}          Override output file name
+  ${chalk.cyan('pr-review --help')}                          Show this help
+  ${chalk.cyan('pr-review --version')}                       Show version
+
+${chalk.bold('PROVIDERS')}
+  ${chalk.cyan('claude')}    claude CLI  — claude-sonnet-4-6, claude-opus-4-6, claude-haiku-4-5
+  ${chalk.cyan('copilot')}   copilot CLI — claude-sonnet-4.6, gpt-5.4, claude-opus-4.6, gpt-5.4-mini
+  ${chalk.cyan('codex')}     codex CLI   — gpt-5.4, o3, o4-mini, gpt-4.1
+  ${chalk.cyan('gemini')}    gemini CLI  — flash, pro, flash-lite
+  ${chalk.cyan('cursor')}    agent CLI   — install Cursor + add \`agent\` to PATH
+
+${chalk.bold('PR NUMBER')}
+  If a GitHub PR is open for the current branch (\`gh pr view\`),
+  the output file is automatically named ${chalk.yellow('pr-<number>-review.md')}.
+
+${chalk.bold('CONFIG')}
+  ${chalk.dim('~/.pr-review/config.json')}   Auto-created on first run
+  Last-used provider and model per provider are remembered.
+
+${chalk.bold('EXAMPLES')}
+  ${chalk.dim('# Standard interactive review')}
+  pr-review
+
+  ${chalk.dim('# Explicit review subcommand')}
+  pr-review review
+
+  ${chalk.dim('# Skip all prompts')}
+  pr-review review --provider=copilot --model=gpt-5.4 --base=develop
+
+  ${chalk.dim('# Security-focused review of staged changes')}
+  pr-review review --staged --focus=security
+
+  ${chalk.dim('# Most capable model with custom output file')}
+  pr-review review --provider=claude --model=claude-opus-4-6 --output=deep-review.md
+`);
+}

package/src/config.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import readline from 'readline';
+
+export const CONFIG_DIR = path.join(os.homedir(), '.pr-review');
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export const DEFAULT_CONFIG = {
+  defaultProvider: 'claude',
+  defaultModels: {
+    claude:  'claude-sonnet-4-5',
+    copilot: 'default',
+    codex:   'default',
+    gemini:  'flash',
+    cursor:  'default',
+  },
+  defaultBaseBranch: 'main',
+  maxDiffLength: 100000,
+  ignoreFiles: ['package-lock.json', 'yarn.lock'],
+  outputFile: 'pr-review-review.md',
+  strictMode: true,
+};
+
+export function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function loadConfig() {
+  ensureConfigDir();
+
+  if (!fs.existsSync(CONFIG_FILE)) {
+    saveConfig(DEFAULT_CONFIG);
+    return { ...DEFAULT_CONFIG };
+  }
+
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    // Merge with defaults so new keys are always present
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+
+export function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+}
+
+export function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+function ask(rl, question, defaultValue) {
+  return new Promise((resolve) => {
+    rl.question(`  ${question} [${defaultValue}]: `, (answer) => {
+      const trimmed = answer.trim();
+      resolve(trimmed === '' ? String(defaultValue) : trimmed);
+    });
+  });
+}
+
+export async function showAndEditConfig(chalk) {
+  const config = loadConfig();
+
+  console.log(chalk.bold('\nCurrent configuration:'));
+  console.log(chalk.dim(`  File: ${CONFIG_FILE}\n`));
+  console.log(JSON.stringify(config, null, 2));
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  console.log(chalk.bold('Update values') + chalk.dim(' (press Enter to keep current):\n'));
+
+  const newModel      = await ask(rl, 'Default model      ', config.defaultModel);
+  const newBranch     = await ask(rl, 'Default base branch', config.defaultBaseBranch);
+  const newMaxDiff    = await ask(rl, 'Max diff length    ', config.maxDiffLength);
+  const newOutputFile = await ask(rl, 'Output file        ', config.outputFile);
+  const newStrictMode = await ask(rl, 'Strict mode        ', config.strictMode);
+  const newIgnore     = await ask(rl, 'Ignore files (csv) ', config.ignoreFiles.join(','));
+
+  rl.close();
+
+  const updated = {
+    ...config,
+    defaultModel:      newModel,
+    defaultBaseBranch: newBranch,
+    maxDiffLength:     parseInt(newMaxDiff, 10) || config.maxDiffLength,
+    outputFile:        newOutputFile,
+    strictMode:        newStrictMode === 'true',
+    ignoreFiles:       newIgnore.split(',').map((f) => f.trim()).filter(Boolean),
+  };
+
+  saveConfig(updated);
+  console.log('\n' + chalk.green('✔ Config saved.\n'));
+  console.log(JSON.stringify(updated, null, 2));
+  console.log('');
+}

package/src/file.js

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+
+export function saveReport(content, outputFile) {
+  const outputPath = path.resolve(process.cwd(), outputFile);
+  fs.writeFileSync(outputPath, content, 'utf8');
+  return outputPath;
+}
+
+export function addMetadata(reviewText, meta) {
+  const { sourceBranch, destBranch, provider, model, prNumber, diffLength, generatedAt } = meta;
+
+  const lines = [
+    '---',
+    `<!-- Generated by pr-review on ${generatedAt} -->`,
+    `<!-- Provider: ${provider} | Model: ${model} | Diff: ${diffLength} chars | ${sourceBranch} → ${destBranch} -->`,
+  ];
+  if (prNumber) lines.push(`<!-- PR: #${prNumber} -->`);
+  lines.push('---', '');
+
+  return lines.join('\n') + reviewText;
+}

package/src/git.js

@@ -0,0 +1,83 @@
+import { execSync } from 'child_process';
+
+export function getPRNumber() {
+  try {
+    const result = execSync('gh pr view --json number --jq .number', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+    const num = parseInt(result, 10);
+    return isNaN(num) ? null : num;
+  } catch {
+    return null; // No open PR, gh not installed, or not authenticated
+  }
+}
+
+export function isGitRepo() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { encoding: 'utf8', stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getCurrentBranch() {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8', stdio: 'pipe' }).trim();
+  } catch {
+    throw new Error('Unable to detect current branch. Is this a git repository?');
+  }
+}
+
+export function branchExists(branch) {
+  try {
+    execSync(`git rev-parse --verify "${branch}"`, { encoding: 'utf8', stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getDiff(sourceBranch, destBranch, ignoreFiles = []) {
+  if (!branchExists(sourceBranch)) {
+    throw new Error(`Branch not found: "${sourceBranch}"`);
+  }
+  if (!branchExists(destBranch)) {
+    throw new Error(`Branch not found: "${destBranch}"`);
+  }
+
+  try {
+    let cmd = `git diff "${destBranch}...${sourceBranch}"`;
+
+    if (ignoreFiles.length > 0) {
+      const exclusions = ignoreFiles.map((f) => `':(exclude)${f}'`).join(' ');
+      cmd += ` -- . ${exclusions}`;
+    }
+
+    return execSync(cmd, {
+      encoding: 'utf8',
+      maxBuffer: 100 * 1024 * 1024,
+    });
+  } catch (err) {
+    throw new Error(`git diff failed: ${err.message}`);
+  }
+}
+
+export function getStagedDiff(ignoreFiles = []) {
+  try {
+    let cmd = 'git diff --staged';
+
+    if (ignoreFiles.length > 0) {
+      const exclusions = ignoreFiles.map((f) => `':(exclude)${f}'`).join(' ');
+      cmd += ` -- . ${exclusions}`;
+    }
+
+    return execSync(cmd, {
+      encoding: 'utf8',
+      maxBuffer: 100 * 1024 * 1024,
+    });
+  } catch (err) {
+    throw new Error(`git diff --staged failed: ${err.message}`);
+  }
+}

package/src/prompt.js

@@ -0,0 +1,68 @@
+export const SYSTEM_PROMPT = `You are a principal software engineer performing a rigorous pull request review.
+
+Your reviews are:
+- Precise, technical, and evidence-based — cite specific file paths and line context from the diff
+- Comprehensive — cover correctness, security, performance, maintainability, and test coverage
+- Actionable — every issue must include a clear recommendation
+- Honest — if code is well-written, say so; do not invent issues
+
+You output reviews in strict Markdown with exactly the sections specified. No preamble, no postamble.`;
+
+export function buildReviewPrompt(sourceBranch, destBranch, diff, focus = null) {
+  const focusInstruction = focus
+    ? `\n> **Special focus requested:** Prioritize **${focus}**-related issues throughout the review.\n`
+    : '';
+
+  return `You are reviewing a Pull Request merging \`${sourceBranch}\` into \`${destBranch}\`.
+${focusInstruction}
+Analyze the git diff below and produce a structured code review in the exact Markdown format specified.
+
+<git_diff>
+\`\`\`diff
+${diff}
+\`\`\`
+</git_diff>
+
+---
+
+Respond using **exactly** this structure:
+
+# PR Review: \`${sourceBranch}\` → \`${destBranch}\`
+
+## Summary
+_2–4 sentences describing what this PR does, its scope, and overall quality._
+
+## Critical Issues
+_Bugs, breaking changes, data-loss risks, or anything that MUST be fixed before merge._
+_Format each item as:_ **[CRITICAL]** \`path/to/file.ext\` — Description and fix recommendation.
+_If none: "No critical issues found."_
+
+## Security
+_Auth bypasses, injection risks, secret exposure, insecure defaults, etc._
+_Format each item as:_ **[HIGH|MEDIUM|LOW]** \`path/to/file.ext\` — Description and fix recommendation.
+_If none: "No security issues found."_
+
+## Performance
+_Algorithmic complexity, unnecessary re-renders, N+1 queries, blocking I/O, memory leaks._
+_Format each item as:_ **[HIGH|MEDIUM|LOW]** \`path/to/file.ext\` — Description and fix recommendation.
+_If none: "No performance issues found."_
+
+## Code Quality & Improvements
+_Anti-patterns, duplication, poor naming, overly complex logic, missing error handling._
+- Description with specific recommendation.
+_If none: "No code quality issues found."_
+
+## Test Coverage
+_Missing unit tests, edge cases not covered, untested error paths._
+- Description of what should be tested.
+_If none: "Test coverage appears adequate."_
+
+## Suggestions
+_Non-blocking improvements, best practices, minor style notes._
+- Suggestion.
+
+## Final Verdict
+**[APPROVE | REQUEST CHANGES | NEEDS DISCUSSION]**
+
+_2–3 sentence justification for your verdict._`;
+}

package/src/providers/claude.js

@@ -0,0 +1,23 @@
+import { execFileSync } from 'child_process';
+import { SYSTEM_PROMPT } from '../prompt.js';
+
+export async function callClaude(prompt, model) {
+  const fullPrompt = `${SYSTEM_PROMPT}\n\n---\n\n${prompt}`;
+  let output;
+  try {
+    output = execFileSync(
+      'claude',
+      ['--print', '--output-format', 'text', '--model', model, '--no-session-persistence', fullPrompt],
+      { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024, timeout: 120_000 }
+    );
+  } catch (err) {
+    if (err.code === 'ENOENT') throw new Error('`claude` not found. Install Claude Code: https://claude.ai/code');
+    if (err.signal === 'SIGTERM') throw new Error('Claude timed out after 2 minutes. Try a smaller diff.');
+    const detail = err.stderr?.trim() || err.stdout?.trim() || '';
+    if (/auth|token|expired|401|login/i.test(detail)) {
+      throw new Error('Claude authentication expired. Run `claude` to re-authenticate, then try again.');
+    }
+    throw new Error(`claude CLI error: ${detail || 'unknown error (run `claude` to check status)'}`);
+  }
+  return output.trim();
+}

package/src/providers/codex.js

@@ -0,0 +1,39 @@
+import { execFileSync } from 'child_process';
+import { SYSTEM_PROMPT } from '../prompt.js';
+
+export async function callCodex(prompt, model) {
+  const fullPrompt = `${SYSTEM_PROMPT}\n\n---\n\n${prompt}`;
+
+  // -q  quiet / non-interactive mode (no TUI, outputs response to stdout)
+  // --approval-mode suggest  read-only agent: proposes but never auto-executes
+  const cliArgs = ['-q', '--approval-mode', 'suggest'];
+
+  if (model && model !== 'default') {
+    cliArgs.push('--model', model);
+  }
+
+  cliArgs.push(fullPrompt);
+
+  let output;
+  try {
+    output = execFileSync('codex', cliArgs, {
+      encoding:  'utf8',
+      maxBuffer: 50 * 1024 * 1024,
+      timeout:   180_000, // 3 min — codex reasoning models can be slow
+    });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(
+        '`codex` not found. Install: npm install -g @openai/codex\n' +
+        '  Then run: codex  (and sign in on first launch)'
+      );
+    }
+    if (err.signal === 'SIGTERM') {
+      throw new Error('Codex timed out after 3 minutes. Try reducing the diff size.');
+    }
+    const stderr = err.stderr?.trim();
+    throw new Error(`codex CLI error: ${stderr || err.message}`);
+  }
+
+  return output.trim();
+}

package/src/providers/copilot.js

@@ -0,0 +1,38 @@
+import { execFileSync } from 'child_process';
+import { SYSTEM_PROMPT } from '../prompt.js';
+
+export async function callCopilot(prompt, model) {
+  const fullPrompt = `${SYSTEM_PROMPT}\n\n---\n\n${prompt}`;
+
+  // -p  non-interactive (exits after response)
+  // -s  output only the agent response (no stats/spinners) — perfect for scripting
+  const cliArgs = ['-p', fullPrompt, '-s'];
+
+  if (model && model !== 'default') {
+    cliArgs.push('--model', model);
+  }
+
+  let output;
+  try {
+    output = execFileSync('copilot', cliArgs, {
+      encoding:  'utf8',
+      maxBuffer: 50 * 1024 * 1024,
+      timeout:   120_000,
+    });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(
+        '`copilot` not found. Install: npm install -g @github/copilot\n' +
+        '  Then run: copilot /login'
+      );
+    }
+    if (err.signal === 'SIGTERM') {
+      throw new Error('Copilot CLI timed out after 2 minutes. Try reducing the diff size.');
+    }
+    const stderr = err.stderr?.trim();
+    throw new Error(`copilot CLI error: ${stderr || err.message}`);
+  }
+
+  return output.trim();
+}
+

package/src/providers/cursor.js

@@ -0,0 +1,39 @@
+import { execFileSync } from 'child_process';
+import { SYSTEM_PROMPT } from '../prompt.js';
+
+export async function callCursor(prompt, model) {
+  const fullPrompt = `${SYSTEM_PROMPT}\n\n---\n\n${prompt}`;
+
+  // -p / --print  non-interactive, prints response to stdout
+  // --mode=ask    read-only exploration — agent won't edit any files
+  // --output-format text  plain text (not JSON)
+  const cliArgs = ['-p', fullPrompt, '--mode=ask', '--output-format', 'text'];
+
+  if (model && model !== 'default') {
+    cliArgs.push('--model', model);
+  }
+
+  let output;
+  try {
+    output = execFileSync('agent', cliArgs, {
+      encoding:  'utf8',
+      maxBuffer: 50 * 1024 * 1024,
+      timeout:   120_000,
+    });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(
+        '`agent` not found. Install Cursor and ensure the CLI is in your PATH.\n' +
+        '  macOS: open Cursor → Cmd+Shift+P → "Install cursor/agent in PATH"'
+      );
+    }
+    if (err.signal === 'SIGTERM') {
+      throw new Error('Cursor agent timed out after 2 minutes. Try reducing the diff size.');
+    }
+    const stderr = err.stderr?.trim();
+    throw new Error(`agent CLI error: ${stderr || err.message}`);
+  }
+
+  return output.trim();
+}
+

package/src/providers/gemini.js

@@ -0,0 +1,38 @@
+import { execFileSync } from 'child_process';
+import { SYSTEM_PROMPT } from '../prompt.js';
+
+export async function callGemini(prompt, model) {
+  const fullPrompt = `${SYSTEM_PROMPT}\n\n---\n\n${prompt}`;
+
+  // -p  non-interactive (exits after response)
+  // -o text  plain text output (default, but explicit is safer)
+  const cliArgs = ['-p', fullPrompt, '-o', 'text'];
+
+  if (model && model !== 'default') {
+    cliArgs.push('-m', model);
+  }
+
+  let output;
+  try {
+    output = execFileSync('gemini', cliArgs, {
+      encoding:  'utf8',
+      maxBuffer: 50 * 1024 * 1024,
+      timeout:   120_000,
+    });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(
+        '`gemini` not found. Install: npm install -g @google/gemini-cli\n' +
+        '  Then run: gemini  (and authenticate on first launch)'
+      );
+    }
+    if (err.signal === 'SIGTERM') {
+      throw new Error('Gemini CLI timed out after 2 minutes. Try reducing the diff size.');
+    }
+    const stderr = err.stderr?.trim();
+    throw new Error(`gemini CLI error: ${stderr || err.message}`);
+  }
+
+  return output.trim();
+}
+

package/src/providers/index.js

@@ -0,0 +1,80 @@
+export const PROVIDERS = {
+  // claude CLI: model IDs use dashes (e.g. claude-sonnet-4-6)
+  claude: {
+    key:          'claude',
+    name:         'Claude',
+    label:        'Claude (Anthropic)',
+    description:  'Uses local claude CLI — no API key needed',
+    defaultModel: 'claude-sonnet-4-6',
+    models: [
+      { id: 'claude-sonnet-4-6', label: 'claude-sonnet-4-6  · Recommended' },
+      { id: 'claude-opus-4-6',   label: 'claude-opus-4-6    · Most capable' },
+      { id: 'claude-haiku-4-5',  label: 'claude-haiku-4-5   · Fastest' },
+      { id: 'claude-sonnet-4-5', label: 'claude-sonnet-4-5' },
+      { id: 'claude-sonnet-4',   label: 'claude-sonnet-4' },
+    ],
+  },
+  // copilot CLI: model IDs use periods (e.g. claude-sonnet-4.6, gpt-5.4)
+  copilot: {
+    key:          'copilot',
+    name:         'GitHub Copilot',
+    label:        'GitHub Copilot',
+    description:  'Uses copilot CLI — run `copilot /login` first',
+    defaultModel: 'claude-sonnet-4.6',
+    models: [
+      { id: 'claude-sonnet-4.6', label: 'claude-sonnet-4.6  · Recommended' },
+      { id: 'claude-opus-4.6',   label: 'claude-opus-4.6    · Most capable' },
+      { id: 'gpt-5.4',           label: 'gpt-5.4            · Standard' },
+      { id: 'gpt-5.2',           label: 'gpt-5.2            · Standard' },
+      { id: 'claude-haiku-4.5',  label: 'claude-haiku-4.5   · Fast/cheap' },
+      { id: 'gpt-5.4-mini',      label: 'gpt-5.4-mini       · Fast/cheap' },
+      { id: 'gpt-4.1',           label: 'gpt-4.1            · Fast/cheap' },
+    ],
+  },
+  // codex CLI: model IDs from ~/.codex/config.toml and codex help examples
+  codex: {
+    key:          'codex',
+    name:         'Codex',
+    label:        'OpenAI Codex',
+    description:  'Uses codex CLI — run `codex` once to sign in',
+    defaultModel: 'gpt-5.4',
+    models: [
+      { id: 'gpt-5.4',  label: 'gpt-5.4   · Recommended' },
+      { id: 'o3',       label: 'o3        · Reasoning' },
+      { id: 'o4-mini',  label: 'o4-mini   · Fast reasoning' },
+      { id: 'gpt-4.1',  label: 'gpt-4.1   · Cheaper' },
+    ],
+  },
+  // gemini CLI: uses short aliases (flash, pro, flash-lite, auto)
+  gemini: {
+    key:          'gemini',
+    name:         'Gemini',
+    label:        'Google Gemini',
+    description:  'Uses gemini CLI — run `gemini` once to authenticate',
+    defaultModel: 'flash',
+    models: [
+      { id: 'flash',      label: 'flash      · gemini-2.5-flash (Recommended)' },
+      { id: 'pro',        label: 'pro        · gemini-2.5-pro (Most capable)' },
+      { id: 'flash-lite', label: 'flash-lite · gemini-2.5-flash-lite (Fastest)' },
+      { id: 'auto',       label: 'auto       · Auto-select best available' },
+    ],
+  },
+  // cursor agent CLI: model IDs (install Cursor + add agent binary to PATH)
+  cursor: {
+    key:          'cursor',
+    name:         'Cursor',
+    label:        'Cursor',
+    description:  'Uses agent CLI — install Cursor + add agent to PATH',
+    defaultModel: 'default',
+    models: [
+      { id: 'default',           label: 'Default (your Cursor plan model)' },
+      { id: 'claude-sonnet-4-6', label: 'claude-sonnet-4-6' },
+      { id: 'gpt-5.4',           label: 'gpt-5.4' },
+      { id: 'gemini-2.5-pro',    label: 'gemini-2.5-pro' },
+      { id: 'o3',                label: 'o3                · Reasoning' },
+    ],
+  },
+};
+
+export const PROVIDER_LIST = Object.values(PROVIDERS);
+

package/src/providers/openai.js

@@ -0,0 +1,3 @@
+// openai.js has been superseded by codex.js which uses the Codex CLI.
+// This file is kept for reference only and is not imported anywhere.
+