prrev 0.1.0__py3-none-any.whl

prrev/__init__.py

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

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)

prrev/config.py

@@ -0,0 +1,89 @@
+# config file loading and env var handling
+# precedence: cli flags > env vars > repo .prrev.toml > global config > defaults
+# tokens only from env vars or global config, never repo config (security)
+
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomllib
+    except ImportError:
+        import tomli as tomllib
+
+GLOBAL_CONFIG_PATH = Path.home() / ".config" / "prrev" / "config.toml"
+REPO_CONFIG_NAME = ".prrev.toml"
+
+
+@dataclass
+class Config:
+    provider: str = "anthropic"
+    model: str | None = None
+    github_token: str | None = None
+    anthropic_api_key: str | None = None
+    openai_api_key: str | None = None
+    max_items: int = 20
+
+
+def _load_toml(path: Path) -> dict:
+    if not path.is_file():
+        return {}
+    with open(path, "rb") as f:
+        return tomllib.load(f)
+
+
+def load_config(repo_path: str | None = None) -> Config:
+    # start with defaults
+    cfg = Config()
+
+    # global config
+    global_data = _load_toml(GLOBAL_CONFIG_PATH)
+    _apply_toml(cfg, global_data, allow_tokens=True)
+
+    # repo config, tokens not allowed here
+    if repo_path:
+        repo_data = _load_toml(Path(repo_path) / REPO_CONFIG_NAME)
+        _apply_toml(cfg, repo_data, allow_tokens=False)
+
+    # env vars override everything
+    if v := os.environ.get("PRREV_PROVIDER"):
+        cfg.provider = v
+    if v := os.environ.get("PRREV_MODEL"):
+        cfg.model = v
+    if v := os.environ.get("PRREV_MAX_ITEMS"):
+        cfg.max_items = int(v)
+    if v := os.environ.get("GITHUB_TOKEN"):
+        cfg.github_token = v
+    if v := os.environ.get("ANTHROPIC_API_KEY"):
+        cfg.anthropic_api_key = v
+    if v := os.environ.get("OPENAI_API_KEY"):
+        cfg.openai_api_key = v
+
+    return cfg
+
+
+def _apply_toml(cfg: Config, data: dict, *, allow_tokens: bool) -> None:
+    llm = data.get("llm", {})
+    if v := llm.get("provider"):
+        cfg.provider = v
+    if v := llm.get("model"):
+        cfg.model = v
+
+    review = data.get("review", {})
+    if v := review.get("max_items"):
+        cfg.max_items = int(v)
+
+    # tokens only from global config, not repo config
+    if allow_tokens:
+        github = data.get("github", {})
+        if v := github.get("token"):
+            cfg.github_token = v
+        llm_keys = data.get("llm", {})
+        if v := llm_keys.get("anthropic_api_key"):
+            cfg.anthropic_api_key = v
+        if v := llm_keys.get("openai_api_key"):
+            cfg.openai_api_key = v

prrev/formatter.py

@@ -0,0 +1,72 @@
+# rich terminal output and markdown file export
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from prrev.llm.base import ReviewItem, ReviewResult
+
+console = Console()
+
+SEVERITY_STYLES = {
+    "critical": ("red", "CRITICAL"),
+    "warning": ("yellow", "WARNING"),
+    "suggestion": ("green", "SUGGESTION"),
+}
+
+
+def _format_item(item: ReviewItem) -> Text:
+    color, label = SEVERITY_STYLES.get(item.severity, ("white", item.severity.upper()))
+
+    text = Text()
+    text.append(f"{label:10s}", style=f"bold {color}")
+    text.append(f"  {item.file}", style="bold")
+    if item.line is not None:
+        text.append(f":{item.line}", style="bold")
+    text.append("\n")
+    text.append(f"   {item.summary}\n", style="bold")
+    text.append(f"   {item.explanation}\n")
+
+    return text
+
+
+def print_review(result: ReviewResult, file_count: int = 0) -> None:
+    # header panel
+    subtitle = f"Reviewed {file_count} files" if file_count else "Review"
+    console.print(Panel(
+        Text("PRRev", style="bold white"),
+        subtitle=subtitle,
+        border_style="blue",
+    ))
+    console.print()
+
+    if not result.items:
+        console.print("  No issues found.", style="bold green")
+        console.print()
+    else:
+        for item in result.items:
+            console.print(_format_item(item))
+
+    # summary at the bottom
+    console.print(Panel(result.summary, title="Summary", border_style="dim"))
+
+
+def to_markdown(result: ReviewResult) -> str:
+    lines = ["# PRRev Code Review\n"]
+
+    if not result.items:
+        lines.append("No issues found.\n")
+    else:
+        for item in result.items:
+            color, label = SEVERITY_STYLES.get(item.severity, ("white", item.severity.upper()))
+            location = item.file
+            if item.line is not None:
+                location += f":{item.line}"
+            lines.append(f"### {label} — {location}\n")
+            lines.append(f"**{item.summary}**\n")
+            lines.append(f"{item.explanation}\n")
+
+    lines.append(f"## Summary\n")
+    lines.append(f"{result.summary}\n")
+
+    return "\n".join(lines)

prrev/git.py

@@ -0,0 +1,56 @@
+# local diff extraction via gitpython
+
+from git import Repo, InvalidGitRepositoryError, NoSuchPathError
+
+
+def get_diff(
+    repo_path: str,
+    *,
+    commit: str | None = None,
+    range: str | None = None,
+    staged: bool = False,
+) -> str:
+    try:
+        repo = Repo(repo_path)
+    except InvalidGitRepositoryError:
+        raise ValueError(f"not a git repository: {repo_path}")
+    except NoSuchPathError:
+        raise ValueError(f"path does not exist: {repo_path}")
+
+    if repo.bare:
+        raise ValueError(f"cannot diff a bare repository: {repo_path}")
+
+    # specific commit, show its diff against parent
+    if commit:
+        commit_obj = repo.commit(commit)
+        if commit_obj.parents:
+            return repo.git.diff(commit_obj.parents[0].hexsha, commit_obj.hexsha)
+        # root commit, diff against empty tree
+        empty_tree = repo.git.hash_object("-t", "tree", "/dev/null")
+        return repo.git.diff(empty_tree, commit_obj.hexsha)
+
+    # commit range like abc123..def456
+    if range:
+        if ".." not in range:
+            raise ValueError(f"invalid range format, expected 'a..b': {range}")
+        return repo.git.diff(range)
+
+    # staged only
+    if staged:
+        diff = repo.git.diff("--cached")
+        if not diff:
+            raise ValueError("no staged changes found")
+        return diff
+
+    # default: all uncommitted changes (staged + unstaged)
+    # diff HEAD to catch both, but if theres no commits yet diff the index
+    if repo.head.is_valid():
+        diff = repo.git.diff("HEAD")
+    else:
+        # no commits yet, show whats staged
+        diff = repo.git.diff("--cached")
+
+    if not diff:
+        raise ValueError("no changes found")
+
+    return diff

prrev/github.py

@@ -0,0 +1,95 @@
+# github api, fetch pr diffs and post review comments
+
+import re
+from dataclasses import dataclass
+
+import httpx
+
+API_BASE = "https://api.github.com"
+
+# matches urls like https://github.com/owner/repo/pull/42
+PR_URL_PATTERN = re.compile(r"https://github\.com/([^/]+)/([^/]+)/pull/(\d+)")
+
+
+@dataclass
+class PRInfo:
+    owner: str
+    repo: str
+    number: int
+    title: str
+    diff: str
+
+
+def parse_pr_url(url: str) -> tuple[str, str, int]:
+    match = PR_URL_PATTERN.match(url)
+    if not match:
+        raise ValueError(f"invalid github PR url: {url}")
+    return match.group(1), match.group(2), int(match.group(3))
+
+
+async def fetch_pr(owner: str, repo: str, number: int, token: str) -> PRInfo:
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/json",
+    }
+
+    async with httpx.AsyncClient(base_url=API_BASE, headers=headers) as client:
+        # get pr metadata
+        resp = await client.get(f"/repos/{owner}/{repo}/pulls/{number}")
+        resp.raise_for_status()
+        pr_data = resp.json()
+
+        # get the full diff using the diff accept header
+        diff_resp = await client.get(
+            f"/repos/{owner}/{repo}/pulls/{number}",
+            headers={"Accept": "application/vnd.github.v3.diff"},
+        )
+        diff_resp.raise_for_status()
+
+    return PRInfo(
+        owner=owner,
+        repo=repo,
+        number=number,
+        title=pr_data.get("title", ""),
+        diff=diff_resp.text,
+    )
+
+
+async def post_review(
+    owner: str,
+    repo: str,
+    number: int,
+    body: str,
+    token: str,
+    items: list[dict] | None = None,
+) -> None:
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/json",
+    }
+
+    # build inline comments from items that have file + line
+    comments = []
+    if items:
+        for item in items:
+            if item.get("file") and item.get("line"):
+                comments.append({
+                    "path": item["file"],
+                    "line": item["line"],
+                    "side": "RIGHT",
+                    "body": f"**{item['severity'].upper()}**: {item['summary']}\n\n{item['explanation']}",
+                })
+
+    payload: dict = {
+        "body": body,
+        "event": "COMMENT",
+    }
+    if comments:
+        payload["comments"] = comments
+
+    async with httpx.AsyncClient(base_url=API_BASE, headers=headers) as client:
+        resp = await client.post(
+            f"/repos/{owner}/{repo}/pulls/{number}/reviews",
+            json=payload,
+        )
+        resp.raise_for_status()

prrev/llm/anthropic.py

@@ -0,0 +1,107 @@
+# anthropic provider, uses tool use for structured output so we
+# dont have to parse json from raw text
+
+import os
+
+import anthropic
+
+from prrev.llm.base import LLMProvider, ReviewItem, ReviewResult
+
+# tool schema that forces the model to call submit_review
+# with the exact shape we need
+REVIEW_TOOL = {
+    "name": "submit_review",
+    "description": "Submit a structured code review.",
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "summary": {
+                "type": "string",
+                "description": "1-2 sentence overall assessment of the diff.",
+            },
+            "items": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "severity": {
+                            "type": "string",
+                            "enum": ["critical", "warning", "suggestion"],
+                        },
+                        "file": {
+                            "type": "string",
+                            "description": "filepath from the diff header",
+                        },
+                        "line": {
+                            "type": ["integer", "null"],
+                            "description": "new-file line number, or null if not identifiable",
+                        },
+                        "summary": {
+                            "type": "string",
+                            "description": "one line description of the issue",
+                        },
+                        "explanation": {
+                            "type": "string",
+                            "description": "1-3 sentence explanation",
+                        },
+                    },
+                    "required": ["severity", "file", "line", "summary", "explanation"],
+                },
+            },
+        },
+        "required": ["summary", "items"],
+    },
+}
+
+SYSTEM_PROMPT = (
+    "You are a senior code reviewer. You will receive a unified diff. "
+    "Review it for bugs, security issues, logic errors, performance problems, "
+    "and style issues. Be concise, no filler. "
+    "If the diff is clean, submit an empty items array with a positive summary. "
+    "Use the submit_review tool to return your review."
+)
+
+
+class AnthropicProvider(LLMProvider):
+    max_input_tokens = 180_000  # claude sonnet/opus context is 200k, leave room for output
+
+    def __init__(self, model: str = "claude-sonnet-4-6", api_key: str | None = None):
+        self.model = model
+        key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+        if not key:
+            raise ValueError("ANTHROPIC_API_KEY not set")
+        self.client = anthropic.AsyncAnthropic(api_key=key)
+
+    def count_tokens(self, text: str) -> int:
+        # synchronous token counting using the anthropic sdk
+        sync_client = anthropic.Anthropic(api_key=self.client.api_key)
+        return sync_client.count_tokens(text)
+
+    async def review(self, diff: str) -> ReviewResult:
+        response = await self.client.messages.create(
+            model=self.model,
+            max_tokens=4096,
+            system=SYSTEM_PROMPT,
+            tools=[REVIEW_TOOL],
+            # force the model to use our tool
+            tool_choice={"type": "tool", "name": "submit_review"},
+            messages=[{"role": "user", "content": diff}],
+        )
+
+        # find the tool use block in the response
+        for block in response.content:
+            if block.type == "tool_use" and block.name == "submit_review":
+                data = block.input
+                items = [
+                    ReviewItem(
+                        severity=item["severity"],
+                        file=item["file"],
+                        line=item.get("line"),
+                        summary=item["summary"],
+                        explanation=item["explanation"],
+                    )
+                    for item in data.get("items", [])
+                ]
+                return ReviewResult(items=items, summary=data.get("summary", ""))
+
+        raise RuntimeError("model did not call submit_review tool")

prrev/llm/base.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class ReviewItem:
+    severity: str  # "critical" | "warning" | "suggestion"
+    file: str
+    line: int | None  # new-file line number (right side of diff)
+    summary: str
+    explanation: str
+
+
+@dataclass
+class ReviewResult:
+    items: list[ReviewItem]
+    summary: str
+
+
+class LLMProvider(ABC):
+    # max input tokens the model can handle, subclasses override
+    max_input_tokens: int = 100_000
+
+    @abstractmethod
+    async def review(self, diff: str) -> ReviewResult:
+        ...
+
+    @abstractmethod
+    def count_tokens(self, text: str) -> int:
+        ...

prrev/llm/openai.py

@@ -0,0 +1,107 @@
+# openai provider, uses response_format for structured output
+
+import json
+import os
+
+import openai
+import tiktoken
+
+from prrev.llm.base import LLMProvider, ReviewItem, ReviewResult
+
+# json schema for structured output, same shape as the anthropic tool
+REVIEW_SCHEMA = {
+    "name": "review_response",
+    "strict": True,
+    "schema": {
+        "type": "object",
+        "properties": {
+            "summary": {
+                "type": "string",
+                "description": "1-2 sentence overall assessment of the diff.",
+            },
+            "items": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "severity": {
+                            "type": "string",
+                            "enum": ["critical", "warning", "suggestion"],
+                        },
+                        "file": {
+                            "type": "string",
+                            "description": "filepath from the diff header",
+                        },
+                        "line": {
+                            "type": ["integer", "null"],
+                            "description": "new-file line number, or null if not identifiable",
+                        },
+                        "summary": {
+                            "type": "string",
+                            "description": "one line description of the issue",
+                        },
+                        "explanation": {
+                            "type": "string",
+                            "description": "1-3 sentence explanation",
+                        },
+                    },
+                    "required": ["severity", "file", "line", "summary", "explanation"],
+                    "additionalProperties": False,
+                },
+            },
+        },
+        "required": ["summary", "items"],
+        "additionalProperties": False,
+    },
+}
+
+SYSTEM_PROMPT = (
+    "You are a senior code reviewer. You will receive a unified diff. "
+    "Review it for bugs, security issues, logic errors, performance problems, "
+    "and style issues. Be concise, no filler. "
+    "If the diff is clean, return an empty items array with a positive summary."
+)
+
+
+class OpenAIProvider(LLMProvider):
+    max_input_tokens = 110_000  # gpt-4o is 128k, leave room for output
+
+    def __init__(self, model: str = "gpt-4o", api_key: str | None = None):
+        self.model = model
+        key = api_key or os.environ.get("OPENAI_API_KEY")
+        if not key:
+            raise ValueError("OPENAI_API_KEY not set")
+        self.client = openai.AsyncOpenAI(api_key=key)
+
+    def count_tokens(self, text: str) -> int:
+        try:
+            enc = tiktoken.encoding_for_model(self.model)
+        except KeyError:
+            enc = tiktoken.get_encoding("cl100k_base")
+        return len(enc.encode(text))
+
+    async def review(self, diff: str) -> ReviewResult:
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                {"role": "user", "content": diff},
+            ],
+            response_format={
+                "type": "json_schema",
+                "json_schema": REVIEW_SCHEMA,
+            },
+        )
+
+        data = json.loads(response.choices[0].message.content)
+        items = [
+            ReviewItem(
+                severity=item["severity"],
+                file=item["file"],
+                line=item.get("line"),
+                summary=item["summary"],
+                explanation=item["explanation"],
+            )
+            for item in data.get("items", [])
+        ]
+        return ReviewResult(items=items, summary=data.get("summary", ""))

prrev/reviewer.py

@@ -0,0 +1,102 @@
+# orchestrator, takes diff + provider, returns structured review
+# auto-chunks when diff exceeds 80% of the providers context window
+
+import asyncio
+
+from prrev.llm.base import LLMProvider, ReviewItem, ReviewResult
+
+DIFF_HEADER = "diff --git "
+
+# chunk when diff uses more than 80% of the providers max input tokens
+CHUNK_THRESHOLD = 0.8
+
+
+def _split_by_file(diff: str) -> list[str]:
+    chunks = []
+    current: list[str] = []
+
+    for line in diff.splitlines(keepends=True):
+        if line.startswith(DIFF_HEADER) and current:
+            chunks.append("".join(current))
+            current = []
+        current.append(line)
+
+    if current:
+        chunks.append("".join(current))
+
+    return chunks
+
+
+async def review_diff(
+    provider: LLMProvider,
+    diff: str,
+    *,
+    max_items: int = 20,
+) -> ReviewResult:
+    if not diff.strip():
+        raise ValueError("empty diff")
+
+    # check if we need to chunk based on token count
+    token_count = provider.count_tokens(diff)
+    threshold = int(provider.max_input_tokens * CHUNK_THRESHOLD)
+
+    if token_count <= threshold:
+        result = await provider.review(diff)
+        return _truncate(result, max_items)
+
+    # diff is too big, split by file and review in parallel
+    file_diffs = _split_by_file(diff)
+    if len(file_diffs) <= 1:
+        # single file thats too big, just send it and hope for the best.
+        # TODO: split within file by hunk
+        result = await provider.review(diff)
+        return _truncate(result, max_items)
+
+    # skip files that individually exceed the threshold
+    reviewable = []
+    skipped_files = []
+    for chunk in file_diffs:
+        if provider.count_tokens(chunk) > threshold:
+            # grab filename from the diff header for the warning
+            first_line = chunk.split("\n", 1)[0]
+            skipped_files.append(first_line)
+        else:
+            reviewable.append(chunk)
+
+    results = await asyncio.gather(*[provider.review(d) for d in reviewable])
+    merged = _merge_results(list(results))
+
+    # add warnings for skipped files
+    for skipped in skipped_files:
+        merged.items.append(ReviewItem(
+            severity="warning",
+            file=skipped,
+            line=None,
+            summary="file skipped, too large for context window",
+            explanation="this files diff exceeded the models token limit and was not reviewed.",
+        ))
+
+    return _truncate(merged, max_items)
+
+
+def _merge_results(results: list[ReviewResult]) -> ReviewResult:
+    all_items: list[ReviewItem] = []
+    summaries: list[str] = []
+
+    for r in results:
+        all_items.extend(r.items)
+        if r.summary:
+            summaries.append(r.summary)
+
+    summary = " ".join(summaries) if summaries else "No issues found."
+    return ReviewResult(items=all_items, summary=summary)
+
+
+def _truncate(result: ReviewResult, max_items: int) -> ReviewResult:
+    if len(result.items) <= max_items:
+        return result
+
+    # keep criticals first, then warnings, drop suggestions
+    severity_order = {"critical": 0, "warning": 1, "suggestion": 2}
+    sorted_items = sorted(result.items, key=lambda i: severity_order.get(i.severity, 2))
+    return ReviewResult(items=sorted_items[:max_items], summary=result.summary)

prrev-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,15 @@
+prrev/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+prrev/cli.py,sha256=7mQrMIL8un-ndcqumvt3aJUOkOtmm0JxdKJLzoyX0xs,5307
+prrev/config.py,sha256=rXoC8bAM7zPtYvn1bzpXGP9sQxq-TTvxL5RLU36AqyM,2532
+prrev/formatter.py,sha256=FY49jCcbolcwABS3ZYmn3cfT9lYAbEZ503BDHE9PluQ,2125
+prrev/git.py,sha256=GLPlLQZib85N8hCpoCRtB3YxT2SW-fmKp29A-r53Oto,1712
+prrev/github.py,sha256=1vANHkdzgagYHbDm2EEN6tmY9aj3vQYJSiTFkJpJ3Mc,2557
+prrev/reviewer.py,sha256=J5ODnnGXSaKk7Kx9jRqlEFJWM1GCMFaf5VCshVJCRyU,3241
+prrev/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prrev/llm/anthropic.py,sha256=pXjknqPHDDsSdAEqWwW7xeQn2n3aW8LefVoVv8bUqjk,4132
+prrev/llm/base.py,sha256=gdCCuLBol-f7fKIQ7xgKxzvXyDGaB2iInMnpTX_7iz8,650
+prrev/llm/openai.py,sha256=cBny6EbXD_4l2tbW4rfhcIgRx5rvwUgPAyo2NUD6R6M,3785
+prrev-0.1.0.dist-info/METADATA,sha256=cTdfvXZNLHzTlAZ1QE94O3PAsW-YVqph4fMxhToZh40,3457
+prrev-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+prrev-0.1.0.dist-info/entry_points.txt,sha256=tmn8g4SfTYeuGy3eWUaBHY9gM8GCVutgLXFTvPtSfHg,40
+prrev-0.1.0.dist-info/RECORD,,

prrev-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

prrev-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+prrev = prrev.cli:app