ship-ci-review-loop — Claude Code command: setup and features
ship-ci-review-loop automates the CI and code review monitoring loop for pull requests. It polls GitHub checks, waits for bot reviews, and resolves feedback before merging.
MIT ★ 2,003 updated 2026-07-26
/plugin marketplace add composio-community/awesome-claude-plugins
/plugin install ship@awesome-claude-pluginsWhat ship-ci-review-loop does
This command implements phase 4 of the /ship workflow. It checks CI status by polling gh pr checks every 15 seconds until all checks finish. On the first run, the loop pauses for 3 minutes so external review bots like CodeRabbit or Copilot can finish posting comments.
The monitor loop runs up to 10 iterations with a 30-second interval. It inspects PR state using gh api graphql and filters responses with jq to track unresolved threads and change requests. Claude Code then applies fixes, commits the updates, and repeats the loop until zero unresolved conversations remain.
Without gh and jq installed and authenticated in your terminal, the bash monitor functions fail immediately.
What it helps with
- wait for GitHub CI check runs to pass
- fetch unresolved review threads via GraphQL
- handle code review comments from automated bots
- push iterative fixes until all review threads are resolved
Example prompts for the agent
- Run ship-ci-review-loop on the current pull request
- Check PR #12 for unresolved review comments and apply fixes
- Wait for CI checks and resolve remaining review threads
How to install ship-ci-review-loop
1Plugin marketplace
/plugin marketplace add composio-community/awesome-claude-plugins/plugin install ship@awesome-claude-plugins2Manually: put the files in place
.claude/commands/ship-ci-review-loop.mdCall it with /ship-ci-review-loop. For all projects use ~/.claude/commands/
Manually: put the files in place
~/.codex/prompts/ship-ci-review-loop.mdCall it with /prompts:ship-ci-review-loop. Codex marks this format deprecated in favour of skills
Manually: put the files in place
.github/prompts/ship-ci-review-loop.prompt.mdManually: put the files in place
.gemini/commands/ship-ci-review-loop.tomlGemini stores commands as TOML: the prompt text goes into the prompt field
Questions about ship-ci-review-loop
How to install ship-ci-review-loop in Claude Code?
Run /plugin marketplace add composio-community/awesome-claude-plugins to add the marketplace. Then install the command with /plugin install ship@awesome-claude-plugins. You can also configure it manually by adding .claude/commands/ship-ci-review-loop.md to your repository.
What does ship-ci-review-loop do?
It runs an iterative monitor loop that waits for CI checks to pass and ensures every review comment is addressed. The execution stops after at most 10 iterations and enforces a 3-minute initial wait for automated review bots.
Which dependencies must be installed?
The underlying monitor functions rely on gh (GitHub CLI) and jq. The GitHub CLI must have active repository access to execute gh pr checks and GraphQL queries.
Source text
ship-ci-review-loop.md · MIT
<ci-review-loop>
# Phase 4: CI & Review Monitor Loop - Reference
This file contains detailed implementation for the CI & Review Monitor Loop phase of `/ship`.
**Parent document**: `ship.md`
---
<mandatory-requirements>
## This Phase Is Mandatory
This is not optional. You must:
1. Wait the full 3 minutes for auto-reviewers
2. Run the monitor loop (not just check once)
3. Address all comments before merge
</mandatory-requirements>
---
<pr-auto-review>
## PR Auto-Review Process
PRs receive automatic reviews from configured auto-reviewers (Copilot, Gemini, CodeRabbit, etc.).
**Mandatory workflow:**
1. After PR creation, wait **at least 3 minutes** for first review round
2. Read **all comments** from all reviewers
3. Address **every comment** - no exceptions
4. Iterate until **zero unresolved threads** (typically 2-4 rounds)
**Rules:**
- Always address all comments, including "minor" or "nit" suggestions
- Do not skip a comment unless factually wrong or user-approved
- Treat all feedback as **required changes**, not suggestions
</pr-auto-review>
---
<overview>
## Overview
The monitor loop must wait for:
1. CI to pass
2. All comments resolved (addressed or replied to)
3. No "changes requested" reviews remain
## Why All Comments Matter
**Every comment must be addressed:**
- Critical/High issues: Fix immediately
- Medium issues: Fix (don't defer)
- Minor/Nit issues: Fix (shows attention to quality)
- Style suggestions: Fix (maintains codebase consistency)
- Questions: Answer with explanation
- False positives: Reply explaining why, then resolve
- Not relevant: Reply explaining why, then resolve
Do not ignore comments. Do not leave comments unresolved. A clean PR has zero unresolved conversations.
</overview>
## The Monitor Loop Algorithm
> **Note:** The JavaScript below is **conceptual pseudocode** showing the algorithm flow.
> Implement using bash functions defined in this file.
```javascript
const MAX_ITERATIONS = 10; // Safety limit
const INITIAL_WAIT_MS = 180000; // 3 minutes - wait for auto-reviews
const ITERATION_WAIT_MS = 30000; // 30 seconds between iterations
let iteration = 0;
while (iteration < MAX_ITERATIONS) {
iteration++;
console.log(`\n## CI & Review Monitor - Iteration ${iteration}`);
// Step 1: Wait for CI to complete
const ciStatus = await waitForCI();
if (ciStatus === 'failed') {
await fixCIFailures();
continue; // Push fix, re-run CI
}
// Step 1.5: First iteration only - wait for auto-reviews
if (iteration === 1) {
console.log("Waiting 3 minutes for auto-reviews...");
await sleep(INITIAL_WAIT_MS);
}
// Step 2: Check for PR comments and reviews
const feedback = await checkPRFeedback();
if (feedback.unresolvedCount === 0 && !feedback.changesRequested) {
console.log("[OK] CI passed, all comments resolved");
break; // Ready to merge!
}
// Step 3: Address ALL feedback
await addressAllFeedback(PR_NUMBER);
// Step 4: Push fixes
if (feedback.hasCodeChanges) {
await commitAndPush(`fix: address review feedback (iteration ${iteration})`);
}
// Step 5: Sleep before next check
await sleep(ITERATION_WAIT_MS);
}
```
## Step 1: Wait for CI
```bash
wait_for_ci() {
echo "Waiting for CI checks..."
while true; do
CHECKS=$(gh pr checks $PR_NUMBER --json name,state 2>/dev/null || echo "[]")
PENDING=$(echo "$CHECKS" | jq '[.[] | select(.state | IN("PENDING", "QUEUED", "IN_PROGRESS"))] | length')
FAILED=$(echo "$CHECKS" | jq '[.[] | select(.state | IN("FAILURE", "CANCELLED"))] | length')
PASSED=$(echo "$CHECKS" | jq '[.[] | select(.state=="SUCCESS")] | length')
if [ "$FAILED" -gt 0 ]; then
echo "[ERROR] CI failed ($FAILED checks)"
gh pr checks $PR_NUMBER
return 1
elif [ "$PENDING" -eq 0 ] && [ "$PASSED" -gt 0 ]; then
echo "[OK] CI passed ($PASSED checks)"
return 0
elif [ "$PENDING" -eq 0 ] && [ "$PASSED" -eq 0 ]; then
echo "[WARN] No CI checks found, proceeding..."
return 0
fi
echo " Waiting... ($PENDING pending, $PASSED passed)"
sleep 15
done
}
```
## Step 2: Check PR Feedback
```bash
check_pr_feedback() {
local pr_number=$1
echo "Checking PR feedback..."
# Extract owner and repo from git remote
REPO_INFO=$(gh repo view --json owner,name --jq '"\(.owner.login)/\(.name)"')
OWNER=$(echo "$REPO_INFO" | cut -d'/' -f1)
REPO=$(echo "$REPO_INFO" | cut -d'/' -f2)
# Get review state
REVIEWS=$(gh pr view $pr_number --json reviews --jq '.reviews')
CHANGES_REQUESTED=$(echo "$REVIEWS" | jq '[.[] | select(.state=="CHANGES_REQUESTED")] | length')
# Get unresolved review threads
# NOTE: Fetches first 100 threads. For PRs with >100 threads, implement pagination.
UNRESOLVED_THREADS=$(gh api graphql -f query='
query($owner: String!, $repo: String!, $pr: Int!) {
repository(owner: $owner, name: $repo) {
pullRequest(number: $pr) {
reviewThreads(first: 100) {
nodes {
isResolved
}
}
}
}
}
' -f owner="$OWNER" -f repo="$REPO" -F pr=$pr_number \
--jq '[.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == false)] | length')
echo " Unresolved threads: $UNRESOLVED_THREADS"
echo " Changes requested: $CHANGES_REQUESTED"
echo "{\"unresolvedThreads\": $UNRESOLVED_THREADS, \"changesRequested\": $CHANGES_REQUESTED}"
}
```
### Get Full Thread Details
```bash
get_unresolved_threads() {
local pr_number=$1
REPO_INFO=$(gh repo view --json owner,name --jq '"\(.owner.login)/\(.name)"')
OWNER=$(echo "$REPO_INFO" | cut -d'/' -f1)
REPO=$(echo "$REPO_INFO" | cut -d'/' -f2)
# NOTE: Fetches first 100 threads. For PRs with >100, implement pagination.
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
path
line
diffHunk
comments(first: 1) {
nodes {
id
body
}
}
}
}
}
}
}
' -f owner="$OWNER" -f repo="$REPO" -F pr=$pr_number \
--jq '.data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == false)'
}
```
## Step 3: Address ALL Feedback
> **Note:** This is **conceptual pseudocode** showing the algorithm flow.
> Implement using: gh api, Read, Edit, Task (ci-fixer), etc.
```javascript
async function addressAllFeedback(prNumber) {
const threads = await getUnresolvedThreads(prNumber);
console.log(`\nAddressing ${threads.length} unresolved threads...`);
for (const thread of threads) {
console.log(`\n--- Thread: ${thread.path}:${thread.line} ---`);
const analysis = analyzeComment(thread);
switch (analysis.type) {
case 'code_fix_required':
console.log(`Action: Fixing code issue`);
await implementFix(thread); // Use Task(ci-fixer) or Edit tool
break;
case 'style_suggestion':
console.log(`Action: Applying style fix`);
await implementFix(thread);
break;
case 'question':
console.log(`Action: Answering question`);
await replyToComment(prNumber, thread.commentId, generateAnswer(thread));
await resolveThread(thread.id);
break;
case 'false_positive':
console.log(`Action: Explaining false positive`);
await replyToComment(prNumber, thread.commentId,
`This is a false positive because: ${analysis.reason}\n\n` +
`Resolving. Please reopen if you disagree.`
);
await resolveThread(thread.id);
break;
case 'not_relevant':
console.log(`Action: Explaining out of scope`);
await replyToComment(prNumber, thread.commentId,
`Outside scope of this PR: ${analysis.reason}\n\n` +
`Resolving. Please reopen if needed.`
);
await resolveThread(thread.id);
break;
case 'already_addressed':
console.log(`Action: Confirming addressed`);
await replyToComment(prNumber, thread.commentId,
`Addressed in commit ${gitRevParseHead}.`
);
await resolveThread(thread.id);
break;
}
}
// Request re-review from those who requested changes
const changesRequestedReviews = await getChangesRequestedReviews(prNumber);
for (const review of changesRequestedReviews) {
await requestReReview(prNumber, review.author);
}
}
```
## Comment Analysis Heuristics
> **Note:** Classification heuristics for comment handling.
```javascript
function analyzeComment(thread) {
const body = thread.body.toLowerCase();
// Question patterns
if (body.includes('?') || body.startsWith('why') || body.startsWith('how') ||
body.startsWith('what') || body.startsWith('could you explain')) {
return { type: 'question', reason: 'Comment is a question' };
}
// Style/nit patterns
if (body.includes('nit:') || body.includes('nitpick') || body.includes('minor:') ||
body.includes('style:') || body.includes('consider') || body.includes('optional')) {
return { type: 'style_suggestion', reason: 'Style or minor suggestion' };
}
// Out of scope patterns
if (!thread.diffHunk || commentRefersToUnchangedCode(thread)) {
return { type: 'not_relevant', reason: 'Comment refers to unchanged code' };
}
// Default: treat as code fix required
return { type: 'code_fix_required', reason: 'Valid code feedback' };
}
```
## Implementing Fixes
Use the ci-fixer agent for code changes:
```javascript
Task({
subagent_type: "next-task:ci-fixer",
prompt: `Fix the following review comment:
**File**: ${thread.path}
**Line**: ${thread.line}
**Comment**: ${thread.body}
**Code Context**:
\`\`\`
${thread.diffHunk}
\`\`\`
Requirements:
1. Make the minimal change to address the feedback
2. Do NOT over-engineer or add unrelated changes
3. Ensure tests still pass after the fix`
});
```
## Resolving Threads
```bash
resolve_thread() {
local thread_id=$1
gh api graphql -f query='
mutation($threadId: ID!) {
resolveReviewThread(input: {threadId: $threadId}) {
thread {
isResolved
}
}
}
' -f threadId="$thread_id"
}
reply_to_comment() {
local pr_number=$1
local comment_id=$2
local body=$3
REPO_INFO=$(gh repo view --json owner,name --jq '"\(.owner.login)/\(.name)"')
OWNER=$(echo "$REPO_INFO" | cut -d'/' -f1)
REPO=$(echo "$REPO_INFO" | cut -d'/' -f2)
gh api -X POST "repos/$OWNER/$REPO/pulls/$pr_number/comments" \
-f body="$body" \
-F in_reply_to="$comment_id"
}
```
## Step 4: Commit and Push
```bash
commit_and_push_fixes() {
local message=$1
local branch=${2:-$(git branch --show-current)}
if [ -n "$(git status --porcelain)" ]; then
git add -A
git commit -m "$message"
git push origin "$branch"
echo "[OK] Pushed fixes"
return 0
else
echo "No code changes to commit (only comment replies)"
return 1
fi
}
```
## Complete Loop Script
```bash
#!/bin/bash
# Phase 4: CI & Review Monitor Loop
MAX_ITERATIONS=10
INITIAL_WAIT=${SHIP_INITIAL_WAIT:-180} # Configurable via env var
ITERATION_WAIT=30
iteration=0
while [ $iteration -lt $MAX_ITERATIONS ]; do
iteration=$((iteration + 1))
echo "[CI Monitor] Iteration $iteration"
# Step 1: Wait for CI
if ! wait_for_ci; then
echo "CI failed - launching ci-fixer agent..."
continue
fi
# Step 1.5: First iteration - wait for auto-reviews
if [ $iteration -eq 1 ] && [ "$INITIAL_WAIT" -gt 0 ]; then
echo "First iteration - waiting ${INITIAL_WAIT}s for auto-reviews..."
sleep $INITIAL_WAIT
fi
# Step 2: Check feedback
FEEDBACK=$(check_pr_feedback $PR_NUMBER)
UNRESOLVED=$(echo "$FEEDBACK" | jq -r '.unresolvedThreads')
CHANGES_REQ=$(echo "$FEEDBACK" | jq -r '.changesRequested')
if [ "$UNRESOLVED" -eq 0 ] && [ "$CHANGES_REQ" -eq 0 ]; then
echo "[OK] ALL CHECKS PASSED"
echo "[OK] ALL COMMENTS RESOLVED"
echo "Ready to merge!"
break
fi
# Step 3: Address all feedback
echo "Addressing $UNRESOLVED unresolved threads..."
# Step 4: Commit and push
commit_and_push_fixes "fix: address review feedback (iteration $iteration)"
# Step 5: Wait before next iteration
echo "Waiting ${ITERATION_WAIT}s..."
sleep $ITERATION_WAIT
done
if [ $iteration -ge $MAX_ITERATIONS ]; then
echo "[ERROR] Max iterations reached - manual intervention required"
exit 1
fi
```
<iteration-summary>
## Iteration Summary Output
```markdown
## Iteration ${iteration} Summary
**CI Status**: [OK] Passed
**Comments Addressed**: ${addressedCount}
- Code fixes: ${codeFixCount}
- Answered questions: ${questionCount}
- Resolved as not applicable: ${notApplicableCount}
**Remaining Unresolved**: ${remainingCount}
${remainingCount > 0 ? 'Continuing...' : 'Ready to merge!'}
```
</iteration-summary>
</ci-review-loop>
© Community · MIT · composio-community/awesome-claude-plugins