analyze-ci

Files (4)

• SKILL.md
• poll-ci.sh
• poll_ci.py
• test_poll_ci.py

SKILL.md (first lines)

# Analyze CI

Analyze CI checks for the current branch's PR. Polls pending checks until all complete, diagnoses failures, auto-fixes straightforward issues, and suggests fixes for the rest.

## Prerequisites

- **GitHub CLI**: Authenticated via `gh auth login`
- **Current Branch**: Has an open PR on GitHub
- **Clean Working Tree**: No uncommitted changes (required for auto-fix commits)

## Workflow

1. Detect PR and check merge status
2. Fetch CI check status
3. Wait for pending checks (if any)
4. Analyze failures
5. Classify fixability and apply auto-fixes
6. Commit fixes (if any)
7. Report results

---

## Step 1: Detect PR and Check Merge Status

```bash
gh pr view --json number,state,mergedAt,mergedBy,headRefName
```

- If **no PR found**: report "No PR for current branch" and stop
- If **state is MERGED**: report merge time and author, then stop
- Otherwise: continue with the PR number

## Step 2: Fetch CI Check Status

```bash
gh pr checks --json name,state,bucket,workflow,link,completedAt,startedAt
```

Categorize each check by `bucket`:
- `pass` → passed
- `fail` → failed
- `pending` → still running
- `skipping` / `cancel` → skipped/cancelled

Display summary on a single line with check names:

```bash
gh pr checks --json name,state,bucket,workflow | jq -r '
  group_by(.bucket) | 
  map({bucket: .[0].bucket, count: length, items: map(.name)}) | 
  .[] | 
  "\(.bucket | ascii_upcase): \(.count) - \(.items | join(", "))"
'
```

Format: **CI Status:** ✅ N passed | 🟡 N pending | ❌ N failed

Then list check names per bucket:
- **Passed:** check1, check2, check3
- **Pending:** check4, check5
- **Failed:** check6

If all passed and none pending → report success and stop.

## Step 3: Wait for Pending Checks — Stream Dispatch on Failure

If any checks have `bucket: "pending"`:

1. List which checks are still running with their start times
2. Tell the user: "N checks still running. Polling every 30s — dispatching fix agents as failures are found..."
3. **Do NOT use `gh pr checks --watch`** — it blocks as a single long-lived command, hits bash timeout limits, and dies on transient network errors.
4. Gather **fork context** once now (used by every sub-agent dispatched during polling):
   ```bash
   gh pr view --json number,headRefName,baseRefName,title,body
   git log --oneline -10
   git diff $(gh pr view --json baseRefName -q .baseRefName)...HEAD --stat
   ```
5. Launch `poll_ci.py` in background (completion signal):
   ```bash
   find ~/.claude -name "poll_ci.py" -path "*/analyze-ci/*" | head -1
   python3 <path> --interval 30 --timeout 3600
   ```
   Run with `run_in_background: true`, `timeout: 3600000`.
6. **Polling loop** — run until `poll_ci.py` background task completes:
   Every 30s, fetch current check state:
   ```bash
   gh pr checks --json name,state,bucket,workflow,link
   ```
   For each check that just flipped to `bucket: "fail"` (not seen as failed before this iteration):
   - Group it with matrix siblings already known to have failed (same base name)
   - **Immediately dispatch a fix sub-agent** for the group (see sub-agent prompt below)
   - Track dispatched groups — do not re-dispatch a group already dispatched
   - Continue polling; do not wait for the agent to finish before polling again

7. When `poll_ci.py` signals completion, do a final fetch to catch any last failures missed between poll ticks, dispatch agents for any new groups not yet dispatched, then proceed.
8. If all checks passed (no failures ever seen) → report success and stop.

## Step 4: Fix Sub-Agents — Dispatch and Collect

### 4a: Grouping Rule (apply at dispatch time during polling)

For each newly-failed check:
1. Extract run ID from link: `https://github.com/OWNER/REPO/actions/runs/RUN_ID/...`
2. Derive **base job name** by stripping trailing ` (...)` suffix:
   - `test (postgres-14)` → `test`
   - `build / lint (node-18)` → `build / lint`
   - `integration-tests (mysql, ubuntu)` → `integration-tests`
3. If a group with this base name was already dispatched, skip (matrix sibling handled). If a group exists but agent not yet dispatched, add sibling and dispatch now.

### 4b: Sub-Agent Prompt (fill in per group at dispatch time)

Each agent works in isolation — no shared state with other agents.

```
You are a CI fix agent. Work independently; do not reference other CI groups.

## Fork Context
- Repo: <OWNER/REPO>
- PR branch: <BRANCH_NAME>

From bonzofenix/skills, MIT.

More from bonzofenix/skills