Review PR Comments

Review unresolved comments on the GitHub pull request associated with the current branch. Validate each comment, then fix legitimate issues.

Step 1 — Identify the Pull Request

1. If $ARGUMENTS contains a PR number, use it.
2. Otherwise, detect the current git branch and find its open PR:

   gh pr view --json number,url,headRefName,baseRefName
   

3. If no PR is found, stop and tell the user.

Step 2 — Fetch All Unresolved Review Comments

Fetch PR review comments (not issue-level comments) using the GitHub CLI:

gh api repos/{owner}/{repo}/pulls/{number}/comments --paginate

Filter to comments where the thread is not resolved. Group comments by thread (same in_reply_to_id or same path + line/original_line). For each thread, treat the first comment as the review request and subsequent comments as discussion.

Also fetch general PR comments (issue-level):

gh api repos/{owner}/{repo}/issues/{number}/comments --paginate

If there are zero unresolved comments, report that and stop.

Step 3 — Validate and Fix Comments in Parallel (Sub-agents)

For each unresolved comment or comment thread, spawn a sub-agent in parallel. Use model: "sonnet" for cost efficiency. Each agent validates the comment and, if legitimate, fixes it immediately in place.

Conflict avoidance: If multiple comments target the same file, run those agents sequentially (not in parallel) to avoid edit conflicts. Comments on different files run in parallel.

Sub-agent Prompt Template

You are a code review comment validator and fixer. Your job is to determine whether a PR review comment identifies a real issue, and if so, fix it immediately.

## Comment Details
- **Author**: {comment_author}
- **File**: {file_path}
- **Line(s)**: {line_range}
- **Comment**: {comment_body}
- **Thread context** (if any): {thread_replies}
- **Comment ID**: {comment_id}

## Phase 1 — Validate

1. Read the file referenced in the comment. Focus on the specific lines mentioned.
2. Read surrounding context (50 lines above and below) to understand the code fully.
3. Analyze whether the comment identifies a legitimate issue:
   - Is the described problem actually present in the code?
   - Is the suggestion an improvement or just a style preference?
   - Does the comment apply to the current state of the code (it may already be fixed)?
   - Is this a nitpick / optional suggestion vs. a real bug, logic error, or missing handling?

4. Decide: FIX or IGNORE.
   - If IGNORE, skip to the report below.
   - If FIX, proceed to Phase 2.

## Phase 2 — Fix (only if verdict is FIX)

1. Apply the minimal fix that addresses the comment. Do not refactor unrelated code.
2. Ensure the fix:
   - Does not break surrounding logic
   - Follows the existing code style and conventions
   - Preserves all existing functionality
3. If the fix requires changes in multiple locations within the same file, make all changes.
4. If you are unsure whether a fix is safe, do NOT apply it — set verdict to NEEDS_MANUAL_REVIEW instead.

HARD CONSTRAINTS:
- Only modify the file(s) specified. Do not touch other files.
- Do not add comments explaining the fix in the code.
- Do not refactor or "improve" code beyond what the comment asks for.
- Keep changes minimal and surgical.

## Report

Return your result in this exact format:

VERDICT: FIX | IGNORE | NEEDS_MANUAL_REVIEW
CONFIDENCE: HIGH | MEDIUM | LOW
REASON: <1-2 sentence explanation>
SUMMARY: <1 sentence describing what was changed, only if VERDICT is FIX>
FILE: {file_path}
LINES: {line_range}
COMMENT_ID: {comment_id}
FIXED: YES | NO

Step 4 — Resolve Fixed Comments on GitHub

After a fix sub-agent successfully fixes an issue, resolve the corresponding review thread on GitHub using the GraphQL API.

1. First, find the thread ID for the comment. Use the node_id from the comment (fetched in Step 2) to query the thread:

   gh api graphql -f query='
     query {
       node(id: "{comment_node_id}") {
         ... on PullRequestReviewComment {
           pullRequestReview {
             id
           }
           id
           isMinimized
         }
       }
     }
   '
   

2. Resolve the review thread using the resolveReviewThread mutation. The thread ID can be obtained from the pull request's review threads:

   gh api graphql -f query='
     query {
       repository(owner: "{owner}", name: "{repo}") {
         pullRequest(number: {number}) {
           reviewThreads(first: 100) {
             nodes {
               id
               isResolved
               comments(first: 1) {
                 nodes {
                   id
                   body
                   path
                   line
                 }
               }
             }
           }
         }
       }
     }
   '
   

   Match the thread by comparing path and line (or body) to the fixed comment, then resolve it:

   gh api graphql -f query='
     mutation {
       resolveReviewThread(input: {threadId: "{thread_id}"}) {
         thread {
           id
           isResolved
         }
       }
     }
   '
   

3. For every successfully fixed comment, reply to the thread before resolving it:

   gh api repos/{owner}/{repo}/pulls/{number}/comments/{comment_id}/replies \
     -f body="## Agentic reply (github-pr-review-fix)
   

Fixed. {summary}

If you disagree with the fix, please reopen this thread."

Then resolve the thread. If the resolve call fails, note it in the report but do not block on it.

4. For **IGNORE** verdicts, reply to the comment thread with an explanation of why it was ignored, then resolve the thread:
```bash
gh api repos/{owner}/{repo}/pulls/{number}/comments/{comment_id}/replies \
  -f body="## Agentic reply (github-pr-review-fix)

This comment was reviewed and determined to not require a code change.

**Reason**: {reason}

_If you disagree, please reopen this thread._"

Then resolve the thread using the same resolveReviewThread mutation as above.

5. For NEEDS_MANUAL_REVIEW verdicts, reply to the thread but do not resolve it:

   gh api repos/{owner}/{repo}/pulls/{number}/comments/{comment_id}/replies \
     -f body="## Agentic reply (github-pr-review-fix)
   

This comment requires manual review — the agent could not safely apply an automated fix.

Reason: {reason}

Leaving this thread unresolved for human attention."

## Step 5 — Report Results

After all agents complete, provide a summary table:

#	File	Comment	Verdict	Reason	Resolved
1	path/to/file.cs:42	"Missing null check"	FIX	Added null guard	Yes
2	path/to/other.cs:10	"Consider renaming"	IGNORE	Style preference, no bug	Yes (replied)
3	path/to/util.cs:77	"Race condition"	NEEDS_MANUAL_REVIEW	Unsafe to auto-fix, needs human judgment	—

For **IGNORE** verdicts, the reason is posted as a reply in the thread and the thread is resolved. The user can reopen if they disagree.

For **NEEDS_MANUAL_REVIEW** verdicts, explain why the agent couldn't safely apply a fix. These threads are left **unresolved** for human attention.

End with a count: `X comments fixed and resolved, Y ignored and resolved, Z need manual review.`