prrev 0.1.0__tar.gz

prrev-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+.prrev.toml
+*.egg
+.ruff_cache/
+.pytest_cache/

prrev-0.1.0/CLAUDE.md

@@ -0,0 +1,119 @@
+# CLAUDE.md
+
+## Commands
+
+```bash
+# Install in editable mode with dev dependencies
+pip install -e ".[dev]"
+
+# Run the CLI
+prrev .                          # review uncommitted changes
+prrev . --staged                 # review only staged changes
+prrev . --commit abc123          # review a specific commit
+prrev . --range abc123..def456   # review a commit range
+prrev https://github.com/user/repo/pull/42         # review a GitHub PR
+prrev https://github.com/user/repo/pull/42 --post   # post review as PR comment
+
+# Tests
+pytest                           # run all tests
+pytest tests/test_git.py         # run a single test file
+pytest -k "test_parse_pr_url"    # run a single test by name
+
+# Lint
+ruff check src/ tests/           # lint
+ruff check --fix src/ tests/     # lint and auto-fix
+ruff format src/ tests/          # format
+```
+
+## Architecture
+
+PRRev is a single-command CLI that pipes code diffs through an LLM and renders structured reviews.
+
+**Core flow:** CLI (`cli.py`) → diff extraction (`git.py` or `github.py`) → orchestrator (`reviewer.py`) → LLM provider (`llm/`) → formatter (`formatter.py`) → terminal or file output.
+
+### Key modules
+
+- **`cli.py`** — Single Typer command (uses `@app.callback(invoke_without_command=True)`). Routes to local git or GitHub path based on whether `target` is a URL. Wires config, provider, and formatter together. Runs the async review loop via `asyncio.run()`.
+- **`git.py`** — Extracts diffs from local repos via GitPython. Supports uncommitted (staged + unstaged), `--staged` only, specific commit, and commit range. Returns raw unified diff as a string.
+- **`github.py`** — Fetches PR diffs and posts reviews via GitHub API using httpx. The only module that uses httpx directly. Parses PR URLs, fetches full diff via `Accept: application/vnd.github.v3.diff` header, and posts reviews with inline comments.
+- **`reviewer.py`** — Orchestrator. Takes an `LLMProvider` and a diff string. Handles diff chunking: splits by file using `diff --git` headers, reviews chunks in parallel via `asyncio.gather()`, merges results. Applies `max_items` truncation (drop suggestions first, then warnings).
+- **`formatter.py`** — Renders `ReviewResult` to terminal using Rich (panels, colored severity) or to a markdown string for file/PR output.
+- **`config.py`** — Loads config from `~/.config/prrev/config.toml` (global) or `.prrev.toml` (repo-root, gitignored). Env vars (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GITHUB_TOKEN`) override config file values. CLI flags override everything.
+- **`llm/base.py`** — Abstract base class `LLMProvider` with async `review(diff) -> ReviewResult`. Data classes `ReviewItem` and `ReviewResult`.
+- **`llm/anthropic.py`** — Claude implementation. Uses Anthropic SDK's tool use for structured output (defines a `submit_review` tool with the ReviewResult JSON schema). The model calls the tool, we parse the tool call arguments — no fragile JSON-from-text parsing.
+- **`llm/openai.py`** — OpenAI implementation. Uses `response_format` with a JSON schema for structured output.
+
+## Design Decisions
+
+### Structured output over JSON prompting
+Never ask the LLM to return raw JSON text. Anthropic provider uses tool use (`tools=[...]` parameter); OpenAI provider uses structured outputs (`response_format={"type": "json_schema", ...}`). Both guarantee valid JSON matching the schema.
+
+### Async provider interface
+`LLMProvider.review()` is async. This enables parallel chunk reviews via `asyncio.gather()` when a diff is split across files. The CLI entry point uses `asyncio.run()`.
+
+### Line numbers are new-file lines
+`ReviewItem.line` always refers to the new-file line number (right side of the diff, `+` lines). This matches what GitHub's review API expects for inline comments on additions. For deleted lines, `line` refers to the original file's line number and comments use `side="LEFT"`.
+
+### Diff chunking
+Split threshold: use actual token counts, not character estimates. Anthropic SDK provides `client.count_tokens()`; use `tiktoken` for OpenAI. Split at `diff --git a/... b/...` boundaries. If a single file exceeds the context window, skip it with a warning in the review output.
+
+### GitHub inline comments
+When `--post` is used, map each `ReviewItem` to an inline comment using `POST /repos/{owner}/{repo}/pulls/{number}/reviews` with a `comments` array. Each comment needs `path` (from `ReviewItem.file`), `line` (from `ReviewItem.line`), `side` ("RIGHT" for additions, "LEFT" for deletions), and `body`. Items without a line number go into the top-level review body.
+
+### Exit codes
+Exit 0 if review completes successfully with no issues at or above the `--fail-on` threshold. Exit 1 if issues meet/exceed the threshold. Exit 2 for tool errors (missing API key, invalid args, network failure). This enables CI integration.
+
+### Config precedence
+CLI flags > environment variables > repo-root `.prrev.toml` > global `~/.config/prrev/config.toml` > defaults. Tokens are never read from repo-root config (security) — only from env vars or global config.
+
+### max_items truncation order
+When `max_items` is reached, drop suggestions first, then warnings. Critical items are never dropped.
+
+## Code Style
+
+### Comments
+- Casual dev-note tone: lowercase, abbreviations ("bc", "thru", "doesnt"). No em-dashes, use commas and periods.
+- Don't bloat but don't leave files bare. Comment: why a design choice was made, non-obvious blocks, gotchas, TODOs.
+- Quick dev notes, not documentation.
+
+### Commits
+- Small, incremental. One logical change per commit.
+- Lowercase, start with action verb: `added`, `fixed`, `tweaked`, `wired up`, `moved`, `prevent`, `validate`.
+- No conventional commit prefixes (`feat:`, `fix:`, `docs:`).
+- Include the why when its not obvious from context.
+
+### Workflow
+- Build step by step, commit each piece.
+- Never dump an entire project in one shot.
+
+## Build Phases
+
+### Phase 1 — MVP
+1. `git.py`: diff extraction (uncommitted, staged, commit, range)
+2. `llm/anthropic.py`: send diff via tool use, parse structured response
+3. `reviewer.py`: single-chunk review (no splitting yet)
+4. `formatter.py`: Rich terminal output
+5. `cli.py`: wire together, local path only
+6. `config.py`: env var loading (no config file yet)
+7. Basic error handling: missing API key, empty diff, invalid repo path
+8. End-to-end test: `prrev .` on a real repo
+
+### Phase 2 — GitHub
+1. `github.py`: parse PR URL, fetch diff via httpx
+2. `cli.py`: detect URL target, route to github.py
+3. `github.py`: post review with inline comments via `--post`
+4. `GITHUB_TOKEN` support via env var
+
+### Phase 3 — Polish
+1. `llm/openai.py` and `--provider` / `--model` flags
+2. `config.py`: TOML config file loading
+3. `--output` flag for markdown export
+4. Diff chunking with actual token counting and async parallel review
+5. `--fail-on` flag and exit codes
+6. `--staged` flag
+7. Error handling: API rate limits, network failures, oversized diffs
+
+### Phase 4 — Ship
+1. README with usage, install, config reference
+2. LICENSE (MIT)
+3. Tag v0.1.0, publish to PyPI

prrev-0.1.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: prrev
+Version: 0.1.0
+Summary: CLI tool that reviews code diffs using LLMs
+Author-email: Timur Mamedov <tm412421@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.40
+Requires-Dist: gitpython>=3.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.50
+Requires-Dist: rich>=13.0
+Requires-Dist: tiktoken>=0.7
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# PRRev
+
+A CLI tool that reviews code diffs using LLMs. Point it at a local repo or a GitHub PR URL. It sends the diff to Claude or GPT-4o and outputs a structured review with severity ratings, file references, and line numbers.
+
+## Install
+
+```bash
+git clone https://github.com/timurmamedov1/PRRev.git
+cd PRRev
+pip install -e .
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+```bash
+# review uncommitted changes
+prrev .
+
+# review only staged changes
+prrev . --staged
+
+# review a specific commit
+prrev . --commit abc123
+
+# review a commit range
+prrev . --range abc123..def456
+
+# review a GitHub PR
+prrev https://github.com/user/repo/pull/42
+
+# post review as inline PR comments
+prrev https://github.com/user/repo/pull/42 --post
+
+# write review to a markdown file
+prrev . --output review.md
+
+# fail in CI if there are warnings or worse
+prrev . --fail-on warning
+```
+
+## Configuration
+
+Set API keys as environment variables:
+
+```bash
+export ANTHROPIC_API_KEY=sk-...
+export OPENAI_API_KEY=sk-...
+export GITHUB_TOKEN=ghp_...
+```
+
+Or use a config file at `~/.config/prrev/config.toml`:
+
+```toml
+[llm]
+provider = "anthropic"
+model = "claude-sonnet-4-20250514"
+anthropic_api_key = "sk-..."
+
+[github]
+token = "ghp_..."
+
+[review]
+max_items = 20
+```
+
+You can also put a `.prrev.toml` in your repo root for per-project settings. API keys are ignored in repo config for security. They only load from env vars or the global config.
+
+Precedence: CLI flags > env vars > repo config > global config > defaults.
+
+## Providers
+
+```bash
+# use claude (default)
+prrev . --provider anthropic
+
+# use gpt-4o
+prrev . --provider openai
+
+# override the model
+prrev . --provider anthropic --model claude-sonnet-4-20250514
+```
+
+## How It Works
+
+The diff is sent to the LLM using each provider's structured output mechanism: Anthropic's tool use and OpenAI's `response_format` with a JSON schema. This guarantees the response matches the expected structure at the API level without fragile JSON text parsing.
+
+For large diffs, PRRev automatically chunks by file based on actual token counts (not character estimates) and reviews each chunk in parallel. Results are merged and truncated by severity: suggestions are dropped first, then warnings. Critical issues are never dropped.
+
+## Exit Codes
+
+- `0:` review completed, no issues at or above `--fail-on` threshold
+- `1:` issues found at or above `--fail-on` threshold
+- `2:` tool error (missing API key, invalid args, network failure)
+
+## Tech Stack
+
+- **Typer:** CLI framework
+- **Rich:** terminal output with colored severity panels
+- **GitPython:** local diff extraction
+- **httpx:** GitHub API (fetch PR diffs, post inline comments)
+- **Anthropic SDK:** Claude API with tool use for structured output
+- **OpenAI SDK:** GPT-4o API with structured output
+- **tiktoken:** token counting for OpenAI

prrev-0.1.0/README.md

@@ -0,0 +1,105 @@
+# PRRev
+
+A CLI tool that reviews code diffs using LLMs. Point it at a local repo or a GitHub PR URL. It sends the diff to Claude or GPT-4o and outputs a structured review with severity ratings, file references, and line numbers.
+
+## Install
+
+```bash
+git clone https://github.com/timurmamedov1/PRRev.git
+cd PRRev
+pip install -e .
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+```bash
+# review uncommitted changes
+prrev .
+
+# review only staged changes
+prrev . --staged
+
+# review a specific commit
+prrev . --commit abc123
+
+# review a commit range
+prrev . --range abc123..def456
+
+# review a GitHub PR
+prrev https://github.com/user/repo/pull/42
+
+# post review as inline PR comments
+prrev https://github.com/user/repo/pull/42 --post
+
+# write review to a markdown file
+prrev . --output review.md
+
+# fail in CI if there are warnings or worse
+prrev . --fail-on warning
+```
+
+## Configuration
+
+Set API keys as environment variables:
+
+```bash
+export ANTHROPIC_API_KEY=sk-...
+export OPENAI_API_KEY=sk-...
+export GITHUB_TOKEN=ghp_...
+```
+
+Or use a config file at `~/.config/prrev/config.toml`:
+
+```toml
+[llm]
+provider = "anthropic"
+model = "claude-sonnet-4-20250514"
+anthropic_api_key = "sk-..."
+
+[github]
+token = "ghp_..."
+
+[review]
+max_items = 20
+```
+
+You can also put a `.prrev.toml` in your repo root for per-project settings. API keys are ignored in repo config for security. They only load from env vars or the global config.
+
+Precedence: CLI flags > env vars > repo config > global config > defaults.
+
+## Providers
+
+```bash
+# use claude (default)
+prrev . --provider anthropic
+
+# use gpt-4o
+prrev . --provider openai
+
+# override the model
+prrev . --provider anthropic --model claude-sonnet-4-20250514
+```
+
+## How It Works
+
+The diff is sent to the LLM using each provider's structured output mechanism: Anthropic's tool use and OpenAI's `response_format` with a JSON schema. This guarantees the response matches the expected structure at the API level without fragile JSON text parsing.
+
+For large diffs, PRRev automatically chunks by file based on actual token counts (not character estimates) and reviews each chunk in parallel. Results are merged and truncated by severity: suggestions are dropped first, then warnings. Critical issues are never dropped.
+
+## Exit Codes
+
+- `0:` review completed, no issues at or above `--fail-on` threshold
+- `1:` issues found at or above `--fail-on` threshold
+- `2:` tool error (missing API key, invalid args, network failure)
+
+## Tech Stack
+
+- **Typer:** CLI framework
+- **Rich:** terminal output with colored severity panels
+- **GitPython:** local diff extraction
+- **httpx:** GitHub API (fetch PR diffs, post inline comments)
+- **Anthropic SDK:** Claude API with tool use for structured output
+- **OpenAI SDK:** GPT-4o API with structured output
+- **tiktoken:** token counting for OpenAI

prrev-0.1.0/interview-prep-prrev.md

@@ -0,0 +1,105 @@
+## PRRev
+
+### What it is
+
+PRRev is a Python CLI tool that reviews code diffs using LLMs. You point it at a local git repo or a GitHub PR URL, it extracts the diff, sends it to Claude or GPT-4o, and outputs a structured review with severity ratings, file references, and line numbers.
+
+### Architecture
+
+**End-to-end CLI flow:**
+The CLI is a single Typer command using `@app.callback(invoke_without_command=True)` since there are no subcommands. The entry point checks if the target is a GitHub URL or a local path, extracts the diff accordingly, instantiates the right LLM provider, passes the diff through the reviewer orchestrator, and renders the result with Rich. The async review is run via `asyncio.run()` from the synchronous Typer callback.
+
+**Diff extraction — local git:**
+`git.py` uses GitPython's `Repo` class. It handles four modes: uncommitted changes (diffs against HEAD), staged only (`--cached`), specific commit (diffs commit against its parent, or against git's empty tree SHA for root commits), and commit range (passes `a..b` straight to `git diff`). It also handles the edge case where the repo has no commits yet by falling back to diffing the index.
+
+**Diff extraction — GitHub API:**
+`github.py` uses httpx to make two API calls: one `GET` to `/repos/{owner}/{repo}/pulls/{number}` for PR metadata (title), and a second `GET` to the same endpoint with the `Accept: application/vnd.github.v3.diff` header to get the full unified diff. Auth is via Bearer token from `GITHUB_TOKEN` env var.
+
+**LLM abstraction layer:**
+`llm/base.py` defines an abstract base class `LLMProvider` with three things: an async `review(diff) -> ReviewResult` method, a `count_tokens(text) -> int` method, and a `max_input_tokens` class variable. Both `AnthropicProvider` and `OpenAIProvider` subclass it. The CLI picks which to instantiate based on the `--provider` flag. The reviewer orchestrator only depends on the `LLMProvider` interface, it never knows which provider it's talking to.
+
+**Structured output — Anthropic:**
+Defines a `submit_review` tool with a JSON schema matching the `ReviewResult` structure. Passes it via the `tools` parameter and forces the model to use it with `tool_choice={"type": "tool", "name": "submit_review"}`. The response comes back as a `tool_use` content block, and we read `block.input` directly. No JSON text parsing needed.
+
+**Structured output — OpenAI:**
+Uses `response_format={"type": "json_schema", "json_schema": REVIEW_SCHEMA}` with `strict: True`. The model returns JSON in `response.choices[0].message.content` which is guaranteed to match the schema. We `json.loads()` that string.
+
+**GitHub inline comments:**
+When `--post` is used, each `ReviewItem` with a file and line number becomes an inline comment in the `comments` array of `POST /repos/{owner}/{repo}/pulls/{number}/reviews`. Each comment has `path`, `line`, `side` ("RIGHT" for additions), and `body` (formatted with severity and explanation). Items without line numbers go into the top-level review body.
+
+**Libraries and why:**
+- Typer: CLI framework. Handles argument parsing, help text, and exit codes. Used instead of argparse because it's cleaner for type-annotated single-command CLIs.
+- Rich: Terminal output. Panels, colored text, styled severity labels. Used for the review display.
+- GitPython: Wraps git operations. Used to extract diffs from local repos without shelling out to git directly.
+- httpx: Async HTTP client. Used only in `github.py` for GitHub API calls. Chosen over requests because it supports async and is the modern standard.
+- Anthropic SDK: Official Python SDK. Used for the Claude API calls and token counting (`client.count_tokens()`).
+- OpenAI SDK: Official Python SDK. Used for GPT-4o API calls with structured output.
+- tiktoken: OpenAI's tokenizer library. Used for token counting on the OpenAI side since the OpenAI SDK doesn't have built-in token counting.
+
+### Hardest technical problem I solved
+
+Getting structured output reliably from both LLM providers. The naive approach is prompting "return only valid JSON" and parsing the response text. This is fragile — models wrap JSON in markdown fences, add preamble text, or occasionally produce invalid JSON.
+
+I tried raw JSON prompting first and it broke on multi-file diffs where the model would sometimes add commentary between JSON blocks. The fix was using each SDK's native structured output mechanism: Anthropic's tool use (define a tool with the schema, force the model to call it) and OpenAI's `response_format` with `strict: True`. Both guarantee the output matches the schema at the API level, not the prompt level. This means the parsing code never has to handle malformed JSON — it either gets a valid tool call or a valid JSON string.
+
+### Specific details I need to be able to say out loud
+
+**Diff chunking and parallel review:**
+The reviewer checks the diff's token count against 80% of the provider's max input tokens (180k for Claude, 110k for GPT-4o). If it exceeds the threshold, it splits the diff at `diff --git` boundaries into per-file chunks. Each chunk is reviewed in parallel using `asyncio.gather()`. Results are merged by combining all items and concatenating summaries. Files that individually exceed the token limit are skipped with a warning. Token counting uses the Anthropic SDK's `count_tokens()` for Claude and tiktoken for OpenAI.
+
+**CLI interface:**
+Single command `prrev` with one positional argument (local path or GitHub PR URL). Flags: `--commit` (specific commit), `--range` (commit range), `--staged` (staged changes only), `--provider` (anthropic or openai), `--model` (model override), `--post` (post as GitHub PR comment), `--output` (write markdown to file), `--fail-on` (exit 1 if issues at severity threshold). Exit codes: 0 for success, 1 for issues meeting `--fail-on` threshold, 2 for tool errors.
+
+**Rich output:**
+Header panel with "PRRev" title and file count subtitle. Each review item shows a colored severity label (red CRITICAL, yellow WARNING, green SUGGESTION), file:line reference in bold, one-line summary, and explanation. Summary panel at the bottom. Uses `rich.text.Text` for styled inline text and `rich.panel.Panel` for bordered sections.
+
+**Provider-agnostic design at the code level:**
+`LLMProvider` is an ABC with `review()`, `count_tokens()`, and `max_input_tokens`. Both providers subclass it. The CLI instantiates the right one based on `--provider` flag. The reviewer orchestrator's signature is `review_diff(provider: LLMProvider, diff: str)` — it calls `provider.count_tokens()` to decide chunking and `provider.review()` to do the actual review. It never imports or references either concrete provider.
+
+### What's weak or unfinished
+
+**Done:**
+- Full local diff extraction (uncommitted, staged, commit, range)
+- Both LLM providers with structured output
+- Reviewer with auto-chunking and parallel review
+- Rich terminal formatter and markdown export
+- GitHub PR fetching and inline comment posting
+- Config loading from TOML files and env vars with precedence
+- `--fail-on` flag with exit codes
+- All CLI flags wired up
+
+**Still in progress:**
+- Test suite is partially written (URL parsing and diff splitting tests done, still need tests for reviewer, formatter, config, git, providers, and CLI integration)
+- README is a placeholder (just the project name and one-line description)
+- No LICENSE file yet
+- Not published to PyPI yet
+
+**What I'd improve:**
+- The Anthropic `count_tokens()` creates a new synchronous client on every call. Should cache the client instance.
+- Single-file diffs that exceed the context window are sent anyway with no splitting. Should split within a file by hunk boundaries.
+- No retry logic for API rate limits or transient network failures.
+- The `--post` flag hardcodes `side: "RIGHT"` for all inline comments. Should use `"LEFT"` for deleted lines.
+
+### Python relevance
+
+**Async:** `asyncio.run()` as the entry point, `async/await` throughout providers and GitHub module, `asyncio.gather()` for parallel chunk reviews, `httpx.AsyncClient` and async SDK clients (`AsyncAnthropic`, `AsyncOpenAI`).
+
+**Type hints:** Union types with `X | None` syntax (Python 3.10+), `list[str]`, `tuple[str, str, int]`, `dict`, keyword-only arguments with `*`, return type annotations on all functions.
+
+**Abstract base classes:** `LLMProvider(ABC)` with `@abstractmethod` for `review()` and `count_tokens()`, class variable `max_input_tokens` overridden by subclasses.
+
+**Dataclasses:** `ReviewItem`, `ReviewResult`, `Config`, `PRInfo` — all use `@dataclass` for structured data without boilerplate.
+
+**CLI framework:** Typer with `@app.callback(invoke_without_command=True)`, `typer.Argument`, `typer.Option`, `typer.Exit` with exit codes.
+
+**HTTP clients:** httpx `AsyncClient` with `base_url`, custom headers, `raise_for_status()`. Context manager usage with `async with`.
+
+**SDK usage:** Anthropic SDK (tool use, tool_choice, async client, token counting). OpenAI SDK (structured output with response_format, json_schema, async client). tiktoken for tokenization.
+
+**Project structure:** `src/` layout with `pyproject.toml`, hatchling build backend, dynamic versioning from `__init__.py`, optional dependencies for dev tooling, editable install with `pip install -e ".[dev]"`.
+
+**Config management:** TOML parsing with `tomllib` (stdlib 3.11+) and `tomli` fallback for 3.10. Layered config precedence (CLI > env > repo config > global config > defaults). Walrus operator (`:=`) for concise env var loading. Security constraint: tokens never loaded from repo-root config.
+
+**Testing:** pytest with `pytest-asyncio`, test classes, `pytest.raises` for error cases, parametric assertions.
+
+**Other patterns:** Regex compilation with `re.compile()` for URL parsing. `pathlib.Path` throughout. f-strings. List comprehensions. Generator expressions with `any()`. Keyword-only function arguments. Context managers.

prrev-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "prrev"
+dynamic = ["version"]
+description = "CLI tool that reviews code diffs using LLMs"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Timur Mamedov", email = "tm412421@gmail.com" }]
+requires-python = ">=3.10"
+dependencies = [
+    "typer>=0.12",
+    "rich>=13.0",
+    "gitpython>=3.1",
+    "httpx>=0.27",
+    "anthropic>=0.40",
+    "openai>=1.50",
+    "tiktoken>=0.7",
+    "tomli>=2.0; python_version < '3.11'",
+]
+
+[project.scripts]
+prrev = "prrev.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/prrev/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/prrev"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "ruff>=0.6",
+]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "SIM"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"

prrev-0.1.0/src/prrev/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

prrev-0.1.0/src/prrev/cli.py

@@ -0,0 +1,130 @@
+# single command cli, uses callback bc theres no subcommands
+
+import asyncio
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from prrev.config import load_config
+from prrev.formatter import print_review, to_markdown
+from prrev.git import get_diff
+from prrev.github import fetch_pr, parse_pr_url, post_review
+from prrev.llm.anthropic import AnthropicProvider
+from prrev.llm.openai import OpenAIProvider
+from prrev.reviewer import review_diff
+
+app = typer.Typer(add_completion=False)
+console = Console()
+
+
+def _is_github_url(target: str) -> bool:
+    return target.startswith("https://github.com/") and "/pull/" in target
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    target: str = typer.Argument(..., help="Local repo path or GitHub PR URL"),
+    commit: str | None = typer.Option(None, help="Review a specific commit"),
+    range: str | None = typer.Option(None, help="Review a commit range (abc..def)"),
+    staged: bool = typer.Option(False, help="Review only staged changes"),
+    provider: str | None = typer.Option(None, help="LLM provider: anthropic or openai"),
+    model: str | None = typer.Option(None, help="Model override"),
+    post: bool = typer.Option(False, help="Post review as GitHub PR comment"),
+    output: str | None = typer.Option(None, help="Write review to markdown file"),
+    fail_on: str | None = typer.Option(
+        None, help="Exit 1 if issues at this severity or above (critical, warning, suggestion)"
+    ),
+) -> None:
+    # validate --fail-on early
+    valid_severities = {"critical", "warning", "suggestion"}
+    if fail_on and fail_on not in valid_severities:
+        console.print(f"error: --fail-on must be one of: {', '.join(valid_severities)}", style="red")
+        raise typer.Exit(2)
+
+    # cli flags override config, config fills in defaults
+    repo_path = target if not _is_github_url(target) else None
+    cfg = load_config(repo_path=repo_path)
+    prov = provider or cfg.provider
+    mdl = model or cfg.model
+
+    # route based on target type
+    if _is_github_url(target):
+        if not cfg.github_token:
+            console.print("error: GITHUB_TOKEN not set", style="red")
+            raise typer.Exit(2)
+        try:
+            owner, repo, number = parse_pr_url(target)
+            pr = asyncio.run(fetch_pr(owner, repo, number, cfg.github_token))
+            diff = pr.diff
+            console.print(f"reviewing PR #{pr.number}: {pr.title}", style="bold")
+        except ValueError as e:
+            console.print(f"error: {e}", style="red")
+            raise typer.Exit(2)
+        except Exception as e:
+            console.print(f"failed to fetch PR: {e}", style="red")
+            raise typer.Exit(2)
+    else:
+        try:
+            diff = get_diff(target, commit=commit, range=range, staged=staged)
+        except ValueError as e:
+            console.print(f"error: {e}", style="red")
+            raise typer.Exit(2)
+
+    # pick provider
+    try:
+        if prov == "openai":
+            llm = OpenAIProvider(model=mdl, api_key=cfg.openai_api_key) if mdl else OpenAIProvider(api_key=cfg.openai_api_key)
+        elif prov == "anthropic":
+            llm = AnthropicProvider(model=mdl, api_key=cfg.anthropic_api_key) if mdl else AnthropicProvider(api_key=cfg.anthropic_api_key)
+        else:
+            console.print(f"unknown provider: {prov}", style="red")
+            raise typer.Exit(2)
+    except ValueError as e:
+        console.print(f"error: {e}", style="red")
+        raise typer.Exit(2)
+
+    # run the review
+    try:
+        result = asyncio.run(review_diff(llm, diff, max_items=cfg.max_items))
+    except Exception as e:
+        console.print(f"review failed: {e}", style="red")
+        raise typer.Exit(2)
+
+    # count files in the diff for the header
+    file_count = diff.count("diff --git ")
+    print_review(result, file_count=file_count)
+
+    # markdown output
+    if output:
+        Path(output).write_text(to_markdown(result))
+        console.print(f"\nreview written to {output}", style="dim")
+
+    # post review as github pr comment
+    if post:
+        if not _is_github_url(target):
+            console.print("error: --post only works with github PR urls", style="red")
+            raise typer.Exit(2)
+        if not cfg.github_token:
+            console.print("error: GITHUB_TOKEN not set", style="red")
+            raise typer.Exit(2)
+        try:
+            items_for_api = [
+                {"file": i.file, "line": i.line, "severity": i.severity,
+                 "summary": i.summary, "explanation": i.explanation}
+                for i in result.items
+            ]
+            body = to_markdown(result)
+            asyncio.run(post_review(owner, repo, number, body, cfg.github_token, items=items_for_api))
+            console.print("\nreview posted to PR", style="bold green")
+        except Exception as e:
+            console.print(f"failed to post review: {e}", style="red")
+            raise typer.Exit(2)
+
+    # exit code based on --fail-on threshold
+    if fail_on and result.items:
+        # severity levels, lower number = more severe
+        severity_rank = {"critical": 0, "warning": 1, "suggestion": 2}
+        threshold = severity_rank[fail_on]
+        if any(severity_rank.get(i.severity, 2) <= threshold for i in result.items):
+            raise typer.Exit(1)