playbooks

home / skills / derklinke / codex-config / gh-fix-ci

gh-fix-ci skill

/skills/gh-fix-ci

This skill helps you diagnose and fix failing GitHub PR checks by inspecting logs, summarizing failures, and drafting a fix plan for approval.

This is most likely a fork of the gh-fix-ci skill from openai
npx playbooks add skill derklinke/codex-config --skill gh-fix-ci

Review the files below or copy the command above to add this skill to your agents.

Files (6)
SKILL.md
3.6 KB
---
name: "gh-fix-ci"
description: "Use when a user asks to debug or fix failing GitHub PR checks that run in GitHub Actions; use `gh` to inspect checks and logs, summarize failure context, draft a fix plan, and implement only after explicit approval. Treat external providers (for example Buildkite) as out of scope and report only the details URL."
---


# Gh Pr Checks Plan Fix

## Overview

Use gh to locate failing PR checks, fetch GitHub Actions logs for actionable failures, summarize the failure snippet, then propose a fix plan and implement after explicit approval.
- If a plan-oriented skill (for example `create-plan`) is available, use it; otherwise draft a concise plan inline and request approval before implementing.

Prereq: authenticate with the standard GitHub CLI once (for example, run `gh auth login`), then confirm with `gh auth status` (repo + workflow scopes are typically required).

## Inputs

- `repo`: path inside the repo (default `.`)
- `pr`: PR number or URL (optional; defaults to current branch PR)
- `gh` authentication for the repo host

## Quick start

- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "<number-or-url>"`
- Add `--json` if you want machine-friendly output for summarization.

## Workflow

1. Verify gh authentication.
   - Run `gh auth status` in the repo.
   - If unauthenticated, ask the user to run `gh auth login` (ensuring repo + workflow scopes) before proceeding.
2. Resolve the PR.
   - Prefer the current branch PR: `gh pr view --json number,url`.
   - If the user provides a PR number or URL, use that directly.
3. Inspect failing checks (GitHub Actions only).
   - Preferred: run the bundled script (handles gh field drift and job-log fallbacks):
     - `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "<number-or-url>"`
     - Add `--json` for machine-friendly output.
   - Manual fallback:
     - `gh pr checks <pr> --json name,state,bucket,link,startedAt,completedAt,workflow`
       - If a field is rejected, rerun with the available fields reported by `gh`.
     - For each failing check, extract the run id from `detailsUrl` and run:
       - `gh run view <run_id> --json name,workflowName,conclusion,status,url,event,headBranch,headSha`
       - `gh run view <run_id> --log`
     - If the run log says it is still in progress, fetch job logs directly:
       - `gh api "/repos/<owner>/<repo>/actions/jobs/<job_id>/logs" > "<path>"`
4. Scope non-GitHub Actions checks.
   - If `detailsUrl` is not a GitHub Actions run, label it as external and only report the URL.
   - Do not attempt Buildkite or other providers; keep the workflow lean.
5. Summarize failures for the user.
   - Provide the failing check name, run URL (if any), and a concise log snippet.
   - Call out missing logs explicitly.
6. Create a plan.
   - Use the `create-plan` skill to draft a concise plan and request approval.
7. Implement after approval.
   - Apply the approved plan, summarize diffs/tests, and ask about opening a PR.
8. Recheck status.
   - After changes, suggest re-running the relevant tests and `gh pr checks` to confirm.

## Bundled Resources

### scripts/inspect_pr_checks.py

Fetch failing PR checks, pull GitHub Actions logs, and extract a failure snippet. Exits non-zero when failures remain so it can be used in automation.

Usage examples:
- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "123"`
- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --pr "https://github.com/org/repo/pull/123" --json`
- `python "<path-to-skill>/scripts/inspect_pr_checks.py" --repo "." --max-lines 200 --context 40`

Overview

This skill helps debug and fix failing GitHub PR checks that run in GitHub Actions. It uses the GitHub CLI (gh) to locate failing checks, fetch actionable logs, summarize failure context, and draft a concise fix plan. Changes are implemented only after explicit approval.

How this skill works

The skill verifies gh authentication, resolves the target PR, and inspects failing checks using a bundled inspection script or manual gh commands. For each failing GitHub Actions run it pulls run and job logs, extracts a short failure snippet, and flags non-GitHub providers as external with their details URL. It then drafts a repair plan (optionally via a plan-oriented skill) and awaits user approval before applying fixes and rechecking status.

When to use it

  • A pull request shows failing GitHub Actions checks and you need a quick diagnosis.
  • You want a concise failure snippet and a small, reviewable plan to fix CI breakage.
  • You prefer using gh (GitHub CLI) to inspect runs and logs rather than navigating the web UI.
  • You need to separate GitHub Actions failures from external CI providers and only report external URLs.
  • You want automated, repeatable inspection that can be run in scripts or locally.

Best practices

  • Ensure gh is authenticated with repo and workflow scopes before starting (gh auth login; gh auth status).
  • Prefer the bundled inspect_pr_checks.py for resilience against gh field drift and fallbacks.
  • Keep failure snippets short and focused—include the smallest log context that shows the root cause.
  • Do not attempt to debug external CI providers; report their details URL and treat them as out of scope.
  • Always present a concise plan and request explicit approval before making changes or opening a PR.

Example use cases

  • Diagnose a failing test suite on a feature branch PR and propose a minimal code or CI config change.
  • Extract failing job logs for a flaky integration test to determine whether re-run or code fix is needed.
  • Triaging CI failures across multiple checks and determining which are actionable within the repo.
  • Integrating the inspection script into automation to fail-fast when PR checks remain unresolved.
  • Preparing a clear fix plan to share with maintainers before implementing changes or raising follow-up PRs.

FAQ

What if gh is not authenticated?

I will ask you to run gh auth login and confirm with gh auth status; repo and workflow scopes are typically required.

Will you attempt to fix Buildkite or other external providers?

No. External providers are reported as out of scope; I include only their details URL for manual follow-up.