End-to-end PR reviewer

name: pr-reviewer-e2e
version: 1

role: >
  Senior Analytics Engineering Reviewer responsible for end-to-end PR review:
  spec alignment, code quality, tests, docs, and downstream impact.

goal: >
  For the PR referenced in the trigger message:
  (1) read the PR title and description,
  (2) call get_linear_issue to fetch the linked ticket and verify the PR
      delivers what the ticket asked for,
  (3) read every changed .sql and .yml file in the diff,
  (4) check test coverage on new or modified models,
  (5) check documentation completeness in schema YAML,
  (6) flag any breaking-change risk on downstream consumers.
  Post a single structured review to the PR Slack thread under the headings:
  SCOPE / CODE / TESTS / DOCS / IMPACT / VERDICT.

backstory: >
  You are thorough but never noisy. You always cite the file and line for
  any issue you flag. If the PR description has no Linear link, say so in
  SCOPE and continue. You never approve a PR where TESTS or DOCS is FAIL.

tools:
  mode: allowlist
  list:
    - read_file
    - search_files_and_directories
    - ripgrep_search
    - get_linear_issue
    - run_sql_query
    - post_slack_message

slack:
  channel: "#pr-reviews"

import os
import re
import json
import subprocess
import urllib.request

from paradime import Paradime

paradime = Paradime(
    api_endpoint=os.environ["PARADIME_API_ENDPOINT"],
    api_key=os.environ["PARADIME_API_KEY"],
    api_secret=os.environ["PARADIME_API_SECRET"],
)

# 1. Read the PR event payload that GitHub Actions writes to disk
with open(os.environ["GITHUB_EVENT_PATH"]) as f:
    event = json.load(f)

pr = event["pull_request"]
pr_number = pr["number"]
pr_title = pr["title"]
pr_body = pr["body"] or ""
pr_url = pr["html_url"]
base_sha = pr["base"]["sha"]
head_sha = pr["head"]["sha"]

# 2. Get the list of changed files
changed = subprocess.check_output(
    ["git", "diff", "--name-only", f"{base_sha}...{head_sha}"]
).decode().splitlines()

# 3. Extract Linear issue id from the PR body (e.g. "Closes DATA-417")
linear_match = re.search(r"\b([A-Z]{2,10}-\d+)\b", pr_body)
linear_id = linear_match.group(1) if linear_match else None

# 4. Build the trigger message
files_block = "\n".join(f"  - {f}" for f in changed) or "  (no files)"
linear_block = (
    f"Linked Linear issue: {linear_id}. Call get_linear_issue to read it."
    if linear_id
    else "No Linear issue link found in the PR description."
)

message = f"""Review PR #{pr_number}: {pr_title}
URL: {pr_url}

PR description:
\"\"\"
{pr_body}
\"\"\"

{linear_block}

Changed files:
{files_block}

Read each changed file with read_file, verify the PR delivers what the ticket
asked for, and post your review to the PR Slack thread under SCOPE / CODE /
TESTS / DOCS / IMPACT / VERDICT.
"""

result = paradime.dinoai_agents.trigger_run(
    agent="pr-reviewer-e2e",
    message=message,
)
print(f"Started review session: {result.agent_session_id}")

# 5. Post the session id back to the PR as a comment
gh_token = os.environ.get("GITHUB_TOKEN")
if gh_token:
    repo = os.environ["GITHUB_REPOSITORY"]
    body = f"DinoAI review started — session `{result.agent_session_id}` (see #pr-reviews)."
    req = urllib.request.Request(
        f"https://api.github.com/repos/{repo}/issues/{pr_number}/comments",
        data=json.dumps({"body": body}).encode(),
        headers={
            "Authorization": f"Bearer {gh_token}",
            "Accept": "application/vnd.github+json",
        },
        method="POST",
    )
    urllib.request.urlopen(req).read()

name: DinoAI end-to-end PR review

on:
  pull_request:
    types: [opened, synchronize, ready_for_review]

permissions:
  pull-requests: write
  contents: read

jobs:
  review:
    runs-on: ubuntu-latest
    timeout-minutes: 35
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0   # need history for git diff between base and head

      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Install Paradime SDK
        run: pip install paradime-io

      - name: Run end-to-end PR reviewer
        env:
          PARADIME_API_ENDPOINT:  ${{ secrets.PARADIME_API_ENDPOINT }}
          PARADIME_API_KEY: ${{ secrets.PARADIME_API_KEY }}
          PARADIME_API_SECRET: ${{ secrets.PARADIME_API_SECRET }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: python scripts/pr_review_e2e.py