rpr 0.1.0__tar.gz

rpr-0.1.0/.gitignore

@@ -0,0 +1,62 @@
+# --- Python ---
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg
+*.egg-info/
+.eggs/
+build/
+dist/
+wheels/
+.installed.cfg
+*.manifest
+*.spec
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Virtual environments
+.venv/
+.venv-*/
+venv/
+env/
+ENV/
+
+# Test / lint caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.tox/
+.coverage
+.coverage.*
+htmlcov/
+.cache/
+
+# --- Node / npm ---
+node_modules/
+*.tgz
+.npm/
+
+# --- Editors / IDEs ---
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# --- macOS ---
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# --- Project-local secrets ---
+.env
+.env.local
+*.local.json
+
+# --- Claude Code ---
+.claude/settings.local.json
+.claude/.credentials.json
+
+# --- Logs ---
+*.log
+logs/

rpr-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dedev-llc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rpr-0.1.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: rpr
+Version: 0.1.0
+Summary: Stealth PR reviewer — looks like you wrote every word.
+Project-URL: Homepage, https://github.com/dedev-llc/rpr
+Project-URL: Repository, https://github.com/dedev-llc/rpr
+Project-URL: Issues, https://github.com/dedev-llc/rpr/issues
+Author: dedev-llc
+License: MIT License
+        
+        Copyright (c) 2026 dedev-llc
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: ai,claude,code-review,github,pr,review
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# rpr — Stealth PR Reviewer
+
+AI-powered PR reviews that look like you wrote them. No GitHub Apps, no bots, no traces.
+
+## What It Does
+
+1. Fetches the PR diff from GitHub
+2. Sends it to Claude with a prompt engineered to sound like a senior engineer (not AI)
+3. Posts the review under **your GitHub account**  inline comments on specific lines
+
+Nobody can tell the difference.
+
+## Install
+
+| Channel | Command |
+|---|---|
+| **pipx** (recommended) | `pipx install rpr` |
+| **pip**  | `pip install --user rpr` |
+| **Homebrew** | `brew install dedev-llc/rpr/rpr` |
+| **npm**  | `npm install -g rpr` |
+| **npx**  | `npx rpr <pr-number>` |
+| **curl** | `curl -fsSL https://raw.githubusercontent.com/dedev-llc/rpr/main/install.sh \| bash` |
+
+All channels install the same `rpr` command. You'll also need:
+
+- **GitHub CLI (`gh`)** — [install](https://cli.github.com/), then `gh auth login`
+- **Anthropic API key** — `export ANTHROPIC_API_KEY=sk-ant-...` ([get one](https://console.anthropic.com/))
+- **Python 3.9+** (already required by all channels except npm/npx, which need it on PATH at runtime)
+
+## Usage
+
+```bash
+# In any git repo:
+rpr 42                                   # Review PR #42
+rpr 42 --dry-run                         # Preview in terminal first
+rpr 42 --approve                         # Review + approve
+rpr 42 --request-changes                 # Review + request changes
+rpr 42 --comment-only                    # Post as single comment (no inline)
+rpr 42 --repo owner/repo                 # Specify repo explicitly
+rpr 42 --model claude-sonnet-4-6         # Override model
+rpr 42 -v                                # Verbose mode (debug)
+```
+
+### Recommended Workflow
+
+1. **Always dry-run first** until you trust the output:
+   ```bash
+   rpr 42 --dry-run
+   ```
+
+2. If it looks right, post it:
+   ```bash
+   rpr 42
+   ```
+
+3. Optionally tweak a word or two in the posted review for your personal touch.
+
+## Configuration
+
+`rpr` ships with sensible defaults. To override them, drop a config file at one of these paths (first match wins):
+
+1. `./rpr.config.json` — project-local override (per-repo)
+2. `~/.config/rpr/config.json` — user-wide
+
+Example (see `examples/config.json`):
+
+```json
+{
+  "model": "claude-opus-4-6",
+  "max_tokens": 16000,
+  "max_diff_chars": 120000,
+  "skip_patterns": [
+    "*.lock",
+    "*.g.dart",
+    "*.freezed.dart"
+  ]
+}
+```
+
+| Key | Meaning |
+|---|---|
+| `model` | Claude model to use |
+| `max_tokens` | Max response length |
+| `max_diff_chars` | Truncate diffs larger than this |
+| `skip_patterns` | Glob patterns for files to ignore (generated code, locks, etc.) |
+
+### Custom review guidelines
+
+Inject your team's coding standards by dropping a `review-guidelines.md` at:
+
+1. `./review-guidelines.md` — project-local (per-repo)
+2. `~/.config/rpr/review-guidelines.md` — user-wide
+
+The contents get appended to the system prompt and the AI enforces them as if they were your personal standards. See `examples/review-guidelines.md` for a starter template.
+
+## How It Stays Invisible
+
+| Concern | Solution |
+|---|---|
+| GitHub Actions history | None — runs locally on your machine |
+| Workflow files in repo | None — no `.github/workflows` needed |
+| Bot label on comments | None — uses your PAT via `gh` CLI |
+| AI-sounding language | Prompt is engineered to sound human |
+| Review pattern detection | Varies tone, uses informal language |
+
+## Cost
+
+Each review costs roughly $0.01–$0.08 depending on diff size and model:
+
+- Small PR (< 200 lines): ~$0.01
+- Medium PR (200–1000 lines): ~$0.03
+- Large PR (1000+ lines): ~$0.05–0.08
+
+## Tips
+
+- **Edit after posting**: Tweak a word or two in your posted review for authenticity.
+- **Use `--dry-run` liberally**: Especially on important PRs.
+- **Customize guidelines**: The more specific your `review-guidelines.md`, the better the reviews match your real style.
+- **Skip generated files**: Add patterns for code generators your team uses (Freezed, json_serializable, etc.) to avoid noise.
+
+## Development
+
+```bash
+git clone https://github.com/dedev-llc/rpr
+cd rpr
+python -m venv .venv && source .venv/bin/activate
+pip install -e .         # editable install — `rpr` command works from anywhere
+rpr --help
+```
+
+Run as a module: `python -m rpr 42 --dry-run`
+
+> **macOS gotcha**: do **not** clone the repo into `~/Desktop` (or `~/Documents`). macOS sets the `UF_HIDDEN` file flag on everything inside those App Sandbox directories, which makes Python 3.13's `site.py` skip the editable install's `.pth` file (it treats hidden-flagged files as hidden, regardless of name). The published wheel from PyPI is unaffected — this only bites editable dev installs in sandboxed dirs. Symptom: `ModuleNotFoundError: No module named 'rpr'` after `pip install -e .`. Fix: clone to `~/code/rpr` or somewhere outside the sandbox.
+
+## Publishing (maintainer notes)
+
+The PyPI package is the source of truth. Other channels wrap it.
+
+### PyPI
+
+```bash
+pip install build twine
+python -m build                              # produces dist/rpr-X.Y.Z.tar.gz + .whl
+twine upload dist/*                          # requires PyPI account + token
+```
+
+### Homebrew formula
+
+After publishing to PyPI, update `Formula/rpr.rb`:
+
+```bash
+SHA=$(curl -sL https://files.pythonhosted.org/packages/source/r/rpr/rpr-0.1.0.tar.gz | shasum -a 256 | cut -d' ' -f1)
+# Edit Formula/rpr.rb: replace the placeholder sha256 with $SHA, bump version in url
+git commit -am "brew: bump rpr to 0.1.0" && git push
+```
+
+Users install via: `brew install dedev-llc/rpr/rpr`
+
+### npm
+
+```bash
+cd npm
+npm version 0.1.0 --no-git-tag-version       # match pyproject.toml version
+npm pack --dry-run                           # sanity check: should list bin/ + lib/
+npm publish                                  # requires npm login
+```
+
+The `prepack` hook copies `src/rpr/*.py` into `npm/lib/` automatically.
+
+### Release checklist
+
+1. Bump version in `pyproject.toml`, `src/rpr/__init__.py`, `npm/package.json`, `Formula/rpr.rb` (`url`)
+2. Tag: `git tag v0.1.0 && git push --tags`
+3. Publish to PyPI (above)
+4. Update Homebrew formula sha256 (above)
+5. Publish to npm (above)

rpr-0.1.0/README.md

@@ -0,0 +1,176 @@
+# rpr — Stealth PR Reviewer
+
+AI-powered PR reviews that look like you wrote them. No GitHub Apps, no bots, no traces.
+
+## What It Does
+
+1. Fetches the PR diff from GitHub
+2. Sends it to Claude with a prompt engineered to sound like a senior engineer (not AI)
+3. Posts the review under **your GitHub account**  inline comments on specific lines
+
+Nobody can tell the difference.
+
+## Install
+
+| Channel | Command |
+|---|---|
+| **pipx** (recommended) | `pipx install rpr` |
+| **pip**  | `pip install --user rpr` |
+| **Homebrew** | `brew install dedev-llc/rpr/rpr` |
+| **npm**  | `npm install -g rpr` |
+| **npx**  | `npx rpr <pr-number>` |
+| **curl** | `curl -fsSL https://raw.githubusercontent.com/dedev-llc/rpr/main/install.sh \| bash` |
+
+All channels install the same `rpr` command. You'll also need:
+
+- **GitHub CLI (`gh`)** — [install](https://cli.github.com/), then `gh auth login`
+- **Anthropic API key** — `export ANTHROPIC_API_KEY=sk-ant-...` ([get one](https://console.anthropic.com/))
+- **Python 3.9+** (already required by all channels except npm/npx, which need it on PATH at runtime)
+
+## Usage
+
+```bash
+# In any git repo:
+rpr 42                                   # Review PR #42
+rpr 42 --dry-run                         # Preview in terminal first
+rpr 42 --approve                         # Review + approve
+rpr 42 --request-changes                 # Review + request changes
+rpr 42 --comment-only                    # Post as single comment (no inline)
+rpr 42 --repo owner/repo                 # Specify repo explicitly
+rpr 42 --model claude-sonnet-4-6         # Override model
+rpr 42 -v                                # Verbose mode (debug)
+```
+
+### Recommended Workflow
+
+1. **Always dry-run first** until you trust the output:
+   ```bash
+   rpr 42 --dry-run
+   ```
+
+2. If it looks right, post it:
+   ```bash
+   rpr 42
+   ```
+
+3. Optionally tweak a word or two in the posted review for your personal touch.
+
+## Configuration
+
+`rpr` ships with sensible defaults. To override them, drop a config file at one of these paths (first match wins):
+
+1. `./rpr.config.json` — project-local override (per-repo)
+2. `~/.config/rpr/config.json` — user-wide
+
+Example (see `examples/config.json`):
+
+```json
+{
+  "model": "claude-opus-4-6",
+  "max_tokens": 16000,
+  "max_diff_chars": 120000,
+  "skip_patterns": [
+    "*.lock",
+    "*.g.dart",
+    "*.freezed.dart"
+  ]
+}
+```
+
+| Key | Meaning |
+|---|---|
+| `model` | Claude model to use |
+| `max_tokens` | Max response length |
+| `max_diff_chars` | Truncate diffs larger than this |
+| `skip_patterns` | Glob patterns for files to ignore (generated code, locks, etc.) |
+
+### Custom review guidelines
+
+Inject your team's coding standards by dropping a `review-guidelines.md` at:
+
+1. `./review-guidelines.md` — project-local (per-repo)
+2. `~/.config/rpr/review-guidelines.md` — user-wide
+
+The contents get appended to the system prompt and the AI enforces them as if they were your personal standards. See `examples/review-guidelines.md` for a starter template.
+
+## How It Stays Invisible
+
+| Concern | Solution |
+|---|---|
+| GitHub Actions history | None — runs locally on your machine |
+| Workflow files in repo | None — no `.github/workflows` needed |
+| Bot label on comments | None — uses your PAT via `gh` CLI |
+| AI-sounding language | Prompt is engineered to sound human |
+| Review pattern detection | Varies tone, uses informal language |
+
+## Cost
+
+Each review costs roughly $0.01–$0.08 depending on diff size and model:
+
+- Small PR (< 200 lines): ~$0.01
+- Medium PR (200–1000 lines): ~$0.03
+- Large PR (1000+ lines): ~$0.05–0.08
+
+## Tips
+
+- **Edit after posting**: Tweak a word or two in your posted review for authenticity.
+- **Use `--dry-run` liberally**: Especially on important PRs.
+- **Customize guidelines**: The more specific your `review-guidelines.md`, the better the reviews match your real style.
+- **Skip generated files**: Add patterns for code generators your team uses (Freezed, json_serializable, etc.) to avoid noise.
+
+## Development
+
+```bash
+git clone https://github.com/dedev-llc/rpr
+cd rpr
+python -m venv .venv && source .venv/bin/activate
+pip install -e .         # editable install — `rpr` command works from anywhere
+rpr --help
+```
+
+Run as a module: `python -m rpr 42 --dry-run`
+
+> **macOS gotcha**: do **not** clone the repo into `~/Desktop` (or `~/Documents`). macOS sets the `UF_HIDDEN` file flag on everything inside those App Sandbox directories, which makes Python 3.13's `site.py` skip the editable install's `.pth` file (it treats hidden-flagged files as hidden, regardless of name). The published wheel from PyPI is unaffected — this only bites editable dev installs in sandboxed dirs. Symptom: `ModuleNotFoundError: No module named 'rpr'` after `pip install -e .`. Fix: clone to `~/code/rpr` or somewhere outside the sandbox.
+
+## Publishing (maintainer notes)
+
+The PyPI package is the source of truth. Other channels wrap it.
+
+### PyPI
+
+```bash
+pip install build twine
+python -m build                              # produces dist/rpr-X.Y.Z.tar.gz + .whl
+twine upload dist/*                          # requires PyPI account + token
+```
+
+### Homebrew formula
+
+After publishing to PyPI, update `Formula/rpr.rb`:
+
+```bash
+SHA=$(curl -sL https://files.pythonhosted.org/packages/source/r/rpr/rpr-0.1.0.tar.gz | shasum -a 256 | cut -d' ' -f1)
+# Edit Formula/rpr.rb: replace the placeholder sha256 with $SHA, bump version in url
+git commit -am "brew: bump rpr to 0.1.0" && git push
+```
+
+Users install via: `brew install dedev-llc/rpr/rpr`
+
+### npm
+
+```bash
+cd npm
+npm version 0.1.0 --no-git-tag-version       # match pyproject.toml version
+npm pack --dry-run                           # sanity check: should list bin/ + lib/
+npm publish                                  # requires npm login
+```
+
+The `prepack` hook copies `src/rpr/*.py` into `npm/lib/` automatically.
+
+### Release checklist
+
+1. Bump version in `pyproject.toml`, `src/rpr/__init__.py`, `npm/package.json`, `Formula/rpr.rb` (`url`)
+2. Tag: `git tag v0.1.0 && git push --tags`
+3. Publish to PyPI (above)
+4. Update Homebrew formula sha256 (above)
+5. Publish to npm (above)

rpr-0.1.0/examples/config.json

@@ -0,0 +1,24 @@
+{
+  "model": "claude-opus-4-6",
+  "max_tokens": 16000,
+  "max_diff_chars": 120000,
+  "review_style": "senior_engineer",
+  "skip_patterns": [
+    "*.lock",
+    "*.g.dart",
+    "*.freezed.dart",
+    "*.gen.dart",
+    "*.mocks.dart",
+    "pubspec.lock",
+    "package-lock.json",
+    "yarn.lock",
+    "Podfile.lock",
+    "*.pbxproj",
+    "*.min.js",
+    "*.min.css",
+    "*.map",
+    "ios/Runner.xcodeproj/*",
+    "android/app/src/main/res/*",
+    ".dart_tool/*"
+  ]
+}

rpr-0.1.0/examples/review-guidelines.md

@@ -0,0 +1,43 @@
+# Review Guidelines
+
+These are injected into every review to enforce team standards.
+Edit this file to match your project's conventions.
+
+## Architecture
+- We use Clean Architecture with BLoC pattern
+- Feature-first folder structure: lib/features/<feature>/{data,domain,presentation}
+- Repository pattern for data layer — no direct API calls from BLoC
+- Use cases should be single-responsibility
+
+## Dart / Flutter
+- Prefer `final` over `var` wherever possible
+- Use `sealed` classes for state modeling
+- Freezed unions for complex states, simple classes for straightforward ones
+- No business logic in widgets — everything through BLoC
+- Dispose streams and controllers properly
+- Handle all error states — no silent failures
+- Use `Either<Failure, Success>` pattern for repository returns
+
+## State Management
+- BLoC for feature-level state
+- No nested BlocBuilders unless absolutely necessary
+- Use BlocSelector for granular rebuilds
+- Events should be past-tense verbs (e.g., `LoginSubmitted`, `UserProfileLoaded`)
+
+## API & Networking
+- All API calls must have proper error handling with timeout
+- Use interceptors for auth token refresh
+- DTOs for API responses, separate domain models for business logic
+- Never expose raw API models to the presentation layer
+
+## Security
+- No hardcoded API keys or secrets
+- Validate all user input
+- Sanitize data before rendering in WebViews
+- Use secure storage for tokens
+
+## Performance
+- Avoid unnecessary rebuilds (const constructors, proper keys)
+- Lazy loading for lists and heavy content
+- Image caching and proper sizing
+- No synchronous heavy computation on main isolate

rpr-0.1.0/npm/README.md

@@ -0,0 +1,33 @@
+# rpr
+
+Stealth PR reviewer — looks like you wrote every word.
+
+This is the npm distribution of `rpr`. It bundles the Python source and runs it via your local `python3`. You'll need:
+
+- **Python 3.9+** on your `PATH`
+- **GitHub CLI (`gh`)**, authenticated
+- **`ANTHROPIC_API_KEY`** environment variable
+
+## Install
+
+```bash
+npm install -g rpr
+# or
+npx rpr <pr-number>
+```
+
+## Usage
+
+```bash
+rpr 42                         # Review PR #42 in current repo
+rpr 42 --dry-run               # Print review, don't post
+rpr 42 --approve               # Review + approve
+rpr 42 --request-changes       # Review + request changes
+rpr 42 --repo owner/repo       # Specify a different repo
+```
+
+See the [main repo](https://github.com/dedev-llc/rpr) for full docs and configuration.
+
+## Why a Node wrapper around Python?
+
+`rpr` is written in Python (stdlib only). The npm package is a thin Node shim that finds your `python3` and execs the bundled CLI. If you're already a Python user, install via `pipx install rpr` instead — it's more idiomatic.

rpr-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+# hatchling >=1.27 emits editable .pth files without a leading underscore,
+# which Python 3.13's site.py would otherwise treat as "hidden" and skip.
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rpr"
+version = "0.1.0"
+description = "Stealth PR reviewer — looks like you wrote every word."
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.9"
+authors = [{ name = "dedev-llc" }]
+keywords = ["pr", "review", "github", "claude", "ai", "code-review"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+dependencies = []
+
+[project.scripts]
+rpr = "rpr.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/dedev-llc/rpr"
+Repository = "https://github.com/dedev-llc/rpr"
+Issues = "https://github.com/dedev-llc/rpr/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rpr"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/rpr",
+    "README.md",
+    "LICENSE",
+    "examples",
+]

rpr-0.1.0/src/rpr/__init__.py

@@ -0,0 +1,3 @@
+"""rpr — stealth PR reviewer."""
+
+__version__ = "0.1.0"

rpr-0.1.0/src/rpr/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

rpr-0.1.0/src/rpr/cli.py

@@ -0,0 +1,727 @@
+"""
+Stealth PR Reviewer — looks like you wrote every word.
+
+Usage:
+    rpr 42                          # Review PR #42 in current repo
+    rpr 42 --repo owner/repo        # Review PR #42 in specific repo
+    rpr 42 --comment-only           # Post as a single PR comment (not inline review)
+    rpr 42 --dry-run                # Print review to terminal, don't post
+    rpr 42 --approve                # Post review + approve the PR
+    rpr 42 --request-changes        # Post review + request changes
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+DEFAULT_CONFIG = {
+    "model": "claude-opus-4-6",
+    "max_tokens": 16000,
+    "max_diff_chars": 120000,
+    "review_style": "senior_engineer",
+    "skip_patterns": [
+        "*.lock",
+        "*.g.dart",
+        "*.freezed.dart",
+        "*.gen.dart",
+        "*.mocks.dart",
+        "pubspec.lock",
+        "package-lock.json",
+        "yarn.lock",
+        "Podfile.lock",
+        "*.pbxproj",
+    ],
+}
+
+
+def _xdg_config_home() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config")
+
+
+def _config_search_paths() -> list[Path]:
+    """Search order for the user's config file. First match wins."""
+    return [
+        Path.cwd() / "rpr.config.json",          # project-local override
+        _xdg_config_home() / "rpr" / "config.json",  # user config
+    ]
+
+
+def _guidelines_search_paths() -> list[Path]:
+    """Search order for the review-guidelines.md file. First match wins."""
+    return [
+        Path.cwd() / "review-guidelines.md",
+        _xdg_config_home() / "rpr" / "review-guidelines.md",
+    ]
+
+
+def load_config() -> dict:
+    config = DEFAULT_CONFIG.copy()
+    for p in _config_search_paths():
+        if p.exists():
+            with open(p) as f:
+                config.update(json.load(f))
+            break
+    return config
+
+
+# ---------------------------------------------------------------------------
+# GitHub helpers (uses `gh` CLI — no extra dependencies)
+# ---------------------------------------------------------------------------
+
+
+def run_gh(args: list, repo: str | None = None) -> str:
+    cmd = ["gh"]
+    if repo:
+        cmd += ["--repo", repo]
+    cmd += args
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"❌ gh error: {result.stderr.strip()}", file=sys.stderr)
+        sys.exit(1)
+    return result.stdout
+
+
+def get_pr_info(pr_number: int, repo: str | None) -> dict:
+    """Fetch PR metadata."""
+    raw = run_gh(
+        [
+            "pr",
+            "view",
+            str(pr_number),
+            "--json",
+            "title,body,baseRefName,headRefName,files,url,additions,deletions",
+        ],
+        repo,
+    )
+    return json.loads(raw)
+
+
+def get_pr_diff(pr_number: int, repo: str | None) -> str:
+    """Fetch the unified diff."""
+    return run_gh(["pr", "diff", str(pr_number)], repo)
+
+
+def get_pr_files(pr_number: int, repo: str | None) -> list:
+    """Fetch changed files with patches via API."""
+    raw = run_gh(
+        ["api", f"repos/{{owner}}/{{repo}}/pulls/{pr_number}/files", "--paginate"],
+        repo,
+    )
+    return json.loads(raw)
+
+
+def post_review_comment(pr_number: int, body: str, repo: str | None):
+    """Post a simple comment on the PR (not an inline review)."""
+    run_gh(["pr", "comment", str(pr_number), "--body", body], repo)
+
+
+def post_review(
+    pr_number: int,
+    body: str,
+    comments: list,
+    event: str,
+    repo: str | None,
+):
+    """
+    Submit a pull request review with optional inline comments.
+    event: COMMENT | APPROVE | REQUEST_CHANGES
+    """
+    # Build the review payload
+    payload = {"event": event, "body": body}
+
+    if comments:
+        payload["comments"] = []
+        for c in comments:
+            entry = {
+                "path": c["path"],
+                "body": c["body"],
+            }
+            # Use line-based positioning
+            if c.get("line"):
+                entry["line"] = c["line"]
+                entry["side"] = "RIGHT"
+            elif c.get("position"):
+                entry["position"] = c["position"]
+
+            # Multi-line comment support
+            if c.get("start_line") and c.get("line") and c["start_line"] != c["line"]:
+                entry["start_line"] = c["start_line"]
+                entry["start_side"] = "RIGHT"
+
+            payload["comments"].append(entry)
+
+    payload_json = json.dumps(payload)
+
+    # Use gh api to submit the review
+    result = subprocess.run(
+        _gh_cmd(
+            [
+                "api",
+                f"repos/{{owner}}/{{repo}}/pulls/{pr_number}/reviews",
+                "--method",
+                "POST",
+                "--input",
+                "-",
+            ],
+            repo,
+        ),
+        input=payload_json,
+        capture_output=True,
+        text=True,
+    )
+
+    if result.returncode != 0:
+        err = result.stderr.strip()
+        # If inline comments fail (common with line number mismatches),
+        # fall back to posting as a single review body
+        if "pull_request_review_thread" in err or "Validation" in err:
+            print("⚠️  Inline comments failed, falling back to body-only review...", file=sys.stderr)
+            fallback_body = body + "\n\n---\n\n"
+            for c in comments:
+                fallback_body += f"**`{c['path']}`**"
+                if c.get("line"):
+                    fallback_body += f" (line {c['line']})"
+                fallback_body += f"\n{c['body']}\n\n"
+
+            fallback_payload = json.dumps({"event": event, "body": fallback_body})
+            subprocess.run(
+                _gh_cmd(
+                    [
+                        "api",
+                        f"repos/{{owner}}/{{repo}}/pulls/{pr_number}/reviews",
+                        "--method",
+                        "POST",
+                        "--input",
+                        "-",
+                    ],
+                    repo,
+                ),
+                input=fallback_payload,
+                capture_output=True,
+                text=True,
+            )
+        else:
+            print(f"❌ Review submission error: {err}", file=sys.stderr)
+            sys.exit(1)
+
+
+def _gh_cmd(args: list, repo: str | None) -> list:
+    cmd = ["gh"]
+    if repo:
+        cmd += ["--repo", repo]
+    cmd += args
+    return cmd
+
+
+# ---------------------------------------------------------------------------
+# Diff filtering
+# ---------------------------------------------------------------------------
+
+
+def should_skip_file(filename: str, skip_patterns: list) -> bool:
+    from fnmatch import fnmatch
+    return any(fnmatch(filename, pat) for pat in skip_patterns)
+
+
+def filter_diff(diff: str, skip_patterns: list) -> str:
+    """Remove diff hunks for files matching skip patterns."""
+    lines = diff.split("\n")
+    filtered = []
+    skip_current = False
+    current_file = None
+
+    for line in lines:
+        if line.startswith("diff --git"):
+            # Extract filename: diff --git a/path b/path
+            parts = line.split(" b/")
+            current_file = parts[-1] if len(parts) > 1 else None
+            skip_current = current_file and should_skip_file(current_file, skip_patterns)
+
+        if not skip_current:
+            filtered.append(line)
+
+    return "\n".join(filtered)
+
+
+def truncate_diff(diff: str, max_chars: int) -> tuple:
+    """Truncate diff if too large, return (diff, was_truncated)."""
+    if len(diff) <= max_chars:
+        return diff, False
+    return diff[:max_chars] + "\n\n... [diff truncated due to size]", True
+
+
+def parse_diff_lines(diff: str) -> dict:
+    """
+    Parse a unified diff and extract the actual NEW-SIDE line numbers
+    that were added or modified per file. This is the source of truth
+    for which lines Claude is allowed to comment on.
+
+    Returns: {"path/to/file.dart": [12, 13, 14, 55, 56], ...}
+    """
+    import re
+    file_lines: dict = {}
+    current_file = None
+    current_line = 0
+
+    for raw_line in diff.split("\n"):
+        # New file in diff: diff --git a/path b/path
+        if raw_line.startswith("diff --git"):
+            parts = raw_line.split(" b/")
+            current_file = parts[-1] if len(parts) > 1 else None
+            if current_file and current_file not in file_lines:
+                file_lines[current_file] = []
+            continue
+
+        # Hunk header: @@ -old_start,old_count +new_start,new_count @@
+        hunk_match = re.match(r'^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@', raw_line)
+        if hunk_match:
+            current_line = int(hunk_match.group(1))
+            continue
+
+        if current_file is None:
+            continue
+
+        # Added or modified line (starts with +, but not +++ header)
+        if raw_line.startswith("+") and not raw_line.startswith("+++"):
+            file_lines[current_file].append(current_line)
+            current_line += 1
+        # Removed line (starts with -, but not --- header) — doesn't advance new-side counter
+        elif raw_line.startswith("-") and not raw_line.startswith("---"):
+            pass
+        # Context line (unchanged) — advances new-side counter
+        elif not raw_line.startswith("\\"):
+            current_line += 1
+
+    # Remove files with no changed lines
+    return {f: lines for f, lines in file_lines.items() if lines}
+
+
+def build_valid_lines_summary(valid_lines: dict) -> str:
+    """
+    Build a compact summary of which files and line ranges were changed.
+    e.g. "lib/auth.dart: 12-18, 45-50, 88"
+    """
+    parts = []
+    for filepath, lines in sorted(valid_lines.items()):
+        if not lines:
+            continue
+        # Compress consecutive lines into ranges
+        ranges = []
+        start = lines[0]
+        end = lines[0]
+        for ln in lines[1:]:
+            if ln == end + 1:
+                end = ln
+            else:
+                ranges.append(f"{start}-{end}" if start != end else str(start))
+                start = end = ln
+        ranges.append(f"{start}-{end}" if start != end else str(start))
+        parts.append(f"  {filepath}: lines {', '.join(ranges)}")
+    return "\n".join(parts)
+
+
+# ---------------------------------------------------------------------------
+# Claude API
+# ---------------------------------------------------------------------------
+
+
+def call_claude(prompt: str, system: str, config: dict) -> str:
+    api_key = os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        # Try loading from config
+        api_key = config.get("anthropic_api_key")
+    if not api_key:
+        print(
+            "❌ Set ANTHROPIC_API_KEY env var or add it to ~/.config/rpr/config.json",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    model = config["model"]
+    payload = {
+        "model": model,
+        "max_tokens": config["max_tokens"],
+        "system": system,
+        "messages": [{"role": "user", "content": prompt}],
+    }
+
+    # Enable adaptive thinking for 4.6 / opus models
+    if "opus" in model or "4-6" in model or "4_6" in model:
+        payload["temperature"] = 1  # required for thinking
+        payload["thinking"] = {"type": "adaptive"}
+
+    req = urllib.request.Request(
+        "https://api.anthropic.com/v1/messages",
+        data=json.dumps(payload).encode("utf-8"),
+        headers={
+            "content-type": "application/json",
+            "x-api-key": api_key,
+            "anthropic-version": "2023-06-01",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=300) as resp:
+            response = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        print(f"❌ Claude API error ({e.code}): {body}", file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f"❌ Network error contacting Claude API: {e.reason}", file=sys.stderr)
+        sys.exit(1)
+
+    if "error" in response:
+        print(f"❌ Claude API error: {response['error']}", file=sys.stderr)
+        sys.exit(1)
+
+    # Extract text content, skipping thinking blocks
+    for block in response.get("content", []):
+        if block.get("type") == "text":
+            return block["text"]
+
+    # Fallback
+    return response["content"][0].get("text", "")
+
+
+# ---------------------------------------------------------------------------
+# Review prompt engineering
+# ---------------------------------------------------------------------------
+
+
+def get_review_guidelines() -> str:
+    """Load custom review guidelines from cwd or XDG config dir."""
+    for p in _guidelines_search_paths():
+        if p.exists():
+            return p.read_text()
+    return ""
+
+
+SYSTEM_PROMPT = """\
+You are a senior software engineer doing a code review. You are NOT an AI — you are \
+the developer reviewing this pull request. Write exactly how a sharp, experienced \
+engineer writes PR reviews:
+
+VOICE & TONE RULES:
+- Be direct. No pleasantries, no "Great work overall!" fluff.
+- Use first person naturally: "I think", "I'd suggest", "this concerns me"
+- Be specific about what's wrong and why
+- Occasionally use informal language — "this looks off", "hmm", "nit:", "not sure about this"
+- Vary your sentence length. Mix short punchy observations with longer explanations.
+- It's okay to say "looks good" for parts that are fine — but don't overdo it
+- NEVER use phrases like "as an AI", "I notice", "I'd like to highlight"
+- NEVER use bullet points with perfect parallel structure — real humans don't write that way
+- Skip obvious stuff. Don't explain what the code does back to the author.
+
+WHAT TO FOCUS ON:
+- Bugs, logic errors, edge cases that will break
+- Security issues (injection, auth gaps, data exposure)
+- Performance problems that actually matter
+- Missing error handling that will cause production issues
+- Concurrency / race conditions
+- Resource leaks
+
+WHAT TO SKIP:
+- Style preferences (formatting, naming conventions) unless truly confusing
+- "Consider adding tests" — they know
+- Obvious documentation suggestions
+- Praise for basic competence
+
+{custom_guidelines}"""
+
+USER_PROMPT_TEMPLATE = """\
+Review this pull request.
+
+**{title}**
+{description}
+
+Base: `{base}` ← Head: `{head}`
+{stats}
+
+CHANGED FILES AND LINES (only these are reviewable):
+{changed_lines_summary}
+
+CRITICAL CONSTRAINT: You may ONLY comment on lines listed above. These are the \
+lines that were actually added or modified in this PR. Do NOT comment on:
+- Lines that appear in the diff as context (lines without + prefix)
+- Lines from files not listed above
+- Code that exists in the repo but was not changed in this PR
+If an issue involves unchanged code, mention it in the summary instead.
+
+Return your review as JSON with this exact structure — no markdown fences, no preamble:
+
+{{
+  "action": "approve" | "request_changes" | "comment",
+  "summary": "Your overall assessment in 2-3 sentences. Be direct.",
+  "comments": [
+    {{
+      "path": "relative/file/path.ext",
+      "line": <line number from the CHANGED LINES list above>,
+      "body": "Your comment about this specific line/section"
+    }}
+  ]
+}}
+
+Rules for "action":
+- "approve" — the code is solid, no blocking issues. Minor nits are fine alongside an approval.
+- "request_changes" — there are bugs, security holes, or logic errors that MUST be fixed before merge.
+- "comment" — you have feedback but nothing blocking. Use this when you have suggestions but the code would work fine as-is.
+- Default to "approve" if the changes look correct and there are no real issues.
+- Only use "request_changes" for actual problems, not style preferences.
+
+Rules for the JSON:
+- "path" must be one of the files listed in CHANGED FILES above
+- "line" must be a number from that file's changed lines listed above
+- If you can't pinpoint an exact changed line, put it in the summary instead
+- Keep comments concise — 1-3 sentences each
+- If the PR looks solid, return an empty comments array and say so in the summary
+- Do NOT invent issues just to have something to say
+
+Here's the diff:
+
+{diff}"""
+
+
+def build_prompt(pr_info: dict, diff: str, valid_lines: dict) -> tuple:
+    """Build the system and user prompts."""
+    custom_guidelines = get_review_guidelines()
+    if custom_guidelines:
+        custom_guidelines = f"\nADDITIONAL TEAM GUIDELINES:\n{custom_guidelines}"
+
+    system = SYSTEM_PROMPT.format(custom_guidelines=custom_guidelines)
+
+    description = pr_info.get("body") or "(no description)"
+    # Truncate long descriptions
+    if len(description) > 2000:
+        description = description[:2000] + "..."
+
+    stats = f"+{pr_info.get('additions', '?')} / -{pr_info.get('deletions', '?')}"
+    changed_lines_summary = build_valid_lines_summary(valid_lines)
+
+    user = USER_PROMPT_TEMPLATE.format(
+        title=pr_info.get("title", "Untitled"),
+        description=description,
+        base=pr_info.get("baseRefName", "?"),
+        head=pr_info.get("headRefName", "?"),
+        stats=stats,
+        changed_lines_summary=changed_lines_summary,
+        diff=diff,
+    )
+
+    return system, user
+
+
+# ---------------------------------------------------------------------------
+# Response parsing
+# ---------------------------------------------------------------------------
+
+
+def parse_review(raw: str) -> dict:
+    """Parse Claude's JSON response, handling common quirks."""
+    # Strip markdown code fences if present
+    text = raw.strip()
+    if text.startswith("```"):
+        # Remove first line and last line
+        lines = text.split("\n")
+        if lines[0].startswith("```"):
+            lines = lines[1:]
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
+        text = "\n".join(lines)
+
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        # Try to extract JSON from the response
+        start = text.find("{")
+        end = text.rfind("}") + 1
+        if start >= 0 and end > start:
+            try:
+                return json.loads(text[start:end])
+            except json.JSONDecodeError:
+                pass
+
+        # Last resort: return as plain comment
+        return {"summary": raw, "comments": []}
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="rpr",
+        description="Stealth PR Reviewer — looks like you wrote every word.",
+    )
+    parser.add_argument("pr_number", type=int, help="PR number to review")
+    parser.add_argument("--repo", "-r", help="owner/repo (default: current repo)")
+    parser.add_argument("--dry-run", "-n", action="store_true", help="Print review, don't post")
+    parser.add_argument("--comment-only", action="store_true", help="Post as simple comment, not inline review")
+    parser.add_argument("--approve", action="store_true", help="Approve the PR with review")
+    parser.add_argument("--request-changes", action="store_true", help="Request changes")
+    parser.add_argument("--model", help="Override Claude model")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Show debug info")
+
+    args = parser.parse_args()
+    config = load_config()
+
+    if args.model:
+        config["model"] = args.model
+
+    # 1. Fetch PR info
+    print(f"📋 Fetching PR #{args.pr_number}...", file=sys.stderr)
+    pr_info = get_pr_info(args.pr_number, args.repo)
+
+    if args.verbose:
+        print(f"   Title: {pr_info.get('title')}", file=sys.stderr)
+        files = pr_info.get("files", [])
+        print(f"   Files: {len(files)} changed", file=sys.stderr)
+
+    # 2. Get diff
+    print("📝 Fetching diff...", file=sys.stderr)
+    diff = get_pr_diff(args.pr_number, args.repo)
+
+    # 3. Filter out noise
+    diff = filter_diff(diff, config["skip_patterns"])
+    diff, was_truncated = truncate_diff(diff, config["max_diff_chars"])
+
+    if was_truncated:
+        print("⚠️  Diff was truncated (too large). Review may miss some files.", file=sys.stderr)
+
+    if not diff.strip():
+        print("⚠️  No reviewable changes found (all files matched skip patterns).", file=sys.stderr)
+        sys.exit(0)
+
+    # 3b. Parse diff to get exact changed lines per file
+    valid_lines = parse_diff_lines(diff)
+    valid_files = set(valid_lines.keys())
+
+    if args.verbose:
+        total_changed = sum(len(v) for v in valid_lines.values())
+        print(f"   Changed lines: {total_changed} across {len(valid_files)} files", file=sys.stderr)
+
+    # 4. Build prompt and call Claude
+    system, user = build_prompt(pr_info, diff, valid_lines)
+
+    print(f"🤖 Reviewing with {config['model']}...", file=sys.stderr)
+    raw_response = call_claude(user, system, config)
+
+    if args.verbose:
+        print(f"\n--- Raw response ---\n{raw_response}\n---\n", file=sys.stderr)
+
+    # 5. Parse response
+    review = parse_review(raw_response)
+    summary = review.get("summary", "Looks good.")
+    comments = review.get("comments", [])
+
+    # Filter out comments that target files/lines NOT in the diff
+    valid_comments = []
+    dropped = 0
+    for c in comments:
+        path = c.get("path")
+        line = c.get("line")
+        if not path or not line:
+            dropped += 1
+            continue
+        if path not in valid_files:
+            dropped += 1
+            if args.verbose:
+                print(f"   ⛔ Dropped comment on {path}:{line} — file not in diff", file=sys.stderr)
+            # Append to summary instead
+            summary += f"\n\n**Note on `{path}`** (line {line}): {c.get('body', '')}"
+            continue
+        if line not in valid_lines.get(path, []):
+            # Try to snap to the nearest valid line in that file
+            file_valid = valid_lines.get(path, [])
+            if file_valid:
+                nearest = min(file_valid, key=lambda x: abs(x - line))
+                # Only snap if within 5 lines (likely referring to same block)
+                if abs(nearest - line) <= 5:
+                    if args.verbose:
+                        print(f"   📌 Snapped {path}:{line} → {path}:{nearest}", file=sys.stderr)
+                    c["line"] = nearest
+                    valid_comments.append(c)
+                else:
+                    dropped += 1
+                    if args.verbose:
+                        print(f"   ⛔ Dropped comment on {path}:{line} — not a changed line", file=sys.stderr)
+                    summary += f"\n\n**Note on `{path}`** (line {line}): {c.get('body', '')}"
+            else:
+                dropped += 1
+            continue
+        valid_comments.append(c)
+
+    if dropped and args.verbose:
+        print(f"   ⚠️  {dropped} comments dropped (not on changed lines)", file=sys.stderr)
+
+    print(f"✅ Review ready: {len(valid_comments)} inline comments", file=sys.stderr)
+
+    # 6. Determine review action
+    # CLI flags override, otherwise use Claude's decision
+    if args.approve:
+        event = "APPROVE"
+    elif args.request_changes:
+        event = "REQUEST_CHANGES"
+    else:
+        # Use Claude's recommendation
+        ai_action = review.get("action", "comment").lower().strip()
+        action_map = {
+            "approve": "APPROVE",
+            "request_changes": "REQUEST_CHANGES",
+            "comment": "COMMENT",
+        }
+        event = action_map.get(ai_action, "COMMENT")
+
+    action_label = {
+        "COMMENT": "💬 commented on",
+        "APPROVE": "✅ approved",
+        "REQUEST_CHANGES": "🔄 requested changes on",
+    }
+
+    # 7. Output or post
+    if args.dry_run:
+        print("\n" + "=" * 60)
+        print(f"ACTION: {action_label.get(event, event)}")
+        print("=" * 60)
+        print("REVIEW SUMMARY:")
+        print(summary)
+        if valid_comments:
+            print("\n" + "-" * 60)
+            print("INLINE COMMENTS:")
+            print("-" * 60)
+            for c in valid_comments:
+                print(f"\n📄 {c['path']}:{c['line']}")
+                print(f"   {c['body']}")
+        print()
+        return
+
+    if args.comment_only:
+        # Post as a single PR comment
+        body = summary
+        if valid_comments:
+            body += "\n\n---\n"
+            for c in valid_comments:
+                body += f"\n**`{c['path']}`** (L{c['line']})\n{c['body']}\n"
+        post_review_comment(args.pr_number, body, args.repo)
+        print(f"✅ Posted as comment on PR #{args.pr_number}", file=sys.stderr)
+    else:
+        post_review(args.pr_number, summary, valid_comments, event, args.repo)
+        print(f"{action_label[event]} PR #{args.pr_number}", file=sys.stderr)
+
+    print(f"🔗 {pr_info.get('url', '')}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()