Gh Pr Metadata

interface:
  display_name: 'GH PR Metadata'
  short_description: 'Normalize PR title and body'
  default_prompt: "Use $gh-pr-metadata to update this repo's PR title and body to match the template and conventional-commit style."

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import subprocess
import sys
from pathlib import Path


TITLE_RE = (
    r"^(build|chore|ci|docs|feat|fix|perf|refactor|revert|test)"
    r"(\([^)]+\))?!?: .+"
)

DEFAULT_TEMPLATE = """## Description

<!--- Provide a general summary of your changes in the Title above -->
<!--- Describe your changes in detail -->

## Related Issue

<!--- This project only accepts pull requests related to open issues -->
<!--- If suggesting a new feature or change, please discuss it in an issue first -->
<!--- If fixing a bug, there should be an issue describing it with steps to reproduce -->
<!--- Please link to the issue here: -->

## Types of changes

- [ ] Docs change / refactoring / dependency upgrade
- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)

## Checklist

- [ ] I have added tests to cover my changes.
- [ ] All new and existing tests passed.
- [ ] I have updated the documentation.
"""


def run(cmd: list[str], cwd: Path) -> str:
    proc = subprocess.run(
        cmd,
        cwd=str(cwd),
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True,
        check=False,
    )
    if proc.returncode != 0:
        raise RuntimeError(proc.stderr.strip() or proc.stdout.strip())
    return proc.stdout


def read_current_pr(cwd: Path) -> tuple[str, str]:
    raw = run(
        ["gh", "pr", "view", "--json", "title,body", "--jq", "{title: .title, body: .body}"],
        cwd,
    )
    data = json.loads(raw)
    return data["title"], data["body"] or ""


def load_body(args: argparse.Namespace, cwd: Path) -> tuple[str, str]:
    if args.title or args.body or args.body_file:
        title = args.title or ""
        if args.body_file:
            body = Path(args.body_file).read_text()
        else:
            body = args.body or ""
        return title, body
    return read_current_pr(cwd)


def load_repo_template(cwd: Path) -> str:
    template_path = cwd / ".github" / "pull_request_template.md"
    if template_path.exists():
        return template_path.read_text()
    return DEFAULT_TEMPLATE


def parse_template_requirements(template: str) -> tuple[list[str], list[str], list[str]]:
    sections: list[str] = []
    type_lines: list[str] = []
    checklist_lines: list[str] = []
    current_section = ""

    for raw_line in template.splitlines():
        line = raw_line.strip()
        if line.startswith("## "):
            sections.append(line)
            current_section = line
            continue
        if not line.startswith("- [ ] "):
            continue
        if current_section == "## Types of changes":
            type_lines.append(line)
        elif current_section == "## Checklist":
            checklist_lines.append(line)

    return sections, type_lines, checklist_lines


def validate_title(title: str) -> list[str]:
    import re

    errors: list[str] = []
    if not title:
      errors.append("title is empty")
      return errors
    if not re.match(TITLE_RE, title):
        errors.append(
            "title does not match conventional format "
            "(expected `type(scope): summary` or `type: summary`)"
        )
    if title.startswith("["):
        errors.append("title should not start with a bracketed prefix")
    return errors


def validate_body(
    body: str,
    required_sections: list[str],
    required_type_lines: list[str],
    required_checklist_lines: list[str],
) -> list[str]:
    errors: list[str] = []
    positions: list[int] = []

    for section in required_sections:
        idx = body.find(section)
        if idx == -1:
            errors.append(f"missing section: {section}")
        positions.append(idx)

    valid_positions = [p for p in positions if p != -1]
    if valid_positions and valid_positions != sorted(valid_positions):
        errors.append("required sections are out of order")

    for line in required_type_lines:
        if line not in body:
            errors.append(f"missing type checkbox: {line}")

    for line in required_checklist_lines:
        if line not in body:
            errors.append(f"missing checklist item: {line}")

    return errors


def print_template(cwd: Path) -> None:
    sys.stdout.write(load_repo_template(cwd))


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Validate PR title/body against repo conventions."
    )
    parser.add_argument("--title", help="Explicit PR title to validate.")
    parser.add_argument("--body", help="Explicit PR body to validate.")
    parser.add_argument("--body-file", help="Path to a PR body file to validate.")
    parser.add_argument(
        "--repo-root",
        default=".",
        help="Repo root. Defaults to current working directory.",
    )
    parser.add_argument(
        "--print-template",
        action="store_true",
        help="Print a repo-compliant PR body scaffold and exit.",
    )
    parser.add_argument(
        "--format",
        choices=["text", "json"],
        default="text",
        help="Output format.",
    )
    args = parser.parse_args()

    cwd = Path(args.repo_root).resolve()
    if args.print_template:
        print_template(cwd)
        return 0

    required_sections, required_type_lines, required_checklist_lines = (
        parse_template_requirements(load_repo_template(cwd))
    )
    title, body = load_body(args, cwd)

    errors = validate_title(title) + validate_body(
        body,
        required_sections,
        required_type_lines,
        required_checklist_lines,
    )
    payload = {
        "ok": not errors,
        "title": title,
        "errors": errors,
    }

    if args.format == "json":
        sys.stdout.write(json.dumps(payload, indent=2) + "\n")
    else:
        if errors:
            sys.stdout.write("PR metadata validation failed:\n")
            for error in errors:
                sys.stdout.write(f"- {error}\n")
        else:
            sys.stdout.write("PR metadata validation passed.\n")

    return 0 if not errors else 1


if __name__ == "__main__":
    raise SystemExit(main())