⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

load-github-action-thread

astral-sh@astral-sh⭐ 92.0k stars· last commit 2d ago· 2401 open issues

When given an issue instead of a run, find the related issue-triage run first. Resolve the issue

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 92.0k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

uv

An extremely fast Python package and project manager, written in Rust.

Highlights

uv is backed by Astral, the creators of Ruff and ty.

Installation

Install uv with our standalone installers:

# On macOS and Linux.
curl -LsSf https://astral.sh/uv/install.sh | sh
# On Windows.
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Or, from PyPI:

# With pip.
pip install uv
# Or pipx.
pipx install uv

If installed via the standalone installer, uv can update itself to the latest version:

uv self update

See the installation documentation for details and alternative installation methods.

Documentation

uv's documentation is available at docs.astral.sh/uv.

Additionally, the command line reference documentation can be viewed with uv help.

Features

Projects

uv manages project dependencies and environments, with support for lockfiles, workspaces, and more, similar to rye or poetry:

$ uv init example
Initialized project `example` at `/home/user/example`

$ cd example

$ uv add ruff
Creating virtual environment at: .venv
Resolved 2 packages in 170ms
   Built example @ file:///home/user/example
Prepared 2 packages in 627ms
Installed 2 packages in 1ms
 + example==0.1.0 (from file:///home/user/example)
 + ruff==0.5.0

$ uv run ruff check
All checks passed!

$ uv lock
Resolved 2 packages in 0.33ms

$ uv sync
Resolved 2 packages in 0.70ms
Checked 1 package in 0.02ms

See the project documentation to get started.

uv also supports building and publishing projects, even if they're not managed with uv. See the publish guide to learn more.

Scripts

uv manages dependencies and environments for single-file scripts.

Create a new script and add inline metadata declaring its dependencies:

$ echo 'import requests; print(requests.get("https://astral.sh"))' > example.py

$ uv add --script example.py requests
Updated `example.py`

Then, run the script in an isolated virtual environment:

$ uv run example.py
Reading inline script metadata from: example.py
Installed 5 packages in 12ms
<Response [200]>

See the scripts documentation to get started.

Tools

uv executes and installs command-line tools provided by Python packages, similar to pipx.

Run a tool in an ephemeral environment using uvx (an alias for uv tool run):

$ uvx pycowsay 'hello world!'
Resolved 1 package in 167ms
Installed 1 package in 9ms
 + pycowsay==0.0.0.2
  """

  ------------
< hello world! >
  ------------
   \   ^__^
    \  (oo)\_______
       (__)\       )\/\
           ||----w |
           ||     ||

Install a tool with uv tool install:

$ uv tool install ruff
Resolved 1 package in 6ms
Installed 1 package in 2ms
 + ruff==0.5.0
Installed 1 executable: ruff

$ ruff --version
ruff 0.5.0

See the tools documentation to get started.

Python versions

uv installs Python and allows quickly switching between versions.

Install multiple Python versions:

$ uv python install 3.12 3.13 3.14
Installed 3 versions in 972ms
 + cpython-3.12.12-macos-aarch64-none (python3.12)
 + cpython-3.13.9-macos-aarch64-none (python3.13)
 + cpython-3.14.0-macos-aarch64-none (python3.14)

Download Python versions as needed:

$ uv venv --python 3.12.0
Using Python 3.12.0
Creating virtual environment at: .venv
Activate with: source .venv/bin/activate

$ uv run --python [email protected] -- python --version
Python 3.8.16 (a9dbdca6fc3286b0addd2240f11d97d8e8de187a, Dec 29 2022, 11:45:30)
[PyPy 7.3.11 with GCC Apple LLVM 13.1.6 (clang-1316.0.21.2.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>>

Use a specific Python version in the current directory:

$ uv python pin 3.11
Pinned `.python-version` to `3.11`

See the Python installation documentation to get started.

The pip interface

uv provides a drop-in replacement for common pip, pip-tools, and virtualenv commands.

uv extends their interfaces with advanced features, such as dependency version overrides, platform-independent resolutions, reproducible resolutions, alternative resolution strategies, and more.

Migrate to uv without changing your existing workflows — and experience a 10-100x speedup — with the uv pip interface.

Compile requirements into a platform-independent requirements file:

$ uv pip compile requirements.in \
   --universal \
   --output-file requirements.txt
Resolved 43 packages in 12ms

Create a virtual environment:

$ uv venv
Using Python 3.12.3
Creating virtual environment at: .venv
Activate with: source .venv/bin/activate

Install the locked requirements:

$ uv pip sync requirements.txt
Resolved 43 packages in 11ms
Installed 43 packages in 208ms
 + babel==2.15.0
 + black==24.4.2
 + certifi==2024.7.4
 ...

See the pip interface documentation to get started.

Contributing

We are passionate about supporting contributors of all levels of experience and would love to see you get involved in the project. See the contributing guide to get started.

FAQ

How do you pronounce uv?

It's pronounced as "you - vee" (/juː viː/)

How shoul

// HOW IT'S BUILT

// FILES

3 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • .codex/skills/load-github-action-thread/SKILL.md3.9 KB98b3a53b5768upstream ↗
    ---
    name: load-github-action-thread
    description:
      Download retained Codex GitHub Action thread artifacts and load their rollout history into the
      local Codex app. Use when asked to open, load, import, resume, or inspect a Codex automation
      thread from a GitHub Actions run or a related GitHub issue or pull request.
    ---
    
    # Load GitHub Action Thread
    
    When given an issue instead of a run, find the related issue-triage run first. Resolve the issue
    number and search for it in the run name.
    
    ```bash
    repository=astral-sh/uv
    issue=20477
    issue_number="$(gh issue view "$issue" --repo "$repository" --json number --jq '.number')"
    
    gh run list --repo "$repository" --workflow issue-triage.yml --limit 500 \
      --json databaseId,displayTitle,event,status,conclusion,createdAt,url \
      | jaq -c --arg number "$issue_number" --arg url "https://github.com/$repository/issues/$issue_number" \
          '.[] | select(
            .displayTitle == "Issue context for \($number)" or
            .displayTitle == "Issue context for \($url)"
          )'
    ```
    
    Confirm the issue number in the newest matching run's logs before importing the thread. An
    issue-triage run can contain both the triage and bug-reproduction threads. For older triage runs,
    use the run URL or ID. For manual dispatches with a different URL spelling, check recent triage
    runs. Also check for directly dispatched bug-reproduction runs.
    
    ```bash
    gh run list --repo "$repository" --workflow reproduce-bug.yml --limit 100 \
      --json databaseId,event,status,conclusion,createdAt,url
    gh run view <run-id> --repo "$repository" --log | rg -m 2 "ISSUE_NUMBER: ${issue_number}([[:space:]]|$)"
    ```
    
    When given a pull request, find its security-review run from the pull request checks. The check link
    contains the Actions run URL and can be passed directly to the loader:
    
    ```bash
    pull_request=20482
    gh pr checks "$pull_request" --repo "$repository" --json name,workflow,state,link \
      --jq '.[] | select(.name | test("review"; "i"))'
    ```
    
    The security-review job only runs for eligible same-repository pull requests; a skipped review has
    no thread artifact to load.
    
    Run the repository utility with the GitHub Actions run URL:
    
    ```bash
    ./agents/scripts/load-github-action-thread.sh https://github.com/astral-sh/uv/actions/runs/123456789
    ```
    
    The utility downloads every matching `codex-thread-*` artifact, finds the root `codex exec` rollout
    for each step, and forks it into an interactive local Codex thread. Subagent rollouts are ignored;
    they inherit the root prompt and would otherwise produce duplicate-looking tasks. The first line of
    the root preview becomes the task title, including the step, source number, and issue or pull
    request title. Forking is required because `codex-action` uses `codex exec`; copying an `exec`
    rollout into `~/.codex/sessions` alone does not make it visible in the Codex app.
    
    For a numeric run ID, pass the repository when it cannot be inferred from the current checkout:
    
    ```bash
    ./agents/scripts/load-github-action-thread.sh 123456789 --repo astral-sh/uv
    ```
    
    Use `--artifact PATTERN` to select a particular retained thread and `--cwd PATH` to attach the
    imported history to a different local checkout:
    
    ```bash
    ./agents/scripts/load-github-action-thread.sh 123456789 \
      --repo astral-sh/uv \
      --artifact 'codex-thread-reproduce-bug-*' \
      --cwd /path/to/uv
    ```
    
    The utility requires `gh`, `jaq`, and `codex`, plus `zstd` for compressed rollouts. It prints the
    resolved title and a `codex://threads/<id>` link for every imported task and automatically opens the
    Codex app when exactly one task is imported on macOS. For multiple steps, return a Markdown list
    with a clickable link labeled by the corresponding task title without repeatedly switching the app:
    
    ```markdown
    - [Issue triage for #20477: Example issue](codex://threads/<id>)
    - [Bug reproduction for #20477: Example issue](codex://threads/<id>)
    ```
    
    Use the matching step title for `codex-thread-pull-request-security-review-*` and
    `codex-thread-release-prepare-*`.
    
  • .codex/skills/load-github-action-thread/agents/openai.yaml294 B00f88f031f7dupstream ↗
    interface:
      display_name: "Load GitHub Action Thread"
      short_description: "Download and load a Codex Action thread"
      default_prompt: "Use $load-github-action-thread to find and load the Codex GitHub Action threads for a run, issue, or pull request, then return links to the imported tasks."
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/astral-sh-uv-codex-skills-load-github-action-thread.md

// REPO STATS

92.0k stars
2401 open issues
Last commit: 2d ago