Fix Pr

Step 2: Detect Issues

Run in parallel:

# Derive repo owner/name dynamically (works across forks)
OWNER=$(gh repo view --json owner -q '.owner.login')
NAME=$(gh repo view --json name -q '.name')

# Check for unresolved review comments (including bot reviewers like CodeRabbit)
# Paginate with endCursor to handle PRs with >100 threads
gh api graphql \
  -F owner="$OWNER" \
  -F name="$NAME" \
  -F number=<NUMBER> \
  -f query='
query($owner: String!, $name: String!, $number: Int!, $cursor: String) {
  repository(owner: $owner, name: $name) {
    pullRequest(number: $number) {
      reviewThreads(first: 100, after: $cursor) {
        nodes {
          id isResolved
          comments(last: 1) {
            nodes { id databaseId body author { login } path line }
          }
        }
        pageInfo { hasNextPage endCursor }
      }
    }
  }
}'
# If pageInfo.hasNextPage is true, re-run with -F cursor="<endCursor>" until all
# threads are fetched. Accumulate nodes across pages before computing counts.

# Check CI status — includes all checks (CI, review bots, etc.)
gh pr checks <NUMBER>

Present a summary: "Iteration N — Found X unresolved comments and Y failed/pending checks."

Exit condition: All CI/review-bot checks are green AND no unresolved comments → report clean status and exit the loop. Pending checks do NOT count as clean — wait for them to complete.

Step 3A: Fetch Review Comments

Filter to isResolved: false and classify:

Note: Treat bot reviewer comments (e.g., CodeRabbit, Copilot) the same as human comments — classify by content, not author.

Step 3B: Fetch CI Failures

# List failed checks
gh pr checks <NUMBER> --json name,state,link | jq '.[] | select(.state == "FAILURE")'

# For GitHub Actions checks, extract the run ID from the link field:
#   link format: https://github.com/<owner>/<repo>/actions/runs/<RUN_ID>/job/<JOB_ID>
RUN_ID=$(echo "$LINK" | grep -oP 'runs/\K[0-9]+')

# Fetch failed run logs online
gh run view "$RUN_ID" --log-failed

For each failure, extract:

• Check name (e.g., build, lint, test)
• Error summary — the relevant error lines from logs
• Affected file/line if identifiable from the log output

Tips for fetching logs:

• gh run view <RUN_ID> --log-failed gives only failed step logs — start here
• If logs are truncated, use gh run view <RUN_ID> --log and grep for error/FAILED
• For large logs, pipe through tail -100 or grep to extract relevant sections
• External checks (non-GitHub Actions): no run ID exists — open the link URL directly to view logs from the external provider

Step 4: Get User Confirmation

Present ALL issues in a numbered list:

Review Comments:
  1. [A] src/foo.cpp:42 — Missing null check (reviewer: alice)
  2. [B] src/bar.py:15 — Style suggestion (reviewer: coderabbitai)
  3. [C] src/baz.h:8 — "Looks good" (reviewer: bob)

CI Failures:
  4. [CI] build — error: 'Foo' is not a member of 'pypto::ir'
  5. [CI] lint — python/pypto/ir/foo.py:10: F401 unused import
  6. [CI] test — FAILED tests/ut/ir/test_foo.py::test_bar - AssertionError

Ask user which to address/skip/discuss. Recommend addressing A and CI items.

First iteration: Always ask for confirmation. Subsequent iterations: If the user said "address all" previously, apply the same policy to new issues of the same category without re-asking. Only ask again for genuinely new or ambiguous issues.

Step 5: Fix Issues

For review comments

1. Read affected files with Read tool
2. Make changes with Edit tool

For CI failures

1. Analyze the error from fetched logs — do NOT reproduce locally unless online logs are insufficient
2. Read affected files
3. Fix the root cause
4. If a fix might introduce new issues, run relevant tests locally to verify

Commit

Commit using /git-commit skill, skip testing and review for minor fixes.

Commit message format:

fix(pr): resolve issues for #<number>

- Fixed null check (review comment #1)
- Fixed missing include (CI build error)
- Removed unused import (CI lint error)

Push

git push

Step 6: Resolve Comment Threads

Reply using gh api repos/:owner/:repo/pulls/<number>/comments/<comment_id>/replies -f body="..." then resolve thread with GraphQL resolveReviewThread mutation.

Response templates:

• Fixed: "Fixed in <commit> - description"
• Skip: "Current code follows .claude/rules/<file>"
• Acknowledged: "Acknowledged, thank you!"

Step 7: Wait and Re-check

After pushing fixes, wait for CI and review bots to process the new commit.

# Wait ~10 minutes for CI and review bots to run
sleep 600

# Then loop back to Step 2

While waiting: Inform the user that you're waiting for CI/reviews to complete. Use gh pr checks <NUMBER> to poll status before the full wait expires — if all checks finish early, proceed immediately.

Loop safeguards:

• Max iterations: 5 — after 5 fix-wait cycles, stop and report remaining issues to the user
• Stuck detection — if the same issue reappears after a fix attempt, flag it to the user rather than retrying blindly
• User can exit — the user can interrupt at any time; respect interruptions

Best Practices

Error Handling

Checklist

• PR matched and validated
• Review comments and CI status fetched
• ALL issues presented to user for selection
• Code changes made and committed (use /git-commit)
• Changes pushed to remote
• Review comment threads replied to and resolved
• Waited for CI/reviews and re-checked
• Loop exited: all clean OR max iterations reached