addressing-review-comments

Category: Development & Coding | Uploader: christian-byrne | Downloads: 0 | Version: v1.0（Latest）
Checks out a PR branch via worktree, implements code review feedback as individual commits linking to each comment URL, runs quality gates, and hands off to resolving-review-comments. Use when asked to address review comments, fix review feedback, or implement PR suggestions.
Changelog: Source: GitHub https://github.com/christian-byrne/ticket-to-pr-pipeline
Directory Structure

Current level: skills/addressing-review-comments/
📄 SKILL.md 11.9 KB
SKILL.md

---
name: addressing-review-comments
description: 'Checks out a PR branch via worktree, implements code review feedback as individual commits linking to each comment URL, runs quality gates, and hands off to resolving-review-comments. Use when asked to address review comments, fix review feedback, or implement PR suggestions.'
---

# Addressing Review Comments

Checks out a PR branch, implements each code review comment as a separate commit (with a hyperlink to the comment URL in the commit message), runs quality gates, and hands off to resolve threads and reassign the PR.

## When to Use

- User says "address review comments", "fix review feedback", "implement PR suggestions"
- User says "the PR got reviewed, go fix the comments"
- User provides a PR URL or number and asks to handle the review feedback
- After a code review round, to implement fixes and push back

## Prerequisites

- GitHub CLI authenticated: `gh auth status`
- `git-worktree-utils` installed and sourced (see `worktree-utils` skill)
- Write access to the repository

## Configuration

Uses the **production API** by default. No configuration needed for read operations.

**Defaults (no setup required):**

- API URL: `https://api-gateway-856475788601.us-central1.run.app`
- Read-only endpoints at `/public/*` require no authentication

**For write operations** (state transitions), set:

```bash
export PIPELINE_API_KEY="..."  # Get from GCP Secret Manager or ask admin
```

## Workflow

### 1. Identify the PR

```bash
# From a PR URL or number
PR_NUMBER=<N>
REPO=$(gh pr view "$PR_NUMBER" --json repository --jq '.repository.nameWithOwner // empty' 2>/dev/null \
  || gh repo view --json nameWithOwner -q .nameWithOwner)
OWNER=$(echo "$REPO" | cut -d'/' -f1)
REPO_NAME=$(echo "$REPO" | cut -d'/' -f2)
BRANCH=$(gh pr view "$PR_NUMBER" --repo "$REPO" --json headRefName -q .headRefName)
```

### 2. Checkout the Branch via Worktree

Try methods in order:

**Method 1: wt-continue (preferred — branch was created on another system)**

```bash
wt-continue "$REPO_NAME" "$BRANCH"
cd "$WORKTREE_BASE/$REPO_NAME/$BRANCH"
```

**Method 2: Navigate to existing worktree**

Check common locations:

```bash
# Standard worktree location
WORKTREE_PATH="$WORKTREE_BASE/$REPO_NAME/$BRANCH"

# Cross-repo task location
CROSS_REPO_PATH="$CROSS_REPO_BASE/*/$REPO_NAME"

if [ -d "$WORKTREE_PATH" ]; then
  cd "$WORKTREE_PATH"
elif ls -d $CROSS_REPO_PATH 2>/dev/null | head -1; then
  cd "$(ls -d $CROSS_REPO_PATH 2>/dev/null | head -1)"
else
  # Fall back to wt-continue
  wt-continue "$REPO_NAME" "$BRANCH"
  cd "$WORKTREE_BASE/$REPO_NAME/$BRANCH"
fi
```

### 3. Safety Checks (MANDATORY — Do NOT Skip)

Before pulling, verify there is no uncommitted local work that could be lost:

```bash
# Check for uncommitted changes
if [ -n "$(git status --porcelain)" ]; then
  echo "❌ ABORT: Uncommitted changes detected in worktree."
  echo "Files with local changes:"
  git status --short
  echo ""
  echo "Resolve these manually before proceeding:"
  echo "  - Stash: git stash"
  echo "  - Commit: git add . && git commit"
  echo "  - Discard: git checkout -- ."
  exit 1
fi

# Check for unpushed commits
UNPUSHED=$(git log origin/"$BRANCH".."$BRANCH" --oneline 2>/dev/null)
if [ -n "$UNPUSHED" ]; then
  echo "⚠️  ABORT: Unpushed local commits detected:"
  echo "$UNPUSHED"
  echo ""
  echo "Push these first: git push origin $BRANCH"
  exit 1
fi
```

### 4. Sync with Remote

```bash
git fetch origin
git reset --hard "origin/$BRANCH"
```

Confirm: `git log --oneline -3` matches what's on GitHub.

### 5. Fetch All Unresolved Review Threads

Use the same GraphQL query as `resolving-review-comments`:

```bash
THREADS_JSON=$(gh api graphql -f query='
query($owner: String!, $repo: String!, $pr: Int!) {
  repository(owner: $owner, name: $repo) {
    pullRequest(number: $pr) {
      reviewThreads(first: 100) {
        nodes {
          id
          isResolved
          isOutdated
          path
          line
          startLine
          comments(first: 20) {
            nodes {
              id
              body
              url
              author {
                login
              }
              createdAt
            }
          }
        }
      }
    }
  }
}' -f owner="$OWNER" -f repo="$REPO_NAME" -F pr="$PR_NUMBER")
```

Filter to only unresolved threads from the JSON output.

### 6. Evaluate and Categorize Each Thread

For each unresolved thread, read the comment and categorize:

| Category                       | Action                                                 |
| ------------------------------ | ------------------------------------------------------ |
| **Actionable code change**     | Implement the fix (step 7)                             |
| **Valid suggestion with code** | Apply the suggestion                                   |
| **Nit / style preference**     | Implement if trivial, otherwise note as skipped        |
| **Question / clarification**   | Skip implementation — note for reply in resolving step |
| **Disagreement / pushback**    | Skip implementation — note for reply in resolving step |
| **Already addressed**          | Skip — will be resolved in handoff step                |
| **Non-blocking / followup**    | Skip — will be tagged for followup in resolving step   |

Present the categorization to the user:

```
## Review Comments Analysis

### Will Implement
1. src/api/client.ts:92 — Add error handling for null response
   Comment: https://github.com/owner/repo/pull/N/files#r123456
2. src/utils/parser.ts:45 — Use const instead of let
   Comment: https://github.com/owner/repo/pull/N/files#r123457

### Will Skip (handle in resolve step)
3. src/stores/auth.ts:20 — Question about design choice (needs reply, not code)
4. src/components/Foo.vue:15 — Nit: author preference, non-blocking

Proceed with implementation? (Y/N)
```

Wait for user approval before implementing.

### 7. Implement Each Comment

For each actionable comment, implement the fix and commit separately.

**Commit message format** — MUST include a hyperlink to the review comment:

```
fix: add null check for API response

Addresses review feedback:
https://github.com/owner/repo/pull/N#discussion_r123456789
```

The URL MUST be the direct link to the review comment on GitHub (the `url` field from the GraphQL response).

**Rules:**

1. One commit per review comment — do not batch
2. Each commit message MUST contain the review comment URL
3. Read the file and surrounding context before making changes
4. Make the minimal change that addresses the feedback
5. Do not refactor or "improve" code beyond what was requested

### 8. Parallel Implementation (When Applicable)

If actionable comments touch **different files or independent code sections**, dispatch parallel subagents using the Task tool:

```
Dispatch criteria for parallel execution:
- Comments modify DIFFERENT files → parallelize
- Comments modify the SAME file but DIFFERENT functions/sections (>50 lines apart) → parallelize
- Comments modify the SAME lines or overlapping sections → sequential only
- Comments have logical dependencies (one fix depends on another) → sequential only
```

**Subagent prompt template:**

```
Implement this code review feedback in <REPO_PATH>:

File: <path>
Line: <line>
Review comment: "<comment body>"
Comment URL: <url>

1. Read the file and understand the surrounding context
2. Make the minimal change that addresses the feedback
3. Commit with message:
   fix: <short description of change>

   Addresses review feedback:
   <comment_url>
4. Report: file changed, lines modified, what was done
```

After parallel subagents complete, verify no conflicts:

```bash
git log --oneline -N  # Should show N clean commits
git diff HEAD~N..HEAD --stat  # Review all changes
```

### 9. Quality Gates

Load and run the `quality-gates-runner` skill:

```json
{ "name": "quality-gates-runner" }
```

Follow its workflow to run lint, format, typecheck, and tests. Fix any issues before proceeding.

### 10. Self-Review Pass

Before pushing, do a final review of all changes:

```bash
# Review the full diff of all commits made
BASE_COMMIT=$(git merge-base origin/main HEAD)
git diff "$BASE_COMMIT"..HEAD

# Or just the new commits
git log --oneline origin/"$BRANCH"..HEAD
git diff origin/"$BRANCH"..HEAD
```

Verify:

- [ ] Each commit addresses exactly one review comment
- [ ] Each commit message contains the review comment URL
- [ ] No unintended changes or debug code
- [ ] Code compiles and tests pass
- [ ] Changes are minimal and focused

### 11. Push

```bash
git push origin "$BRANCH"
```

Confirm push succeeded:

```bash
git log --oneline origin/"$BRANCH" -3
```

### 12. Report and Handoff to Resolving

Present a summary of what was done:

```markdown
## Review Comments Addressed

### Implemented (N commits)

✅ src/api/client.ts:92 — Added null check (abc1234)
✅ src/utils/parser.ts:45 — Changed let to const (def5678)

### Skipped (for resolve step)

⏭️ src/stores/auth.ts:20 — Question, needs reply
⏭️ src/components/Foo.vue:15 — Nit, non-blocking

### Quality Gates: ✅ All Passed

Pushed to origin/$BRANCH
```

**Immediately handoff** to resolve threads and reassign. Use the `handoff` tool:

```
goal: "Resolve review threads and reassign PR. Load skill: resolving-review-comments. PR #<N> in <OWNER/REPO>. Branch: <BRANCH>. Commits addressing feedback have been pushed. Resolve threads where code fixes were implemented, reply to questions/pushback threads appropriately, tag @coderabbitai for followup items, and reassign PR to the reviewer. Skipped threads that need replies: <list skipped thread IDs and reasons>"
follow: true
```

**Do NOT attempt to resolve threads in this thread.** Hand off to keep context clean.

## API Integration

If a pipeline ticket exists, update state after pushing fixes:

```bash
API_URL="${PIPELINE_API_URL:-https://api-gateway-856475788601.us-central1.run.app}"
API_KEY="${PIPELINE_API_KEY}"

# Only if ticket ID is known
if [ -n "$TICKET_ID" ]; then
  curl -s -X POST "${API_URL}/v1/tickets/${TICKET_ID}/transition" \
    -H "Authorization: Bearer ${API_KEY}" \
    -H "Content-Type: application/json" \
    -H "X-Agent-ID: ${AGENT_ID:-amp-agent}" \
    -d '{
      "to_state": "REVIEW_FIXES_PUSHED",
      "reason": "Addressed N review comments, pushed fixes"
    }'
fi
```

## Error Handling

### Worktree Not Found

```
❌ Could not find or create worktree for branch: <branch>

Tried:
  - wt-continue <repo> <branch>
  - $WORKTREE_BASE/<repo>/<branch>
  - $CROSS_REPO_BASE/*/<repo>

Ensure git-worktree-utils is installed and the repo is cloned under $WORKTREE_BASE.
```

### Uncommitted Changes

```
❌ ABORT: Uncommitted changes in worktree. Will not overwrite local work.

Resolve manually:
  - git stash
  - git commit
  - git checkout -- .
```

### Push Rejected

```
❌ Push rejected. Remote has changes not present locally.

Run:
  git fetch origin
  git rebase origin/<branch>
  # Then re-push
```

### No Actionable Comments

```
ℹ️ No actionable code review comments found.

All threads are either:
  - Already resolved
  - Questions/clarifications (no code change needed)
  - Non-blocking nits the author chose to skip

Nothing to implement. Consider loading resolving-review-comments to reply and resolve.
```

## Rules

1. **One commit per comment** — never batch multiple review fixes into one commit
2. **Always include the comment URL** in the commit message — this is non-negotiable
3. **Never overwrite uncommitted work** — always check for dirty state before pulling
4. **Minimal changes only** — address exactly what was requested, nothing more
5. **Parallelize when safe** — use subagents for independent file changes
6. **Run quality gates** — never push without lint/format/typecheck/test passing
7. **Always handoff to resolving** — do not resolve threads in this skill
8. **Get user approval** before implementing — show the categorization first
9. **Never force-push** — use regular push only
10. **Self-review before pushing** — verify all commits look correct
Comments 0
Latest | Hot
Please login before commenting.
No comments yet. Be the first one!
addressing-review-comments

Directory Structure

SKILL.md

Report

Notice
