kandev/.agents/skills/pr-fixup/SKILL.md

name, description

name	description
pr-fixup	Wait for CI checks and automated reviews (CodeRabbit, Greptile) on a PR, fix failures and address comments, then push.

PR Fixup

Wait for CI and code review to complete on a pull request, fix any failures or valid comments, then push.

Context

• Current branch: !git branch --show-current
• Current PR: !gh pr view --json number,url,title

Steps

Create a todo/task for each step below and mark them as completed as you go.

1. Gather PR state

Get the PR number from context or the user. Fetch the current state:

gh pr checks <number>
gh pr view <number> --json comments
gh api repos/:owner/:repo/pulls/<number>/comments

2. Wait for CI checks

If any checks are still running (pending / queued / in_progress), poll until they all resolve:

gh pr checks <number>

• Poll every 30 seconds
• Cap at 10 minutes (20 polls). If still running after 10 min, report which checks are stuck and proceed.
• Once done, note which checks passed and which failed.

3. Wait for automated reviews

Check if CodeRabbit and Greptile have posted or are generating reviews.

Bot usernames: coderabbitai, greptile-apps[bot]

CodeRabbit — stop waiting if:

• A comment contains <!-- rate limited by coderabbit.ai --> — rate-limited, won't review.
• A comment contains <!-- walkthrough_start --> — review complete.

Greptile — stop waiting if:

• A review from greptile-apps[bot] exists (posts via the GitHub review API, not issue comments).

Keep polling if:

• A bot hasn't commented yet AND gh pr checks shows its check is still pending.

Poll every 30 seconds, cap at 10 minutes. Fetch both issue comments and reviews each poll:

# CodeRabbit posts issue comments
gh pr view <number> --json comments --jq '.comments[] | select(.author.login == "coderabbitai") | {author: .author.login, body: .body}'
# Greptile posts reviews (with inline review comments)
gh api repos/:owner/:repo/pulls/<number>/reviews --jq '.[] | select(.user.login == "greptile-apps[bot]") | {user: .user.login, state: .state}'

4. Fix failing CI checks

If any CI checks failed:

1. Identify the failed runs from the gh pr checks output (the URL column contains the run URL)
2. Fetch the failed logs:

   gh run view <run-id> --log-failed
   

3. Read the relevant source files at the failing lines
4. Fix the issues (lint errors, test failures, type errors, etc.)

5. Triage review comments

Fetch all review comments — human reviewers, CodeRabbit, and Greptile:

gh pr view <number> --json reviews,comments
gh api repos/:owner/:repo/pulls/<number>/comments

Verify before implementing. Do not blindly accept review feedback — evaluate each comment technically:

For each comment:

1. Restate the requirement in your own words — if you can't, ask for clarification
2. Check against the codebase: is the suggestion correct for THIS code?
3. Check if it breaks existing functionality or conflicts with architectural decisions
4. YAGNI check: if the suggestion adds unused features ("implement properly"), grep for actual usage first

Then classify:

• Valid and actionable — real issue (bug, missing edge case, naming, architecture, code quality). Fix it.
• Already addressed — the code already handles what the comment suggests. Skip.
• Nitpick or preference — subjective style not covered by linters. Skip unless the reviewer insists.
• Wrong or outdated — misunderstands the code, refers to old state, or is technically incorrect. Push back with reasoning.

Push back when:

• The suggestion breaks existing functionality
• The reviewer lacks full context (explain what they're missing)
• It violates YAGNI (the feature is unused)
• It's technically incorrect for this stack
• It conflicts with architectural decisions

6. Address each comment

Every comment must get a response — either a fix or a reply explaining why it was skipped.

Important: issue comments vs review comments use different APIs:

• Review comments (inline, from gh api repos/:owner/:repo/pulls/<number>/comments) — reply via /pulls/<number>/comments/<comment_id>/replies, react via /pulls/comments/<comment_id>/reactions
• Issue comments (conversation timeline, from gh pr view --json comments — e.g., CodeRabbit walkthrough) — reply by posting a new comment via gh pr comment <number> --body "...", react via /issues/comments/<comment_id>/reactions

For valid comments:

1. Read the file at the referenced line
2. Implement the fix
3. React with thumbs up:

   # For review comments:
   gh api repos/:owner/:repo/pulls/comments/<comment_id>/reactions -f content="+1"
   # For issue comments:
   gh api repos/:owner/:repo/issues/comments/<comment_id>/reactions -f content="+1"
   

4. Resolve the review thread (see below for thread ID retrieval)

For skipped comments (already addressed, nitpick, wrong, or outdated):

1. Reply to the comment explaining why it was skipped:

   # For review comments:
   gh api repos/:owner/:repo/pulls/<number>/comments/<comment_id>/replies -f body="<explanation>"
   # For issue comments:
   gh pr comment <number> --body "<explanation>"
   

   Examples:
   • "This is already handled by X on line Y."
   • "This is a style preference not enforced by our linters — keeping as-is."
   • "This refers to code that was changed in a later commit."
2. Resolve the review thread

Resolving threads: First fetch thread node IDs to map comment IDs to threads:

gh api graphql -f query='
query($owner: String!, $repo: String!, $number: Int!) {
  repository(owner: $owner, name: $repo) {
    pullRequest(number: $number) {
      reviewThreads(first: 100) {
        nodes {
          id
          comments(first: 1) {
            nodes { databaseId }
          }
        }
      }
    }
  }
}' -f owner=":owner" -f repo=":repo" -F number=<number>

Then resolve using the thread id:

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

7. Verify, commit, and push

1. Delegate to the verify sub-agent to run the full verification pipeline (format, typecheck, test, lint). It will fix any issues it finds. Wait for it to complete.

2. Stage and commit the fixes directly. Use a descriptive Conventional Commits message, e.g.:

   fix: address PR review feedback
   fix: resolve CI lint failures
   fix: address review feedback and fix CI failures
   

3. Push:

   git push
   

8. Summary

Report what was done:

• CI checks: which failed and how they were fixed
• Comments addressed (with thumbs up)
• Comments skipped and why
• Link to the pushed commit