End-to-end PR reviewer

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>=6.0.0"

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

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

from paradime import Paradime
from paradime.apis.dinoai_agents.exception import DinoaiAgentRunFailedException
from paradime.apis.dinoai_agents.types import DinoaiAgentRunStatus

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

# 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"]
base_ref = pr["base"]["ref"]
head_ref = pr["head"]["ref"]

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

# 3. Extract the 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}
Base branch: {base_ref}
You are checked out on the PR branch. Read the diff with
run_terminal_command: git fetch origin {base_ref} and
git diff origin/{base_ref}...HEAD.

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 under these exact sections:
SCOPE / CODE / TESTS / DOCS / IMPACT / VERDICT

The VERDICT line must be one of:
  VERDICT: APPROVE
  VERDICT: REQUEST_CHANGES
  VERDICT: REJECT
"""

# 5. Trigger the agent and capture the session ID before blocking
print(f"Starting DinoAI review for PR #{pr_number}: {pr_title}")

trigger = paradime.dinoai_agents.trigger_run(
    agent="pr-reviewer-e2e",
    message=message,
    base_branch=head_ref,  # check out the PR branch, not the default branch
)
session_id = trigger.agent_session_id
print(f"Review session started: {session_id}")

# 6. Block until the agent finishes by polling get_run (up to 30 minutes)
timeout = 1800
poll_interval = 10
start = time.time()

while True:
    run = paradime.dinoai_agents.get_run(agent_session_id=session_id)

    if run.status == DinoaiAgentRunStatus.COMPLETED:
        print(f"Review session completed: {session_id}")
        break

    if run.status == DinoaiAgentRunStatus.FAILED:
        last = run.messages[-1].content if run.messages else "no messages"
        raise DinoaiAgentRunFailedException(f"Agent run failed. Last message: {last}")

    if time.time() - start > timeout:
        raise TimeoutError(f"Timed out waiting for session {session_id} to complete.")

    print(f"  status: {run.status.value}, waiting {poll_interval}s")
    time.sleep(poll_interval)

# 7. Extract the full review report from the last agent message
final_report = run.messages[-1].content if run.messages else "(no report returned)"

# 8. Parse the VERDICT line
verdict_line = next(
    (line.strip() for line in final_report.splitlines() if line.strip().startswith("VERDICT:")),
    "VERDICT: UNKNOWN",
)
print(verdict_line)

# 9. Post the full review report as a PR comment
gh_token = os.environ.get("GITHUB_TOKEN")
if gh_token:
    repo = os.environ["GITHUB_REPOSITORY"]

    comment_body = (
        f"## 🦕 DinoAI PR Review (session `{session_id}`)\n\n"
        f"{final_report}"
    )

    req = urllib.request.Request(
        f"https://api.github.com/repos/{repo}/issues/{pr_number}/comments",
        data=json.dumps({"body": comment_body}).encode(),
        headers={
            "Authorization": f"Bearer {gh_token}",
            "Accept": "application/vnd.github+json",
            "X-GitHub-Api-Version": "2022-11-28",
        },
        method="POST",
    )
    urllib.request.urlopen(req).read()
    print(f"Review report posted to PR #{pr_number}")

# 10. Fail the workflow if the agent rejected the PR
if "REJECT" in verdict_line:
    raise SystemExit("PR rejected by DinoAI reviewer, see the PR comment for details.")