reviewpack 0.4.0__py3-none-any.whl

reviewpack/__init__.py

@@ -0,0 +1,6 @@
+"""Reviewpack.
+
+Privacy-first context packs for AI-assisted pull request review.
+"""
+
+__version__ = "0.4.0"

reviewpack/ai_preview.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from reviewpack.models import ReviewpackResult
+from reviewpack.redaction import redact_text
+
+
+def render_ai_input_preview(result: ReviewpackResult) -> str:
+    """Render a local preview of AI-bound context.
+
+    This function does not call any AI provider. It only generates a local
+    Markdown file that shows the type of context that could be sent if a future
+    AI integration is explicitly enabled.
+    """
+
+    lines: list[str] = []
+
+    lines.append("# AI Input Preview")
+    lines.append("")
+    lines.append("This file is generated locally.")
+    lines.append("")
+    lines.append("It shows the context that may be sent to an AI provider if AI mode is enabled in a future version.")
+    lines.append("")
+    lines.append("Reviewpack does not send this content anywhere by default.")
+    lines.append("")
+    lines.append("## Included by default")
+    lines.append("")
+    lines.append("- Pull request title")
+    lines.append("- Pull request description")
+    lines.append("- Changed file paths")
+    lines.append("- Change statistics")
+    lines.append("- Deterministic risk signals")
+    lines.append("- Suggested review focus")
+    lines.append("")
+    lines.append("## Excluded by default")
+    lines.append("")
+    lines.append("- Raw diffs")
+    lines.append("- Full source code")
+    lines.append("- Branch names")
+    lines.append("- Commit messages")
+    lines.append("- Environment variables")
+    lines.append("- Terminal history")
+    lines.append("- Git remote URLs")
+    lines.append("- API tokens")
+    lines.append("")
+    lines.append("## Pull Request")
+    lines.append("")
+    lines.append(f"- Title: {redact_text(result.pr.title)}")
+    lines.append(f"- Author: {redact_text(result.pr.author)}")
+
+    if result.pr.url:
+        lines.append(f"- URL: {redact_text(result.pr.url)}")
+
+    if result.pr.description:
+        lines.append("")
+        lines.append("## Description")
+        lines.append("")
+        lines.append(redact_text(result.pr.description.strip()))
+
+    lines.append("")
+    lines.append("## Change Statistics")
+    lines.append("")
+    lines.append(f"- Files changed: {result.stats.files_changed}")
+    lines.append(f"- Lines added: {result.stats.additions}")
+    lines.append(f"- Lines deleted: {result.stats.deletions}")
+    lines.append(f"- Source files: {result.stats.source_files}")
+    lines.append(f"- Test files: {result.stats.test_files}")
+    lines.append(f"- Documentation files: {result.stats.docs_files}")
+    lines.append(f"- Dependency files: {result.stats.dependency_files}")
+    lines.append(f"- CI files: {result.stats.ci_files}")
+    lines.append(f"- Config files: {result.stats.config_files}")
+    lines.append(f"- Infrastructure files: {result.stats.infra_files}")
+    lines.append(f"- Unknown files: {result.stats.unknown_files}")
+
+    lines.append("")
+    lines.append("## Changed Files")
+    lines.append("")
+
+    for changed_file in result.changed_files:
+        lines.append(
+            f"- {redact_text(changed_file.path)} "
+            f"({changed_file.category.value}, +{changed_file.additions}/-{changed_file.deletions})"
+        )
+
+    lines.append("")
+    lines.append("## Risk Signals")
+    lines.append("")
+
+    if result.risk_signals:
+        for signal in result.risk_signals:
+            lines.append(f"- {signal.level.value}: {redact_text(signal.title)}")
+            lines.append(f"  - {redact_text(signal.message)}")
+            if signal.files:
+                lines.append("  - Affected files:")
+                for file_path in signal.files:
+                    lines.append(f"    - {redact_text(file_path)}")
+    else:
+        lines.append("- No deterministic risk signals were detected.")
+
+    lines.append("")
+    lines.append("## Suggested Review Focus")
+    lines.append("")
+
+    for item in result.review_focus:
+        lines.append(f"- {redact_text(item.title)}")
+        lines.append(f"  - {redact_text(item.reason)}")
+
+    lines.append("")
+    lines.append("## Safety Notes")
+    lines.append("")
+    lines.append("- This preview was generated without network access.")
+    lines.append("- This preview was generated without calling an AI provider.")
+    lines.append("- This preview does not include raw diffs or source code.")
+    lines.append("- This preview should be reviewed before being copied into any AI tool.")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def write_ai_input_preview(result: ReviewpackResult, output_dir: str | Path) -> Path:
+    """Write AI input preview Markdown to an output directory."""
+
+    target_dir = Path(output_dir)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    output_path = target_dir / "ai-input-preview.md"
+    output_path.write_text(render_ai_input_preview(result), encoding="utf-8")
+
+    return output_path

reviewpack/analyzer.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from collections import Counter
+
+from reviewpack.config import ReviewpackConfig
+from reviewpack.models import (
+    ChangeStats,
+    ChangedFile,
+    FileCategory,
+    ReviewFocusItem,
+    ReviewpackInput,
+    ReviewpackResult,
+)
+from reviewpack.rules import categorize_file, generate_risk_signals
+
+
+def categorize_changed_files(
+    files: list[ChangedFile],
+    config: ReviewpackConfig | None = None,
+) -> list[ChangedFile]:
+    """Return changed files with file categories populated."""
+
+    active_config = config or ReviewpackConfig()
+    categorized: list[ChangedFile] = []
+
+    for changed_file in files:
+        categorized.append(
+            changed_file.model_copy(
+                update={
+                    "category": categorize_file(changed_file.path, active_config),
+                }
+            )
+        )
+
+    return categorized
+
+
+def calculate_stats(files: list[ChangedFile]) -> ChangeStats:
+    """Calculate aggregate change statistics."""
+
+    category_counts = Counter(item.category for item in files)
+
+    return ChangeStats(
+        files_changed=len(files),
+        additions=sum(item.additions for item in files),
+        deletions=sum(item.deletions for item in files),
+        source_files=category_counts[FileCategory.SOURCE],
+        test_files=category_counts[FileCategory.TEST],
+        docs_files=category_counts[FileCategory.DOCS],
+        dependency_files=category_counts[FileCategory.DEPENDENCY],
+        ci_files=category_counts[FileCategory.CI],
+        config_files=category_counts[FileCategory.CONFIG],
+        infra_files=category_counts[FileCategory.INFRA],
+        unknown_files=category_counts[FileCategory.UNKNOWN],
+    )
+
+
+def generate_review_focus(result_files: list[ChangedFile]) -> list[ReviewFocusItem]:
+    """Generate suggested review focus areas from file categories."""
+
+    categories = {item.category for item in result_files}
+    focus: list[ReviewFocusItem] = []
+
+    if FileCategory.SOURCE in categories:
+        focus.append(
+            ReviewFocusItem(
+                title="Validate behavior changes",
+                reason="Source files changed. Review correctness, edge cases, and backward compatibility.",
+            )
+        )
+
+    if FileCategory.TEST not in categories and FileCategory.SOURCE in categories:
+        focus.append(
+            ReviewFocusItem(
+                title="Check test coverage",
+                reason="Source files changed without test updates. Confirm whether existing tests are sufficient.",
+            )
+        )
+
+    if FileCategory.DEPENDENCY in categories:
+        focus.append(
+            ReviewFocusItem(
+                title="Review dependency impact",
+                reason="Dependency files changed. Check version compatibility, security, and lockfile consistency.",
+            )
+        )
+
+    if FileCategory.CI in categories:
+        focus.append(
+            ReviewFocusItem(
+                title="Review CI behavior",
+                reason="CI configuration changed. Check triggers, permissions, secrets, and required checks.",
+            )
+        )
+
+    if FileCategory.INFRA in categories:
+        focus.append(
+            ReviewFocusItem(
+                title="Review deployment impact",
+                reason="Infrastructure files changed. Check deployment, runtime, and environment behavior.",
+            )
+        )
+
+    if FileCategory.DOCS in categories:
+        focus.append(
+            ReviewFocusItem(
+                title="Verify documentation accuracy",
+                reason="Documentation changed. Confirm examples and usage notes match the implementation.",
+            )
+        )
+
+    if not focus:
+        focus.append(
+            ReviewFocusItem(
+                title="Review changed files",
+                reason="No specific category-based focus was detected. Review the changed files manually.",
+            )
+        )
+
+    return focus
+
+
+def analyze_reviewpack_input(
+    reviewpack_input: ReviewpackInput,
+    config: ReviewpackConfig | None = None,
+) -> ReviewpackResult:
+    """Analyze Reviewpack input and return a structured result."""
+
+    active_config = config or ReviewpackConfig()
+    categorized_files = categorize_changed_files(reviewpack_input.changed_files, active_config)
+    stats = calculate_stats(categorized_files)
+    risk_signals = generate_risk_signals(categorized_files, active_config)
+    review_focus = generate_review_focus(categorized_files)
+
+    return ReviewpackResult(
+        pr=reviewpack_input.pr,
+        changed_files=categorized_files,
+        stats=stats,
+        risk_signals=risk_signals,
+        review_focus=review_focus,
+        metadata={
+            "reviewpack_version": "0.1.0",
+            "mode": "fixture",
+            "network_used": False,
+            "ai_used": False,
+        },
+    )

reviewpack/cli.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from reviewpack.ai_preview import write_ai_input_preview
+from reviewpack.analyzer import analyze_reviewpack_input
+from reviewpack.config import load_config
+from reviewpack.git import collect_changed_files_from_git
+from reviewpack.github_client import GitHubAPIError, collect_reviewpack_input_from_github_url
+from reviewpack.models import PullRequestInfo, ReviewpackInput
+from reviewpack.renderers import write_reviewpack_outputs
+
+app = typer.Typer(
+    name="reviewpack",
+    help="Privacy-first context packs for AI-assisted pull request review.",
+)
+
+console = Console()
+
+
+@app.command("from-fixture")
+def from_fixture(
+    fixture_path: Path = typer.Argument(
+        ...,
+        help="Path to a Reviewpack fixture JSON file.",
+    ),
+    output: Path = typer.Option(
+        Path(".reviewpack"),
+        "--output",
+        "-o",
+        help="Directory where Reviewpack output files will be written.",
+    ),
+    config: Path | None = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Optional path to a .reviewpack.yml config file.",
+    ),
+    preview_ai_input: bool = typer.Option(
+        False,
+        "--preview-ai-input",
+        help="Generate a local AI input preview file without calling an AI provider.",
+    ),
+) -> None:
+    """Generate a review context pack from a local fixture JSON file."""
+
+    if not fixture_path.exists():
+        console.print(f"[red]Fixture file not found:[/red] {fixture_path}")
+        raise typer.Exit(code=1)
+
+    raw_json = fixture_path.read_text(encoding="utf-8")
+    reviewpack_input = ReviewpackInput.model_validate_json(raw_json)
+    reviewpack_config = load_config(config)
+
+    result = analyze_reviewpack_input(reviewpack_input, reviewpack_config)
+    write_reviewpack_outputs(result, output)
+
+    if preview_ai_input:
+        write_ai_input_preview(result, output)
+
+    print_success(output, preview_ai_input=preview_ai_input)
+
+
+@app.command("local")
+def local(
+    base: str = typer.Option(
+        "main",
+        "--base",
+        "-b",
+        help="Base git ref used for local diff.",
+    ),
+    head: str = typer.Option(
+        "HEAD",
+        "--head",
+        help="Head git ref used for local diff.",
+    ),
+    repo: Path = typer.Option(
+        Path("."),
+        "--repo",
+        help="Path to the local git repository.",
+    ),
+    output: Path = typer.Option(
+        Path(".reviewpack"),
+        "--output",
+        "-o",
+        help="Directory where Reviewpack output files will be written.",
+    ),
+    config: Path | None = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Optional path to a .reviewpack.yml config file.",
+    ),
+    title: str = typer.Option(
+        "Local git diff",
+        "--title",
+        help="Title used in the generated review pack.",
+    ),
+    author: str = typer.Option(
+        "local",
+        "--author",
+        help="Author label used in the generated review pack.",
+    ),
+    preview_ai_input: bool = typer.Option(
+        False,
+        "--preview-ai-input",
+        help="Generate a local AI input preview file without calling an AI provider.",
+    ),
+) -> None:
+    """Generate a review context pack from a local git diff."""
+
+    reviewpack_config = load_config(config)
+
+    try:
+        changed_files = collect_changed_files_from_git(
+            base=base,
+            head=head,
+            repo_path=repo,
+        )
+    except RuntimeError as error:
+        console.print(f"[red]Failed to collect local git diff:[/red] {error}")
+        raise typer.Exit(code=1) from error
+
+    reviewpack_input = ReviewpackInput(
+        pr=PullRequestInfo(
+            title=title,
+            author=author,
+        ),
+        changed_files=changed_files,
+    )
+
+    result = analyze_reviewpack_input(reviewpack_input, reviewpack_config)
+    result.metadata["mode"] = "local_git"
+    result.metadata["network_used"] = False
+    result.metadata["ai_used"] = False
+
+    write_reviewpack_outputs(result, output)
+
+    if preview_ai_input:
+        write_ai_input_preview(result, output)
+
+    print_success(output, preview_ai_input=preview_ai_input)
+
+
+@app.command("github")
+def github(
+    pr_url: str = typer.Argument(
+        ...,
+        help="GitHub pull request URL.",
+    ),
+    output: Path = typer.Option(
+        Path(".reviewpack"),
+        "--output",
+        "-o",
+        help="Directory where Reviewpack output files will be written.",
+    ),
+    config: Path | None = typer.Option(
+        None,
+        "--config",
+        "-c",
+        help="Optional path to a .reviewpack.yml config file.",
+    ),
+    token: str | None = typer.Option(
+        None,
+        "--token",
+        help="Optional GitHub token. Prefer REVIEWPACK_GITHUB_TOKEN for local use.",
+    ),
+    preview_ai_input: bool = typer.Option(
+        False,
+        "--preview-ai-input",
+        help="Generate a local AI input preview file without calling an AI provider.",
+    ),
+) -> None:
+    """Generate a review context pack from GitHub PR metadata."""
+
+    reviewpack_config = load_config(config)
+
+    try:
+        reviewpack_input = collect_reviewpack_input_from_github_url(pr_url, token=token)
+    except (ValueError, GitHubAPIError) as error:
+        console.print(f"[red]Failed to collect GitHub pull request data:[/red] {error}")
+        raise typer.Exit(code=1) from error
+
+    result = analyze_reviewpack_input(reviewpack_input, reviewpack_config)
+    result.metadata["mode"] = "github"
+    result.metadata["network_used"] = True
+    result.metadata["ai_used"] = False
+
+    write_reviewpack_outputs(result, output)
+
+    if preview_ai_input:
+        write_ai_input_preview(result, output)
+
+    print_success(output, preview_ai_input=preview_ai_input)
+
+
+@app.command("version")
+def version() -> None:
+    """Show Reviewpack version."""
+
+    from reviewpack import __version__
+
+    console.print(__version__)
+
+
+def print_success(output: Path, preview_ai_input: bool = False) -> None:
+    """Print generated output paths."""
+
+    console.print("[green]Reviewpack generated successfully.[/green]")
+    console.print(f"Output directory: {output}")
+    console.print("")
+    console.print("Generated files:")
+    console.print(f"- {output / 'pr-summary.md'}")
+    console.print(f"- {output / 'risk-checklist.md'}")
+    console.print(f"- {output / 'ai-review-prompt.md'}")
+    console.print(f"- {output / 'release-note-hints.md'}")
+    console.print(f"- {output / 'reviewer-checklist.md'}")
+    console.print(f"- {output / 'reviewpack.json'}")
+
+    if preview_ai_input:
+        console.print(f"- {output / 'ai-input-preview.md'}")
+
+
+if __name__ == "__main__":
+    app()

reviewpack/config.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class PrivacyConfig(BaseModel):
+    """Privacy controls for Reviewpack.
+
+    Reviewpack is local-first and privacy-first by default.
+
+    These defaults intentionally avoid sending branch names, commit messages,
+    raw diffs, or local environment information to any external service.
+    """
+
+    include_branch_name: bool = False
+    include_commit_messages: bool = False
+    include_diff_snippets: bool = False
+    include_file_paths: bool = True
+    redact_secrets: bool = True
+
+
+class AIConfig(BaseModel):
+    """Optional AI configuration.
+
+    AI is disabled by default. v0.1.0 does not call AI providers.
+    These fields reserve a stable configuration shape for future versions.
+    """
+
+    enabled: bool = False
+    provider: str | None = None
+    model: str | None = None
+    max_input_chars: int = 12000
+
+
+class LargePRConfig(BaseModel):
+    """Thresholds for large pull request detection."""
+
+    changed_files: int = 20
+    changed_lines: int = 800
+
+
+class ReviewpackConfig(BaseModel):
+    """Project-level Reviewpack configuration."""
+
+    risk_paths_high: list[str] = Field(
+        default_factory=lambda: [
+            "src/auth/**",
+            "src/security/**",
+            "src/payment/**",
+        ]
+    )
+    test_paths: list[str] = Field(
+        default_factory=lambda: [
+            "tests/**",
+            "__tests__/**",
+            "test/**",
+        ]
+    )
+    docs_paths: list[str] = Field(
+        default_factory=lambda: [
+            "README.md",
+            "docs/**",
+        ]
+    )
+    large_pr: LargePRConfig = Field(default_factory=LargePRConfig)
+    privacy: PrivacyConfig = Field(default_factory=PrivacyConfig)
+    ai: AIConfig = Field(default_factory=AIConfig)
+
+
+def load_config(path: str | Path | None = None) -> ReviewpackConfig:
+    """Load Reviewpack configuration.
+
+    If no path is provided, the default configuration is returned.
+    If the file does not exist, the default configuration is returned.
+
+    The first public version keeps configuration loading intentionally simple.
+    """
+
+    if path is None:
+        return ReviewpackConfig()
+
+    config_path = Path(path)
+
+    if not config_path.exists():
+        return ReviewpackConfig()
+
+    data = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    return ReviewpackConfig.model_validate(data)

reviewpack/git.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from reviewpack.models import ChangedFile
+
+
+def parse_numstat_value(value: str) -> int:
+    """Parse a git numstat value.
+
+    Git reports binary files as "-". Reviewpack treats those as zero-line changes
+    for deterministic summary purposes.
+    """
+
+    if value == "-":
+        return 0
+
+    return int(value)
+
+
+def parse_numstat_line(line: str) -> ChangedFile | None:
+    """Parse one line of git diff numstat output.
+
+    Expected format:
+    additions, deletions, path separated by tab characters.
+    """
+
+    parts = line.rstrip("\n").split("\t")
+
+    if len(parts) < 3:
+        return None
+
+    additions_raw = parts[0]
+    deletions_raw = parts[1]
+    path = parts[-1]
+
+    return ChangedFile(
+        path=path,
+        additions=parse_numstat_value(additions_raw),
+        deletions=parse_numstat_value(deletions_raw),
+    )
+
+
+def parse_numstat(text: str) -> list[ChangedFile]:
+    """Parse git diff numstat output into changed files."""
+
+    files: list[ChangedFile] = []
+
+    for line in text.splitlines():
+        if not line.strip():
+            continue
+
+        changed_file = parse_numstat_line(line)
+
+        if changed_file is not None:
+            files.append(changed_file)
+
+    return files
+
+
+def collect_changed_files_from_git(
+    base: str = "main",
+    head: str = "HEAD",
+    repo_path: str | Path = ".",
+) -> list[ChangedFile]:
+    """Collect changed files from a local git repository.
+
+    This function only uses local git metadata. It does not use network access,
+    GitHub APIs, AI providers, environment variables, or external services.
+    """
+
+    repository = Path(repo_path)
+
+    command = [
+        "git",
+        "diff",
+        "--numstat",
+        f"{base}...{head}",
+    ]
+
+    completed = subprocess.run(
+        command,
+        cwd=repository,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    if completed.returncode != 0:
+        message = completed.stderr.strip() or "git diff failed"
+        raise RuntimeError(message)
+
+    return parse_numstat(completed.stdout)