Rabbit Round

Process automated PR review comments systematically. Run this for CodeRabbit, Google Code Assist (Gemini), GitHub Copilot, Devin, and similar review bots.

This skill is single-pass. It does one round, reports the current state, and stops. Do not schedule future runs from inside this skill.

Instructions

1. Get context - PR number and current GitHub user:

   # Get PR number for this branch
   gh pr view --json number -q '.number'
   
   # Get current GitHub username (for plain-text CC attribution)
   gh api user --jq '.login'
   

   Every published reply must end with CC on behalf of {username}. Keep the username as plain text: never prefix it with @ or turn it into a link, because that would trigger a GitHub mention notification.

2. Fetch all bot comments - Prefer GraphQL for review threads to only process unresolved ones:

   # Fetch all review threads and filter for unresolved ones only
   gh api graphql --paginate -f query='
   query($endCursor: String) {
     repository(owner: "{owner}", name: "{repo}") {
       pullRequest(number: {pr_number}) {
         reviewThreads(first: 50, after: $endCursor) {
           nodes {
             id
             isResolved
             path
             comments(first: 10) {
               nodes {
                 databaseId
                 body
                 author { login }
               }
             }
           }
           pageInfo {
             hasNextPage
             endCursor
           }
         }
       }
     }
   }' | jq '.data.repository.pullRequest.reviewThreads.nodes | map(select(.isResolved == false))'
   
   # Issue comments (top-level PR comments, used by some bots)
   gh api repos/{owner}/{repo}/issues/{pr_number}/comments --paginate
   

   Filter for comments from coderabbitai[bot], gemini-code-assist[bot], github-copilot[bot], devin-ai-integration[bot], and similar bots.

   Human comments: Never resolve or minimize human comments. You may reply to push back if incorrect, or ask for clarification - but leave the thread open for the human to resolve.

3. For each bot comment (review or issue), analyze the suggestion and decide:

   • Accept: If the suggestion improves code quality, correctness, or follows our patterns
   • Push back: If the suggestion doesn't apply, is incorrect, or conflicts with our conventions (documented in CLAUDE.md files)

4. Reply to each comment:

   For review comments, use in_reply_to to thread the reply:

   gh api repos/{owner}/{repo}/pulls/{pr_number}/comments \
     -X POST \
     -f body="[response]
   
   CC on behalf of {username}" \
     -f commit_id="{commit_sha}" \
     -f path="{file_path}" \
     -F in_reply_to={comment_id}
   

   For issue comments (top-level PR comments), reply on the issue thread:

   gh api repos/{owner}/{repo}/issues/{pr_number}/comments \
     -X POST \
     -f body="[response]
   
   CC on behalf of {username}"
   

5. Resolve addressed bot review threads using GraphQL (never resolve human comments):

   # First, get thread IDs for the PR
   gh api graphql -f query='
   query {
     repository(owner: "{owner}", name: "{repo}") {
       pullRequest(number: {pr_number}) {
         reviewThreads(first: 50) {
           nodes {
             id
             isResolved
             comments(first: 1) {
               nodes { databaseId }
             }
           }
         }
       }
     }
   }'
   
   # Then resolve each thread by its GraphQL ID
   gh api graphql -f query='
   mutation {
     resolveReviewThread(input: {threadId: "{thread_id}"}) {
       thread { isResolved }
     }
   }'
   

6. Minimize (hide) other addressed bot issue comments using GraphQL. Some bots post as issue comments instead of review comments. These cannot be "resolved" like review threads; instead, minimize them:

   # Use the node_id from the issue comment JSON response
   gh api graphql -f query='
   mutation {
     minimizeComment(input: {
       subjectId: "{comment_node_id}",
       classifier: RESOLVED
     }) {
       minimizedComment { isMinimized }
     }
   }'
   

   Only minimize bot comments you have already addressed (accepted or pushed back on). Never minimize human comments.

7. Check nitpick suggestions (marked with [nitpick] or similar) - these should also be addressed, not ignored.

8. Implement accepted suggestions:

   • Make the code changes for suggestions you agreed with
   • Group related changes logically

9. Check review bot status:

   Before considering this round clean, verify that all review bot checks have completed:

   gh pr checks $(gh pr view --json number -q '.number') \
     --json name,state \
     | jq '[.[] | select(
         (.name | test("coderabbit|copilot|gemini|devin"; "i"))
         and (.state | IN("PENDING","QUEUED","REQUESTED",
                          "WAITING","IN_PROGRESS"))
       )]'
   

   If any review bot checks are still in a non-terminal state, this round is not clean even if there are zero unresolved comments. Report pending_bots and stop.

10. Check and fix failing CI:

    # Find the latest CI run for this PR's branch
    gh run list --branch $(git branch --show-current) --limit 5 \
      --json status,conclusion,name,databaseId
    
    # View failed run logs
    gh run view {run_id} --log-failed
    

    • If CI is failing, read the logs and fix the root cause
    • Common failures: formatting (run bun run format with --write), lint errors, type errors, test failures
    • Fix the issues in code, don't just suppress them

11. Run quality checks:

    Run the quality checks for the project (using ruff format, ruff check, ty for Python, bun run lint, bun run format, bun run typecheck for TypeScript).

12. Commit and push:

    • Create a commit with a message like fix: address review comments
    • Push to the current branch
    • If you pushed new commits in this step, return pending_bots in the final status because CI and review bots need to run on the new commit

13. Report one round status and stop:

    Return exactly one of:

    • clean: no actionable bot comments remain, review bot checks are complete, and CI is green
    • pending_bots: review bots have not finished yet, or new commits were just pushed and checks are re-running
    • needs_changes: actionable bot comments remain
    • failing_ci: CI is failing and still needs fixes

    If the round is clean and the PR is currently a draft, mark it as ready for review:

    gh pr ready
    

    If the round is not clean, summarize what remains and stop. A caller may invoke /rabbit-round again later.

Decision Guidelines

Accept suggestions when they:

• Fix actual bugs or potential issues
• Improve type safety
• Follow established patterns in CLAUDE.md
• Enhance readability without over-engineering
• Address security concerns

Push back when suggestions:

• Conflict with documented conventions
• Would over-engineer a simple solution
• Are based on incorrect assumptions about the codebase
• Would break existing patterns for marginal benefit
• Are purely stylistic and conflict with our style

Response Templates

Reply format: Put the response first, then sign with CC on behalf of {username}. Substitute the current GitHub username without an @ prefix or profile link.

Accepting:

Accepted and implemented. [Brief description of change].

CC on behalf of username

Accepting with modification:

Agreed with the principle. Implementing with a slight modification: [explain].

CC on behalf of username

Pushing back:

Pushing back on this. [Reason]. Our convention is [explain pattern/reference
CLAUDE.md].

CC on behalf of username

Already addressed:

Already addressed in commit [hash]. [Brief description].

CC on behalf of username