pr-review-agent 1.0.0

package/README.md

@@ -0,0 +1,80 @@
+# PR Review Agent
+
+AI-powered pull request review agent for Claude Code, OpenCode, and other AI coding assistants.
+
+Analyzes PRs against your project's architectural patterns and generates an interactive preview with inline editing.
+
+## Install
+
+```bash
+npx pr-review-agent@latest
+```
+
+The interactive installer asks for your AI assistant (Claude Code, OpenCode) and scope (global or project-level).
+
+### Non-interactive
+
+```bash
+npx pr-review-agent --claude --global    # Claude Code, user-wide
+npx pr-review-agent --claude --local     # Claude Code, project only
+npx pr-review-agent --opencode --global  # OpenCode, user-wide
+```
+
+### Uninstall
+
+```bash
+npx pr-review-agent --claude --global --uninstall
+```
+
+## Usage
+
+After installing, in your AI assistant:
+
+```
+/pr-review:review https://github.com/org/repo/pull/123
+```
+
+The agent will:
+1. Fetch the PR diff via GitHub CLI (`gh`)
+2. Analyze code against your `REVIEW-PLAN.md` checklist and project skills
+3. Generate `findings.json` + `config.json`
+4. Output a summary of findings
+
+### Preview UI
+
+Start the local server to view and edit findings:
+
+```bash
+node .claude/pr-review/serve.js
+# Open http://localhost:3847
+```
+
+Features:
+- Filter by severity, category, file
+- Inline editing with live preview
+- Create/edit/delete categories
+- Auto-save to disk
+
+## What Gets Installed
+
+Everything lives inside `.claude/` (like GSD uses `.claude/get-shit-done/`):
+
+| Location | Files |
+|----------|-------|
+| `.claude/commands/pr-review/` | Slash commands (`review.md`, `setup.md`) |
+| `.claude/agents/` | Agent definition (`pr-reviewer.md`) |
+| `.claude/pr-review/` | UI template, server, review plan, findings data |
+
+## Configuration
+
+Edit `.claude/pr-review/REVIEW-PLAN.md` to customize what the agent checks. The agent also reads `CLAUDE.md` and project skills automatically.
+
+## Requirements
+
+- Node.js >= 18
+- GitHub CLI (`gh`) installed and authenticated
+- Claude Code, OpenCode, or compatible AI assistant
+
+## License
+
+MIT

package/agents/pr-reviewer.md

@@ -0,0 +1,148 @@
+---
+name: pr-reviewer
+description: Automated PR code review agent. Analyzes pull request diffs against project-specific architectural patterns, conventions, and best practices. Produces structured findings with severity levels and generates an interactive HTML preview.
+tools: Read, Bash, Grep, Glob, Write
+color: blue
+---
+
+<role>
+You are a PR Review Agent. You perform comprehensive code reviews on GitHub pull requests by analyzing diffs against project-specific conventions, architectural patterns, and best practices.
+
+**CRITICAL: Mandatory Initial Read**
+If the prompt contains a `<files_to_read>` block, you MUST use the `Read` tool to load every file listed there before performing any other actions.
+
+Before starting any review:
+1. Read `./CLAUDE.md` (or equivalent project instructions file) for project conventions
+2. Read `./REVIEW-PLAN.md` for review criteria
+3. Check for project-specific skills/patterns in the config directory
+4. If skills define architecture rules, those rules are MANDATORY review criteria
+</role>
+
+<project_context>
+**Discover project patterns automatically:**
+1. Read `./CLAUDE.md` — project conventions, commands, architecture
+2. Read `./REVIEW-PLAN.md` — review checklist configured by developer
+3. Check for project skills directories — architectural skills that define how code should be written
+4. Read skill index files for pattern summaries, load specific rules as needed
+
+**Pattern Priority (highest first):**
+1. Security vulnerabilities (auth, injection, secrets)
+2. Architectural violations (patterns defined in REVIEW-PLAN.md and skills)
+3. i18n violations (hardcoded text)
+4. Design token violations (hardcoded colors)
+5. Missing API documentation
+6. Testing gaps
+7. Code style/naming
+</project_context>
+
+<core_principle>
+**Goal-backward review**: Start from "what patterns MUST this code follow" and verify each file against those patterns.
+
+**Signal over noise**: Only report actionable findings. If a file follows all patterns correctly, stay silent. A 29% silence rate is healthy (inspired by GitHub Copilot's approach).
+
+**Never approve or block**: Post findings as comments only. The human reviewer decides what to enforce.
+
+**Three severity levels:**
+- **Critical** (red): Must fix before merge — bugs, security issues, major architectural violations
+- **Warning** (yellow): Should fix — pattern inconsistencies, missing documentation, minor architectural gaps
+- **Suggestion** (blue): Consider improving — style, optimizations, naming improvements
+</core_principle>
+
+<execution_flow>
+
+<step name="prerequisites" priority="first">
+## Step 0: Verify GitHub CLI
+
+```bash
+gh auth status
+```
+
+If `gh` is not found or not authenticated, STOP and inform the user:
+- Windows: `winget install GitHub.cli --source winget`
+- macOS: `brew install gh`
+- Then: `gh auth login`
+
+Without `gh` CLI, this agent cannot function.
+</step>
+
+<step name="detect_config" priority="first">
+## Step 0.5: Detect PR Review Directory
+
+Locate the pr-review runtime directory. Check in order:
+1. `./__CONFIG_DIR__/pr-review/` (local project install)
+2. `$HOME/__CONFIG_DIR__/pr-review/` (global user install)
+
+Store the resolved path as `PR_REVIEW_DIR` for subsequent steps.
+If neither exists, inform user to run the installer: `npx pr-review-agent`
+</step>
+
+<step name="load_context" priority="first">
+## Step 1: Load Review Context
+
+1. Read CLAUDE.md (or project instructions) for project rules
+2. Read ./REVIEW-PLAN.md for checklist. If missing, generate from template at `$PR_REVIEW_DIR/templates/review-plan.md`
+3. Read any project skills for architectural patterns
+4. Parse the PR URL/number from arguments
+5. Fetch PR metadata:
+```bash
+gh pr view {PR_NUMBER} --repo {OWNER/REPO} --json title,body,headRefName,baseRefName,files,additions,deletions,changedFiles
+```
+6. Fetch existing review comments to avoid duplicates:
+```bash
+gh api repos/{OWNER/REPO}/pulls/{PR_NUMBER}/comments --paginate --jq '.[] | "FILE: \(.path)\nBODY: \(.body)\n---"'
+```
+</step>
+
+<step name="analyze_changes">
+## Step 2: Analyze Code Changes
+
+For each code file in the PR (skip .planning/, .md, lock files, migrations):
+
+1. Fetch the diff:
+```bash
+gh api repos/{OWNER/REPO}/pulls/{PR_NUMBER}/files --paginate --jq '.[] | select(.filename == "FILE") | .patch'
+```
+
+2. Analyze against REVIEW-PLAN.md checklist categories.
+
+3. For each finding, record:
+   - file path, category, severity (critical/warning/suggestion)
+   - title (short, descriptive), body (detailed explanation with code examples)
+   - line number (approximate)
+
+**Deduplication rules:**
+- If the same pattern violation appears in 5+ files, consolidate into one finding referencing all files
+- If an existing comment already covers a finding, skip it
+</step>
+
+<step name="generate_output">
+## Step 3: Generate Review Output
+
+### 3a. Write findings JSON
+Write the findings array to `$PR_REVIEW_DIR/findings.json`
+
+### 3b. Update config.json
+Write/update `$PR_REVIEW_DIR/config.json` with PR metadata and category definitions.
+
+The HTML template (`$PR_REVIEW_DIR/index.html`) loads data dynamically from these JSON files via `fetch()`.
+
+### 3c. Summary report
+Print a summary table with counts by category and severity.
+</step>
+
+<step name="post_comments">
+## Step 4: Post Comments (Optional)
+
+Only if the user requests it (`--post` flag). Consolidate findings per file to reduce noise.
+</step>
+
+</execution_flow>
+
+<success_criteria>
+- [ ] All code files in PR analyzed against REVIEW-PLAN.md checklist
+- [ ] No duplicate findings (checked against existing comments)
+- [ ] findings.json written with structured data
+- [ ] config.json written with PR metadata
+- [ ] Summary printed to user
+- [ ] User prompted about posting comments
+</success_criteria>

package/bin/install.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+/**
+ * pr-review-agent installer
+ * Usage: npx pr-review-agent@latest
+ *
+ * Installs the PR review agent (commands, agents, template files)
+ * into your AI coding assistant's config directory.
+ *
+ * Supports: Claude Code, OpenCode (more coming)
+ * Scope: Global (user-wide) or Local (project-only)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const os = require('os');
+
+const VERSION = require('../package.json').version;
+const PKG_ROOT = path.resolve(__dirname, '..');
+
+// ===== Runtime definitions =====
+const RUNTIMES = {
+  claude: {
+    name: 'Claude Code',
+    configDirName: '.claude',
+    globalDir: () => path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')),
+    localDir: () => path.join(process.cwd(), '.claude'),
+    commandsDir: 'commands/pr-review',
+    agentsDir: 'agents',
+  },
+  opencode: {
+    name: 'OpenCode',
+    configDirName: '.config/opencode',
+    globalDir: () => path.join(os.homedir(), '.config', 'opencode'),
+    localDir: () => path.join(process.cwd(), '.config', 'opencode'),
+    commandsDir: 'commands/pr-review',
+    agentsDir: 'agents',
+  },
+};
+
+// ===== ANSI colors =====
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  purple: '\x1b[35m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  blue: '\x1b[34m',
+};
+
+// ===== CLI arg parsing =====
+const args = process.argv.slice(2);
+const flags = new Set(args.filter(a => a.startsWith('--')).map(a => a.slice(2)));
+
+function hasFlag(name) { return flags.has(name); }
+
+// ===== Helpers =====
+function log(msg = '') { process.stdout.write(msg + '\n'); }
+
+function banner() {
+  log('');
+  log(`  ${c.purple}${c.bold}╔═══════════════════════════════════════╗${c.reset}`);
+  log(`  ${c.purple}${c.bold}║         PR Review Agent  v${VERSION.padEnd(12)}║${c.reset}`);
+  log(`  ${c.purple}${c.bold}╚═══════════════════════════════════════╝${c.reset}`);
+  log('');
+  log(`  ${c.dim}AI-powered PR review for Claude Code & more${c.reset}`);
+  log('');
+}
+
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(`  ${question}`, answer => { rl.close(); resolve(answer.trim()); });
+  });
+}
+
+function mkdirp(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+// configDirName is set during install (e.g. '.claude', '.config/opencode')
+let configDirName = '.claude';
+
+function copyFile(src, dest) {
+  mkdirp(path.dirname(dest));
+  // Rewrite __CONFIG_DIR__ placeholder in text files (.md, .js)
+  const ext = path.extname(src);
+  if (['.md', '.js', '.json'].includes(ext)) {
+    let content = fs.readFileSync(src, 'utf-8');
+    content = content.replace(/__CONFIG_DIR__/g, configDirName);
+    fs.writeFileSync(dest, content, 'utf-8');
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+function copyDir(src, dest) {
+  mkdirp(dest);
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(srcPath, destPath);
+    else copyFile(srcPath, destPath);
+  }
+}
+
+// ===== Uninstall =====
+function uninstall(configDir) {
+  const toRemove = [
+    path.join(configDir, 'commands', 'pr-review'),
+    path.join(configDir, 'agents', 'pr-reviewer.md'),
+    path.join(configDir, 'pr-review'),
+  ];
+
+  let removed = 0;
+  for (const p of toRemove) {
+    if (fs.existsSync(p)) {
+      const stat = fs.statSync(p);
+      if (stat.isDirectory()) fs.rmSync(p, { recursive: true });
+      else fs.unlinkSync(p);
+      removed++;
+      log(`  ${c.red}removed${c.reset} ${p}`);
+    }
+  }
+
+  if (removed === 0) log(`  ${c.yellow}Nothing to uninstall.${c.reset}`);
+  else log(`\n  ${c.green}Uninstalled PR Review Agent.${c.reset}`);
+  log('');
+}
+
+// ===== Install =====
+function install(runtime, configDir) {
+  const rt = RUNTIMES[runtime];
+  // Set configDirName for path rewriting in copyFile
+  configDirName = rt.configDirName;
+  // Template goes inside configDir as pr-review/ (like GSD uses get-shit-done/)
+  const templateDest = path.join(configDir, 'pr-review');
+
+  log(`  ${c.cyan}Installing for ${rt.name}...${c.reset}`);
+  log('');
+
+  // 1. Copy commands
+  const cmdSrc = path.join(PKG_ROOT, 'commands', 'pr-review');
+  const cmdDest = path.join(configDir, rt.commandsDir);
+  copyDir(cmdSrc, cmdDest);
+  const cmdCount = fs.readdirSync(cmdSrc).length;
+  log(`  ${c.green}+${c.reset} ${cmdCount} commands  ${c.dim}→ ${cmdDest}${c.reset}`);
+
+  // 2. Copy agent
+  const agentSrc = path.join(PKG_ROOT, 'agents', 'pr-reviewer.md');
+  const agentDest = path.join(configDir, rt.agentsDir, 'pr-reviewer.md');
+  copyFile(agentSrc, agentDest);
+  log(`  ${c.green}+${c.reset} 1 agent    ${c.dim}→ ${agentDest}${c.reset}`);
+
+  // 3. Copy runtime files (index.html, serve.js, templates/)
+  const runtimeFiles = ['index.html', 'serve.js', '.gitignore'];
+  mkdirp(templateDest);
+  for (const f of runtimeFiles) {
+    const src = path.join(PKG_ROOT, 'template', f);
+    if (fs.existsSync(src)) copyFile(src, path.join(templateDest, f));
+  }
+  // Copy review-plan template (used by /pr-review:setup to generate REVIEW-PLAN.md)
+  const tplSrc = path.join(PKG_ROOT, 'template', 'templates');
+  const tplDest = path.join(templateDest, 'templates');
+  if (fs.existsSync(tplSrc)) copyDir(tplSrc, tplDest);
+  log(`  ${c.green}+${c.reset} runtime    ${c.dim}→ ${templateDest}${c.reset}`);
+
+  // 4. Write version file
+  fs.writeFileSync(path.join(templateDest, '.version'), VERSION);
+
+  // 5. Ensure .gitignore in template dir
+  const gitignorePath = path.join(templateDest, '.gitignore');
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, '# Generated on each review run\nfindings.json\nconfig.json\n');
+  }
+
+  log('');
+  log(`  ${c.green}${c.bold}PR Review Agent v${VERSION} installed!${c.reset}`);
+  log('');
+  log(`  ${c.bold}Quick start:${c.reset}`);
+  log(`  ${c.dim}1.${c.reset} Generate your review plan (first time only):`);
+  log(`     ${c.cyan}/pr-review:setup${c.reset}`);
+  log(`  ${c.dim}2.${c.reset} Review a PR:`);
+  log(`     ${c.cyan}/pr-review:review <pr-url>${c.reset}`);
+  log(`  ${c.dim}3.${c.reset} Preview findings in browser:`);
+  log(`     ${c.cyan}node ${rt.configDirName}/pr-review/serve.js${c.reset}`);
+  log('');
+  log(`  ${c.dim}Commands:${c.reset}`);
+  log(`    /pr-review:setup   ${c.dim}— Generate REVIEW-PLAN.md for your project${c.reset}`);
+  log(`    /pr-review:review  ${c.dim}— Analyze a PR against your review plan${c.reset}`);
+  log('');
+}
+
+// ===== Main =====
+async function main() {
+  const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+
+  // Non-interactive defaults
+  if (!isTTY || hasFlag('help')) {
+    if (hasFlag('help')) {
+      banner();
+      log(`  ${c.bold}Usage:${c.reset} npx pr-review-agent@latest [options]`);
+      log('');
+      log(`  ${c.bold}Options:${c.reset}`);
+      log(`    --claude       Install for Claude Code`);
+      log(`    --opencode     Install for OpenCode`);
+      log(`    --global       Install user-wide (default)`);
+      log(`    --local        Install in current project only`);
+      log(`    --uninstall    Remove the agent`);
+      log(`    --help         Show this help`);
+      log('');
+      log(`  ${c.bold}Examples:${c.reset}`);
+      log(`    npx pr-review-agent                    ${c.dim}# interactive${c.reset}`);
+      log(`    npx pr-review-agent --claude --local   ${c.dim}# Claude, project-level${c.reset}`);
+      log(`    npx pr-review-agent --claude --global --uninstall`);
+      log('');
+      return;
+    }
+    // Non-TTY or has specific flags: resolve from args
+    const rt = ['claude', 'opencode'].find(r => hasFlag(r)) || 'claude';
+    const scope = hasFlag('local') ? 'local' : 'global';
+    const dir = scope === 'local' ? RUNTIMES[rt].localDir() : RUNTIMES[rt].globalDir();
+    if (hasFlag('uninstall')) return uninstall(dir);
+    return install(rt, dir);
+  }
+
+  banner();
+
+  // Detect flags for non-interactive mode
+  const runtimeFlag = ['claude', 'opencode'].find(r => hasFlag(r));
+  const scopeFlag = hasFlag('local') ? 'local' : hasFlag('global') ? 'global' : null;
+
+  // 1. Select runtime
+  let runtime = runtimeFlag;
+  if (!runtime) {
+    log(`  ${c.bold}Select your AI coding assistant:${c.reset}`);
+    log('');
+    log(`    ${c.cyan}1${c.reset}) Claude Code`);
+    log(`    ${c.cyan}2${c.reset}) OpenCode`);
+    log('');
+    const choice = await prompt(`${c.bold}Enter choice [1]:${c.reset} `);
+    runtime = choice === '2' ? 'opencode' : 'claude';
+    log('');
+  }
+
+  // 2. Select scope
+  let scope = scopeFlag;
+  if (!scope) {
+    log(`  ${c.bold}Install scope:${c.reset}`);
+    log('');
+    log(`    ${c.cyan}1${c.reset}) Global ${c.dim}— available in all projects (${RUNTIMES[runtime].globalDir()})${c.reset}`);
+    log(`    ${c.cyan}2${c.reset}) Local  ${c.dim}— this project only (${RUNTIMES[runtime].localDir()})${c.reset}`);
+    log('');
+    const choice = await prompt(`${c.bold}Enter choice [1]:${c.reset} `);
+    scope = choice === '2' ? 'local' : 'global';
+    log('');
+  }
+
+  const configDir = scope === 'local'
+    ? RUNTIMES[runtime].localDir()
+    : RUNTIMES[runtime].globalDir();
+
+  // 3. Uninstall or install
+  if (hasFlag('uninstall')) {
+    uninstall(configDir);
+  } else {
+    install(runtime, configDir);
+  }
+}
+
+main().catch(err => {
+  log(`\n  ${c.red}${c.bold}Error:${c.reset} ${err.message}`);
+  process.exit(1);
+});

package/commands/pr-review/review.md

@@ -0,0 +1,65 @@
+---
+name: pr-review:review
+description: Analyze a GitHub PR against project architectural patterns and generate an interactive review preview. Posts comments to GitHub optionally.
+argument-hint: "<pr-url-or-number> [--post] [--focus security|i18n|architecture|design-tokens|all]"
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - Grep
+  - AskUserQuestion
+agent: pr-reviewer
+---
+
+<objective>
+Perform a comprehensive code review on a GitHub pull request by analyzing diffs against
+project-specific conventions defined in project instructions, skills, and ./REVIEW-PLAN.md.
+Generates structured findings and optionally posts comments to the PR.
+</objective>
+
+<execution_context>
+@./REVIEW-PLAN.md
+@./CLAUDE.md
+</execution_context>
+
+<context>
+PR identifier: $ARGUMENTS (GitHub URL, org/repo#N, or PR number)
+
+**Flags:**
+- `--post` — Post findings as comments on the GitHub PR
+- `--focus security` — Focus on security patterns only
+- `--focus i18n` — Focus on i18n violations only
+- `--focus architecture` — Focus on architectural patterns only
+- `--focus design-tokens` — Focus on design token violations only
+- `--focus all` — Full review (default)
+
+**Prerequisites:**
+- GitHub CLI (`gh`) installed and authenticated
+- `./REVIEW-PLAN.md` exists (run `/pr-review:setup` to generate it)
+
+**First run:** If `REVIEW-PLAN.md` doesn't exist, generate it from the template at
+`__CONFIG_DIR__/pr-review/templates/review-plan.md` — copy to `./REVIEW-PLAN.md` and ask the
+user to customize the "Project-Specific Rules" section before proceeding.
+</context>
+
+<process>
+1. Verify gh CLI is available and authenticated
+2. Detect pr-review directory (local `__CONFIG_DIR__/pr-review/` or global `$HOME/__CONFIG_DIR__/pr-review/`)
+3. If REVIEW-PLAN.md doesn't exist at project root, generate it from template and notify user
+4. Load project context (project instructions, skills, REVIEW-PLAN.md)
+5. Fetch PR metadata and existing comments
+6. Analyze each code file against review checklist
+7. Generate structured findings (`$PR_REVIEW_DIR/findings.json`)
+8. Generate config (`$PR_REVIEW_DIR/config.json`)
+9. Print summary to user
+10. If --post flag: ask confirmation then post comments to PR
+</process>
+
+<success_criteria>
+- [ ] All code files analyzed against project patterns
+- [ ] findings.json created
+- [ ] config.json created
+- [ ] Summary table displayed
+- [ ] Comments posted to PR (if --post flag used)
+</success_criteria>

package/commands/pr-review/setup.md

@@ -0,0 +1,94 @@
+---
+name: pr-review:setup
+description: Initialize PR review for the current project. Generates REVIEW-PLAN.md with project-specific criteria.
+argument-hint: ""
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+---
+
+<objective>
+Set up PR review for the current project. Generates a REVIEW-PLAN.md at the project
+root with review criteria tailored to the project's stack and patterns.
+
+This is similar to how `/gsd:new-project` generates PROJECT.md — the review plan
+is a project-level file that developers edit and commit, not agent infrastructure.
+</objective>
+
+<context>
+$ARGUMENTS
+
+**What gets created:**
+- `./REVIEW-PLAN.md` — Review criteria checklist at project root (developer-editable, committed to repo)
+
+**What already exists (installed by the agent):**
+- `__CONFIG_DIR__/pr-review/index.html` — Interactive preview UI
+- `__CONFIG_DIR__/pr-review/serve.js` — Local dev server for the preview
+- `__CONFIG_DIR__/pr-review/templates/review-plan.md` — Base template
+</context>
+
+<process>
+
+## Step 1: Check Prerequisites
+
+```bash
+gh --version 2>/dev/null || echo "gh not installed"
+gh auth status 2>/dev/null || echo "gh not authenticated"
+```
+
+If `gh` is not available, ask the user:
+- "GitHub CLI is required for PR review. Would you like to install it?"
+- Windows: `winget install GitHub.cli --source winget`
+- macOS: `brew install gh`
+- Then: `gh auth login`
+
+## Step 2: Detect PR Review Directory
+
+Locate the pr-review runtime:
+1. `./__CONFIG_DIR__/pr-review/` (local)
+2. `$HOME/__CONFIG_DIR__/pr-review/` (global)
+
+If neither exists, inform user to install: `npx pr-review-agent`
+
+## Step 3: Discover Project Context
+
+Read these files to understand the project:
+- `./CLAUDE.md` or equivalent project instructions
+- Project skills directory (if any)
+- `package.json` or equivalent — detect stack
+
+## Step 4: Generate REVIEW-PLAN.md
+
+1. Read the base template from `$PR_REVIEW_DIR/templates/review-plan.md`
+2. Ask the user about their project:
+   - Backend framework and patterns to enforce
+   - Frontend framework and patterns to enforce
+   - Key rules they want every PR checked against
+   - Any additional custom criteria
+3. Generate `./REVIEW-PLAN.md` at the project root, customizing the template
+   with the project's specific stack, patterns, and rules
+4. If project instructions or skills define architectural patterns, incorporate those
+   automatically into the "Project-Specific Rules" section
+
+**Important:** Do NOT hardcode framework-specific rules in the template.
+Generate them dynamically based on what the project actually uses.
+
+## Step 5: Confirm
+
+Tell the user:
+- Where REVIEW-PLAN.md was created
+- That they can edit it anytime
+- That the agent reads it before every `/pr-review:review` run
+- How to start reviewing: `/pr-review:review <pr-url>`
+
+</process>
+
+<success_criteria>
+- [ ] gh CLI verified or installation guided
+- [ ] Project stack detected
+- [ ] REVIEW-PLAN.md generated at project root with project-specific criteria
+- [ ] User informed about next steps
+</success_criteria>

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "pr-review-agent",
+  "version": "1.0.0",
+  "description": "AI-powered PR review agent for Claude Code, OpenCode, and other AI coding assistants. Analyzes pull requests against project-specific architectural patterns with an interactive preview UI.",
+  "bin": {
+    "pr-review-agent": "bin/install.js"
+  },
+  "files": [
+    "bin",
+    "commands",
+    "agents",
+    "template"
+  ],
+  "keywords": [
+    "claude-code",
+    "code-review",
+    "pull-request",
+    "ai-agent",
+    "opencode",
+    "pr-review",
+    "linter"
+  ],
+  "author": "TheRocketCodeMX",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheRocketCodeMX/pr-review-agent"
+  }
+}