Resolve PR Review

Resolve PR Code Review

When the user provides a GitHub PR URL (or asks to resolve review on a PR), run this workflow end-to-end. Do not edit plan files if the user attached one — execute the workflow directly.

Parse the PR

Extract owner, repo, and number from URLs like:

• https://github.com/{owner}/{repo}/pull/{number}
• https://github.com/{owner}/{repo}/pull/{number}#discussion_r...
• https://github.com/{owner}/{repo}/pull/{number}#pullrequestreview-...

Use gh for all GitHub operations. Require gh auth; if unauthenticated, stop and tell the user to run gh auth login.

Workflow checklist

Copy and track progress:

- [ ] 1. Inspect PR state (branch, head commit, CI)
- [ ] 2. Fetch all inline review comments + unresolved threads
- [ ] 3. Build a per-comment checklist (file, suggestion, status)
- [ ] 4. Verify each item against current code; fix gaps with minimal diff
- [ ] 5. Run smoke checks (build / tests relevant to changed files)
- [ ] 6. Commit and push code fixes (if any)
- [ ] 7. Resolve all addressed review threads on GitHub
- [ ] 8. Post a PR conversation reply @-mentioning the reviewer bot (e.g. `@gemini-code-assist`)
- [ ] 9. Request gemini-code-assist re-review via `/gemini review`

Step 1 — PR state

Run in parallel:

gh pr view {number} --repo {owner}/{repo} --json title,headRefName,baseRefName,headRefOid,state,commits
git status -sb
git branch --show-current

If not on the PR head branch, checkout it:

gh pr checkout {number} --repo {owner}/{repo}

Step 2 — Fetch review feedback

Inline comments (suggestions, file/line context):

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

Unresolved threads (preferred — includes resolved state):

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

Filter to unresolved threads first. Skip bot noise (CI reports, dependency bots) unless the user asked to handle them. Prioritize human reviewers and code-assist bots (e.g. gemini-code-assist, copilot-pull-request-reviewer).

When reading API output, extract only: thread id, file path, line, comment body, author — do not dump full JSON into the reply.

Step 3 — Build checklist

For each unresolved thread, record:

Group related comments on the same file. If a later commit already addressed a comment but the thread is still open, mark fixed and plan to resolve without new code.

Step 4 — Verify and fix

For each pending item:

1. Read the cited file at the relevant lines.
2. Compare current code to the reviewer's suggestion.
3. Apply the smallest correct diff that satisfies the feedback.
4. Match project conventions (existing components, error handling, naming).

Do not refactor unrelated code. Do not resolve a thread unless the fix is actually in the PR head commit (after push if you made changes).

If a comment is invalid or out of scope, skip the code change and explain why in the PR reply — do not resolve unless the user wants threads closed anyway.

Step 5 — Smoke checks

Run checks proportional to touched files:

# Rust changes
cd src-tauri && cargo check

# Frontend changes
npm run build
# or: npx tsc --noEmit

Fix any failures introduced by your changes before committing.

Step 6 — Commit and push (only if code changed)

Follow the repo's commit message style. One focused commit is enough:

git add <relevant files>
git commit -m "$(cat <<'EOF'
fix: address PR review feedback on <short topic>

EOF
)"
git push

Skip commit/push if no code changes were needed (threads-only resolution).

Step 7 — Resolve threads

For each thread that is fixed in the PR head, run:

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

Resolve all addressed threads, including ones fixed in an earlier commit on the branch.

Verify all threads are resolved:

gh api graphql -f query='...'  # same query as Step 2; confirm isResolved: true

Step 8 — PR reply

Post a concise summary on the PR conversation. Always @-mention the reviewer bot that left the inline comments (e.g. @gemini-code-assist, @copilot-pull-request-reviewer). Detect the reviewer login from Step 2 thread data (author.login); if multiple bots reviewed, mention each one once at the top.

Standard format (follow PR #15 as the template):

gh pr comment {number} --repo {owner}/{repo} --body "$(cat <<'EOF'
Thanks @gemini-code-assist for the review! All {N} inline comments have been addressed in commit `<sha>` (`<commit subject>`):

1. **`file.ts`**: brief what changed
2. **`other.rs`**: brief what changed

All review threads are now marked as resolved.

/gemini review
EOF
)"

Rules for the reply body:

• Opening line: Thanks @<reviewer-bot> for the review! — required when the review came from a bot; use the exact GitHub login (e.g. gemini-code-assist, not the display name).
• Commit reference: include short SHA and commit subject on the same line as the item count.
• Item list: numbered, one entry per resolved thread; wrap file paths in backticks.
• Closing line: All review threads are now marked as resolved.
• Re-review trigger: append /gemini review on its own line at the end of the same comment (Step 9). This is the official slash command to request a fresh code review from gemini-code-assist after fixes are pushed.
• Use the user's language (Chinese or English) for the change descriptions, but keep the @mention, /gemini review, and structural phrases consistent with the template above.