Interactive PR Reviews with GitHub Copilot in VS Code¶

## Pull Request Review Workflow

### 1. Accessing GitHub Copilot Review Comments

When asked to review PR comments, use the GitHub GraphQL API to retrieve inline review comments:

```bash
# List all review threads and comments on a PR using GraphQL
# Note: Set GH_PAGER=cat to prevent output from opening in pager (alternate buffer)
GH_PAGER=cat gh api graphql -f query='
query($owner: String!, $repo: String!, $prNumber: Int!) {
repository(owner: $owner, name: $repo) {
    pullRequest(number: $prNumber) {
    reviewThreads(first: 100) {
        nodes {
        id
        isResolved
        isOutdated
        isCollapsed
        comments(first: 50) {
            nodes {
            id
            body
            path
            position
            line
            startLine
            author {
                login
            }
            createdAt
            }
        }
        }
    }
    }
}
}' -f owner='{OWNER}' -f repo='{REPO}' -F prNumber={PR_NUMBER}
```

**Note:** GitHub Copilot review comments are inline code review comments attached to specific lines in the "Files changed" tab. They are NOT visible in the PR timeline via `github-pull-request_openPullRequest` tool - you must use the GraphQL API to access review threads with their resolution status.

**Pager Issue:** The `GH_PAGER=cat` prefix prevents `gh` from opening results in a pager (like `less`), which would use the terminal's "alternate buffer" and make output unavailable for processing. This is crucial when piping results or capturing output.

### 2. Interactive PR Comment Resolution Process

When the user requests review of PR comments, follow this structured workflow:

1. **Retrieve Comments**: Use the GraphQL API (Section 1) to fetch all inline review comments
2. **Present Summary**: Show all comments with file paths, line numbers, and descriptions
3. **Iterate Through Each Comment**:
- Present the comment and its context
- **Assess validity**: Explain whether the comment makes sense and why
- **Propose solution**: If valid, suggest a specific fix with code changes
- **Wait for approval**: Do NOT implement until the user explicitly approves with "okay" or similar confirmation
- **Implement**: Once approved, make the changes
- **Move to next**: Only proceed to the next comment after completing the current one
4. **Track Progress**: Keep track of which comments have been addressed
5. **Complete Review**: Confirm when all comments have been resolved

**Key Principles**:
- Work on ONE comment at a time
- Always wait for user approval before implementing
- Be interactive and collaborative, not autonomous
- Provide clear explanations for each assessment
- Propose specific, actionable solutions with code examples

### 3. Replying to PR Comments After Fixes

After addressing a PR comment with code changes, reply to the comment thread to document the resolution:

#### Process:

1. **Always ask for the commit hash** if changes were made:
```
"What's the commit hash for these changes? I'll use it in the reply to the PR comment."
```

2. **Reply to the comment thread using GraphQL:**
```bash
GH_PAGER=cat gh api graphql -f query='
mutation($threadId: ID!, $body: String!) {
    addPullRequestReviewThreadReply(input: {
    pullRequestReviewThreadId: $threadId
    body: $body
    }) {
    comment {
        id
        body
        createdAt
        author {
        login
        }
    }
    }
}' -f threadId="{THREAD_NODE_ID}" -f body="Fixed in {COMMIT_HASH}.

Brief description of how the issue was addressed."
```

3. **Verify the reply was created**:
```bash
GH_PAGER=cat gh api graphql -f query='query($owner: String!, $repo: String!, $prNumber: Int!) {
    repository(owner: $owner, name: $repo) {
    pullRequest(number: $prNumber) {
        reviewThreads(first: 100) {
        nodes {
            id
            comments(first: 50) {
            nodes { id author { login } body createdAt }
            }
        }
        }
    }
    }
}' -f owner='{OWNER}' -f repo='{REPO}' -F prNumber={PR_NUMBER} \
        --jq '.data.repository.pullRequest.reviewThreads.nodes[] | select(.id == "{THREAD_NODE_ID}") | .comments.nodes | length'

#### Reply Template:

```
Fixed in {COMMIT_HASH}.

We've addressed this by:
1. [Specific change 1]
2. [Specific change 2]
3. [Additional improvements if any]

[Optional: Brief explanation of the solution approach]
```

#### Important Notes:

- **DO NOT** try to edit Copilot's original comment - create a reply instead
- **DO NOT** use `gh pr review --comment` as it creates a new top-level comment, not a reply to a thread
- **DO NOT** include PR comment numbers in commit messages
- **ALWAYS** include the commit hash in the reply for traceability
- **ALWAYS** use GraphQL for PR review operations - it provides thread resolution status and better structure
- **Thread IDs**: Use thread node IDs (format: `PRRT_...`) from Section 1 query, not individual comment IDs
- **Resolution**: Comment threads CAN be marked as resolved programmatically via GraphQL API (see Section 4 below)

#### Example Workflow:

```bash
# 1. User: "I've committed the fix as abc123f, please reply to thread PRRT_kwDOLJ_mhs5ti05M"

# 2. Reply to thread using GraphQL
GH_PAGER=cat gh api graphql -f query='
mutation($threadId: ID!, $body: String!) {
addPullRequestReviewThreadReply(input: {
    pullRequestReviewThreadId: $threadId
    body: $body
}) {
    comment {
    id
    body
    createdAt
    }
}
}' -f threadId="PRRT_kwDOLJ_mhs5ti05M" -f body="Fixed in abc123f.

We've addressed this by:
1. Adding proper error handling
2. Creating utility function for DRY principle

This ensures consistent error handling across all operations."

# 3. Verify with GraphQL
GH_PAGER=cat gh api graphql -f query='query($owner: String!, $repo: String!, $prNumber: Int!) {
repository(owner: $owner, name: $repo) {
    pullRequest(number: $prNumber) {
    reviewThreads(first: 100) {
        nodes {
        id
        comments(first: 50) { nodes { id author { login } createdAt } }
        }
    }
    }
}
}' -f owner='{OWNER}' -f repo='{REPO}' -F prNumber={PR_NUMBER} \
--jq '.data.repository.pullRequest.reviewThreads.nodes[] | select(.id == "PRRT_kwDOLJ_mhs5ti05M") | .comments.nodes | length'
```

### 4. Resolving PR Comment Threads

After addressing all comments in a review thread, mark the thread as resolved using the GraphQL API:

```bash
# Resolve a review thread
GH_PAGER=cat gh api graphql -f query='
mutation($threadId: ID!) {
resolveReviewThread(input: {threadId: $threadId}) {
    thread {
    id
    isResolved
    }
}
}' -f threadId="{THREAD_NODE_ID}"

# Unresolve a review thread if needed
GH_PAGER=cat gh api graphql -f query='
mutation($threadId: ID!) {
unresolveReviewThread(input: {threadId: $threadId}) {
    thread {
    id
    isResolved
    }
}
}' -f threadId="{THREAD_NODE_ID}"
```

**Getting Thread IDs:**
Thread node IDs are returned in the GraphQL query from Section 1 (look for `reviewThreads.nodes[].id`). Each thread groups logically related review comments together.

**When to resolve:**
- After replying with fixes and getting confirmation
- When all actionable items in the thread are complete
- As part of the interactive PR review workflow

**Note:** GraphQL requires node IDs (format: `PRRT_...`) rather than numeric IDs. Always fetch the thread ID from the review threads query first.