address-pr-comments

Files (1)

• SKILL.md

SKILL.md (first lines)

**CRITICAL**: This skill makes PUBLIC changes — commits pushed to the PR branch and replies visible to the PR author, reviewers, and all watchers. Every commit must follow project conventions (signed off, GPG-signed where configured, conventional message). Every reply must be accurate, justified, and in English.

## Arguments

Parse `$ARGUMENTS` as a space-separated list of PR refs.

- Each ref: bare number (e.g. `2395`, uses the repo from `gh repo view --json owner,name`) OR `owner/repo#N` (e.g. `cozystack/cozystack#2395`).
- If no args: fall back to detection from the current branch via `gh pr view --json number,headRepositoryOwner,headRepository --jq '.headRepositoryOwner.login + "/" + .headRepository.name + "#" + (.number|tostring)'` — single-PR mode.
- If no args and no PR can be inferred: report the error and stop.

Normalize each ref into `OWNER`, `REPO`, `PR_NUMBER`.

## Step 0: Record the starting state

Before touching any PR branch:

```bash
ORIGINAL_REF=$(git symbolic-ref --quiet --short HEAD || git rev-parse HEAD)
if [ -z "$(git status --porcelain)" ]; then CLEAN_START=1; else CLEAN_START=0; fi
```

- `ORIGINAL_REF` is the branch to return to at the end.
- `CLEAN_START == 1` means the working tree was clean — safe to restore later.
- If the working tree is dirty, ask the user how to handle it (abort, stash, or proceed without final restore) BEFORE doing any `git checkout`.

## Step 1: Outer loop over PR refs

For each PR ref in the parsed list, execute Steps 2–10 in order. Between PRs, print a visible separator (e.g. `────── PR #N ──────`) so progress is easy to follow.

On a per-PR unrecoverable error (PR not found, branch push rejected and user chose not to force, etc.): print the error, skip the remaining steps for that PR, continue with the next ref. Do not abort the whole run.

## Step 2: Check out the PR branch

```bash
PR_BRANCH=$(gh pr view $PR_NUMBER --repo $OWNER/$REPO --json headRefName --jq .headRefName)
git fetch origin "$PR_BRANCH"
git checkout "$PR_BRANCH"
git log --oneline -5
```

**Worktree guard**: if `git checkout` fails with `fatal: '<branch>' is already used by worktree at <path>`, parse the path, `cd` into that worktree, and run the rest of the PR's steps there. Do not delete or force anything.

## Step 3: Read project agent docs

Scan the repo for agent-facing contribution rules and follow them exactly. Common locations:

- `AGENTS.md`, `docs/agents/contributing.md`, `docs/agents/*.md`
- `CONTRIBUTING.md` (look for "review comments" / "AI bot" / "commit format" sections)

Project rules OVERRIDE this skill's defaults — e.g. commit message format, reply etiquette, threads to ignore, whether a separate commit per thread is required.

## Step 4: Fetch every source of actionable feedback

Three GitHub objects can carry blocking feedback on a PR. The skill must read all three:

1. **Inline review threads** (`reviewThreads`) — comments attached to a file/line, repliable via `addPullRequestReviewThreadReply`.
2. **Review submission bodies** (`reviews[].body`) — the freeform text a reviewer types when they click *Approve / Request changes / Comment*. They have **no** `threadId` and are **not** part of `reviewThreads`. A `CHANGES_REQUESTED` review with only a body and zero inline comments is the most-common cause of a PR being blocked without any thread to reply to. Missing this source = silently ignoring the reviewer.
3. **Issue comments** — the general PR conversation (bot summaries, follow-ups).

Also pull `reviewDecision` so the skill knows when the PR is blocked but no findings remain after filtering — that almost always means a finding was missed.

```bash
SELF_LOGIN=$(gh api user --jq .login)

gh api graphql -F owner="$OWNER" -F repo="$REPO" -F pr=$PR_NUMBER -f query='
query($owner: String!, $repo: String!, $pr: Int!) {
  repository(owner: $owner, name: $repo) {
    pullRequest(number: $pr) {
      reviewDecision
      reviewThreads(first: 100) {
        pageInfo { hasNextPage endCursor }
        nodes {
          id
          isResolved
          isOutdated
          comments(first: 100) {
            pageInfo { hasNextPage }
            nodes {
              id
              path
              line
              originalLine
              author { login }
              bodyText
              url
              createdAt
            }
          }
          latestComment: comments(last: 1) {
            nodes {
              author { login }
              createdAt
            }
          }
        }
      }
      reviews(first: 100, states: [CHANGES_REQUESTED, COMMENTED]) {
        pageInfo { hasNextPage endCursor }
        nodes {
          id
          state
          body
          author { login }
          submittedAt
          url
          commit { oid }
          comments(first: 1) { totalCount }
        }
      }
    }
  }
}'
```

Filter:

- **Threads** — keep where `isResolved == false`.
- **Threads (self-reply guard)** — additionally drop any thread where `latestComment.nodes[0].author.login == $SELF_LOGIN`. This prevents duplicate replies on re-runs against PRs with reviewers that do not auto-resolve threads after a fix lands (e.g. Gemini Code Assist). Empty `latestComment.nodes` is treated as "not me" and the thread is kept. To genuinely re-engage a previously-replied thread, the operator posts the reply manually outside the skill flow.
- **Review submissions** — keep where `state == "CHANGES_REQUESTED"` (always, even with empty body — surface as ASK so the user explains the block). For `state == "COMMENTED"`, keep only if `body != ""` AND `comments.totalCount == 0` (a COMMENTED review with inline comments is already covered by the threads query; its body is usually a meta-summary).

From lexfrei/ccc, BSD-3-Clause.

More from lexfrei/ccc