resolve-pr-comments（解决公关评论）

Resolve PR Comments

A workflow skill that systematically addresses and resolves all review comments on a pull request.

Purpose

Automates the process of reviewing, addressing, and resolving PR review feedback by composing multiple general-purpose skills into a cohesive workflow.

When to Use

Use this workflow when:

• PR has received review comments that need to be addressed
• You want to systematically work through all feedback
• You need to resolve threads after making changes
• PR is blocked on unresolved review comments

Skill Composition

This workflow composes:

1. pull-request-tool: Fetch review comments, reply to threads, resolve threads
2. sequential-execution OR parallel-execution: Process comments in order (sequential) or concurrently (parallel), handle dependencies as needed
3. yolo OR collaborative: Execution mode (autonomous vs interactive)

Parameters

Required

You must specify the pull request to process using either of the following input formats:

• Separate Parameters: - pr-number: Pull request number (e.g., 42) - repository: Repository in the format owner/repo (e.g., octocat/Hello-World)
• Combined URL: - pr-url: Full pull request URL (e.g., https://github.com/owner/repo/pull/42)

If both formats are provided, pr-url takes precedence.

Optional

• interaction-mode: yolo (autonomous) or collaborative (interactive)
• execution-mode: sequential (default) or parallel
• filter: unresolved-only (default), all, by-reviewer
• auto-resolve: Automatically resolve threads after addressing (default: true)
• reviewer: Filter comments by specific reviewer

Workflow Steps

Phase 1: Discovery

1. Fetch PR details (pull-request-tool)

- Get PR metadata - Verify PR is open - Check current status

1. List review comments (pull-request-tool)

- Get all review threads - Filter based on parameters - Group by file and thread

Phase 2: Analysis

1. Analyze comments (sequential-execution OR parallel-execution)

- Categorize by type (question, change request, suggestion) - Identify dependencies between comments - Prioritize or group for resolution

1. Plan approach

- Determine which comments need code changes - Which need clarification/discussion - Which can be resolved with replies

Phase 3: Resolution

1. Address each comment (sequential-execution OR parallel-execution) For each comment (in order or concurrently, based on execution-mode): a. Review the feedback - Read comment and context - Understand the request - Check referenced code b. Determine action - Code change needed? - Just needs reply/clarification? - Already addressed? c. Take action - Make code changes if needed - Reply to thread with explanation - Mark as resolved if appropriate d. Verify resolution - Ensure change addresses feedback - Run tests if code changed - Confirm reviewer intent met

Phase 4: Finalization

1. Push changes (if any code changes made)

- Commit all changes - Push to PR branch - Trigger CI checks

1. Final verification

- Verify all targeted comments addressed - Check for any new comments - Update PR description if needed

Interaction and Execution Modes

YOLO Mode (Autonomous)

When interaction-mode = yolo:
- Automatically determine best response to each comment
- Make code changes without confirmation
- Auto-resolve threads after addressing
- Report only final summary

Collaborative Mode (Interactive)

When interaction-mode = collaborative:
- Show each comment to user
- Propose response/change
- Get approval before proceeding
- Confirm before resolving threads

Sequential vs Parallel Execution

• sequential: Comments are processed one after another, respecting dependencies.
• parallel: Independent comments are processed concurrently for faster resolution.

Example Workflows

Example 1: YOLO + Parallel

Task: Resolve all unresolved PR comments on PR #42 in owner/repo using parallel execution

Execution:
1. Fetch unresolved comments (5 found)
2. Process all comments in parallel:
     - Comment 1: "Add error handling" → Add try/catch, reply, resolve
     - Comment 2: "Fix typo" → Fix, reply, resolve
     - ...
3. Push changes
4. Report: "Resolved 5 comments, updated 3 files"

Example 2: Collaborative + Sequential

Task: Address review comments collaboratively, one at a time

Execution:
1. Fetch 3 unresolved comments
2. Show comment 1, get user input, apply change, resolve
3. Repeat for each comment in order
4. Show summary, push changes

Output Format

YOLO Mode Output

TASK: Resolve PR Comments (#42)
STATUS: Complete

COMMENTS ADDRESSED: 8/8
- 5 required code changes
- 2 clarifications
- 1 acknowledgment

FILES MODIFIED:
- src/auth.ts (2 changes)
- src/api.ts (1 change)
- src/utils.ts (2 changes)

THREADS RESOLVED: 8
CHANGES PUSHED: Yes
CI STATUS: Passing

Collaborative Mode Output

PR Comment Resolution Progress

✅ Comment 1/8 - "Add error handling" - Resolved
✅ Comment 2/8 - "Fix typo" - Resolved
⏳ Comment 3/8 - "Refactor function" - In progress

Current: Reviewing proposed refactoring approach
Next: 5 comments remaining

Error Handling

Common Issues

1. Conflict with recent changes

- Pull latest changes - Re-evaluate comment applicability - Resolve conflicts if needed

1. Unclear feedback

- YOLO: Make best-effort interpretation, document assumption - Collaborative: Ask user for clarification

1. Comment already addressed

- Verify fix is present - Reply explaining it's addressed - Resolve thread

1. Tests fail after changes

- YOLO: Attempt auto-fix, revert if fails - Collaborative: Show failure, ask for guidance

Best Practices

1. Process in logical order: Group related comments, handle dependencies first
2. Verify before resolving: Ensure feedback truly addressed
3. Clear communication: Explain what was done in thread replies
4. Test after changes: Run tests before pushing
5. Commit logically: Group related changes in commits
6. Update PR description: Reflect significant changes made
7. Track progress: Use todo list for multi-comment PRs
8. Request re-review: Notify reviewers of significant changes

Integration Example

# Full PR processing using composed skills

1. resolve-pr-comments (this workflow)
     - Uses: pull-request-tool + sequential-execution OR parallel-execution + yolo
     - Addresses all review feedback

2. Check CI status
     - Uses: pull-request-tool
     - Verify tests pass

3. Merge PR
     - Uses: merge-pr workflow
     - Complete the process

Quick Reference

PURPOSE:
    Systematically address and resolve PR review comments

COMPOSITION:
    pull-request-tool + sequential-execution OR parallel-execution + (yolo OR collaborative)

MODES:
    **YOLO**:          Autonomous resolution
    **Collaborative**: Interactive with user input

EXECUTION:
    **sequential**:    One comment at a time
    **parallel**:      Multiple comments concurrently

PHASES:
    1. **Discovery**:   Fetch PR and comments
    2. **Analysis**:    Categorize and prioritize
    3. **Resolution**:  Address each comment
    4. **Finalization**: Push changes, verify

PARAMETERS:
- **pr-number** (required): Pull request number (e.g., `42`)
- **repository** (required): Repository in the format `owner/repo` (e.g., `octocat/Hello-World`)
- **pr-url**: Full pull request URL (e.g., `https://github.com/owner/repo/pull/42`). Takes precedence if provided.
- **interaction-mode**: `yolo` (autonomous) or `collaborative` (interactive)
- **execution-mode**: `sequential` (default) or `parallel`
- **filter**: `unresolved-only` (default), `all`, or `by-reviewer`
- **auto-resolve**: Automatically resolve threads after addressing (default: true)
- **reviewer**: Filter comments by specific reviewer

OUTPUT:
    Summary of comments addressed, files changed, status

Related Skills

• pull-request-tool: For fetching PR details, posting replies, resolving threads
• handle-pr-feedback: For triage and decision routing based on feedback severity
• update-work-item: For reverting work item status when major feedback is detected
• process-pr: Orchestrates full PR workflow including feedback resolution
• sequential-execution: For ordered comment processing
• parallel-execution: For concurrent comment addressing