Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

cache-github-repo

/cache-github-repo

Klonuje i lokalnie buforuje przypiętą wersję repozytorium GitHub, aby inne skille miały do niego szybki i powtarzalny dostęp, z konfiguracją wersji dla projektu.

Repozytorium
pathling ↗
Licencja
MIT
Ostatnia zmiana repozytorium
21.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
5
Przestarzałość

Brak sygnałów. Repozytorium zmienione 21.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Klonuje i lokalnie buforuje przypiętą wersję repozytorium GitHub, aby inne skille miały do niego szybki i powtarzalny dostęp, z konfiguracją wersji dla projektu.

Wyzwalacze z opisu

cache this repopin a reference implementation

Argumenty

/cache-github-repo <ensure|configure> <org/repo> [--version <ref>] [--unattended]
Oryginalny opis (EN)

Clone and locally cache a pinned version of a GitHub repository for fast, deterministic access by other skills — for example a reference implementation consulted for spec cross-checking. Manages a tracked per-project config file mapping `org/repo` to a pinned version, and a version-keyed local cache shared across projects. Invoke directly to set or change a pin (`configure org/repo [--version ref]`), or let another skill delegate to it to make sure a pinned repo is available (`ensure org/repo [--unattended]`). Trigger on phrases like "cache this repo", "pin a reference implementation", "config

Jak działa

  1. Config file
  2. Cache location
  3. Mode: ensure <org/repo> [--unattended]
  4. Mode: configure <org/repo> [--version <ref>]
  5. Cloning a pinned ref
  6. What this skill does not do
Sekcje z nagłówków SKILL.md, w oryginale · 135 linii, 1 049 słów
Podgląd SKILL.md
---
name: cache-github-repo
description: >
  Clone and locally cache a pinned version of a GitHub repository for fast, deterministic access by
  other skills — for example a reference implementation consulted for spec cross-checking. Manages a
  tracked per-project config file mapping `org/repo` to a pinned version, and a version-keyed local
  cache shared across projects. Invoke directly to set or change a pin
  (`configure org/repo [--version ref]`), or let another skill delegate to it to make sure a pinned
  repo is available (`ensure org/repo [--unattended]`). Trigger on phrases like "cache this repo",
  "pin a reference implementation", "configure the version of X to use", or when a skill needs a
  stable local copy of an external GitHub repository.
argument-hint: <ensure|configure> <org/repo> [--version <ref>] [--unattended]
allowed-tools: Bash, AskUserQuestion
---

# Cache a GitHub repo locally, pinned to a version

Keeps other skills from depending on ad hoc, machine-specific setup (a hand-made symlink, a path
that only exists on one developer's machine) to reach reference material that lives in a GitHub
repository. Owns two things:

- a tracked, per-project config file recording which pinned version of which `org/repo` this project
  uses
- a local, version-keyed cache of that repo, shared across every project, worktree, and clone on this
  machine

Scope is deliberately narrow: `github.com` repositories identified by `org/repo`, nothing else.

## Config file

`.claude/repo-cache.yaml` at the project root (created on first `configure`). One line per pinned
repo, key is the GitHub `org/repo` slug:

```yaml
HL7/fhirpath.js: 3.16.4
```

The key doubles as the clone identifier (`https://github.com/<org>/<repo>.git`) — nothing else needs
recording. **Commit this file.** It is what makes the pin reproducible across every contributor,
clone, and CI run, rather than a personal, silent choice that could differ machine to machine.

## Cache location

```
~/.cache/claude-skills/github-repo-cache/<org>/<repo>/<version>/
```

Shared across every project on this machine and keyed by version, so two projects pinning different
versions of the same repo never conflict, and a version bump doesn't disturb whatever was cached for
the old one.

## Mode: `ensure <org/repo> [--unattended]`

The path other skills delegate to. **Never asks a question when `--unattended` is passed** — a
dispatched subagent or an unattended pipeline has no one to answer it.

1. Resolve the project root (`git rev-parse --show-toplevel`, or `$PWD` if not inside a git repo) and
   read `.claude/repo-cache.yaml` there. Look up `<org/repo>`.
2. **Entry missing:**
   - `--unattended` literally passed as an argument to this invocation → fail immediately. Report:
     `"<org/repo> has no configured version — run '/cache-github-repo configure <org/repo>' first"` and
     stop. Do not guess a version, do not attempt to ask.
   - Otherwise → run the `configure` steps below for this repo, then continue. This includes when the
     current session has some general "auto mode"/"operate autonomously" disposition — that governs
     tool-permission friction, not whether a human can answer a question, and does not satisfy the
     `--unattended` condition above. Only the literal flag does.
3. **Entry present** → let `VERSION` be the recorded value. Compute
   `CACHE_DIR=~/.cache/claude-skills/github-repo-cache/<org>/<repo>/<version>`.
   - `$CACHE_DIR/.git` exists → already cached. Report `$CACHE_DIR` and stop.
   - Missing → clone it (see "Cloning a pinned ref" below), then report `$CACHE_DIR`.

## Mode: `configure <org/repo> [--version <ref>]`

The explicit, user-invoked path — and also what `ensure` falls into automatically when attended and
the entry is missing.

1. If `--version <ref>` was given, use it as `VERSION` and skip to step 3.
2. Otherwise, find the candidates:
   ```bash
   git ls-remote --tags --sort=-v:refname "https://github.com/<org>/<repo>.git" | head -5
   ```
   Present the most recent tag as "latest stable" and `main` as the alternative. You MUST NOT pick one
   and write the config yourself, even under an "auto mode"/"proceed autonomously" disposition — wait
   for the user's choice (e.g. via `AskUserQuestion`) first. If the network call fails, say so and ask
   the user to supply a ref directly instead of guessing.

   Whichever is chosen, record a reference that stays fixed across future runs:
   - A tag → record the tag name. This is a deliberate trade-off, not a claim that the tag can never
     move: a maintainer could in principle recreate or reassign one, but for a maintained upstream
     release tag that's atypical, and `5.1.0` is far more useful to a reader of
     `.claude/repo-cache.yaml` than a bare SHA. Readability wins here.
   - `main` (or any branch) → resolve it to its current commit SHA
     (`git ls-remote https://github.com/<org>/<repo>.git main`) and record **the SHA**, not the
     branch name. A branch moves on every commit by design — a far more frequent failure mode than a
     maintained tag being reassigned — so recording the branch name would silently re-resolve to a
     different commit on every future run, defeating the point of pinning.
3. Write `<org/repo>: <VERSION>` into `.claude/repo-cache.yaml` at the project root, creating the
   file if it doesn't exist and updating the entry in place if the key is already present.
4. Clone it immediately (see below) so the project is usable right away rather than deferring the
   fetch to the next `ensure` call.
5. Report the recorded version and the local cache path.

## Cloning a pinned ref

```bash
CACHE_DIR=~/.cache/claude-skills/github-repo-cache/<org>/<repo>/<version>
if [ ! -d "$CACHE_DIR/.git" ]; then
  TMP=$(mktemp -d)
  if ! git clone --quiet --depth 1 --branch "<version>" \
        "https://github.com/<org>/<repo>.git" "$TMP" 2>/dev/null; then
    # <version> isn't a branch or tag name (e.g. a SHA resolved from `main`) — fetch it directly.
    # Every step is chained, so a failure anywhere leaves nothing behind at $CACHE_DIR.
    if ! { git init --quiet "$TMP" \
        && git -C "$TMP" remote add origin "https://github.com/<org>/<repo>.git" \
        && git -C "$TMP" fetch --quiet --depth 1 origin "<version>" \
        && git -C "$TMP" checkout --quiet FETCH_HEAD; }; then
      rm -rf "$TMP"
      echo "Could not retrieve <org>/<repo> at <version>" >&2
      exit 1
    fi
  fi
  mkdir -p "$(dirname "$CACHE_DIR")"
  if [ ! -d "$CACHE_DIR/.git" ]; then
    mv "$TMP" "$CACHE_DIR"
  else
    rm -rf "$TMP"   # another caller already populated it first — discard the redundant clone
  fi
fi
```

Each attempt clones into its own `mktemp -d`, so two concurrent `ensure` calls never race over a
shared temp path. The final move only proceeds if nobody has already populated `$CACHE_DIR`, so this
isn't a fully atomic claim against another writer finishing in between — but the failure mode is at
worst an occasional wasted clone, never a corrupted destination.

If the clone fails outright (network unreachable, ref doesn't exist upstream), report the error
clearly and stop. Do not leave a partial `$CACHE_DIR` behind — an aborted fallback that still got as
far as `git init` would otherwise install a `.git` directory that every later `ensure` call reads as
a populated cache, silently serving an empty repository from then on.

## What this skill does not do

- Does not track "latest" live. Once a version is recorded, it stays pinned until someone runs
  `configure` again — nothing re-resolves it automatically or on a schedule.
- Does not assume a specific consumer. Any skill needing a stable local copy of a GitHub repo can
  delegate to `ensure org/repo`, not just one reference implementation.
- Does not clone anything not hosted on `github.com` — the key format and clone-URL derivation both
  assume GitHub specifically.

Wersje

W bazie nie ma innych skilli o nazwie cache-github-repo.

Migawka bazy z 13.11.2026 · wersja paczki 305249aade43 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100github-multi-repo
    Koordynuje zmiany w wielu repozytoriach GitHub naraz: aktualizacje zależności i bezpieczeństwa w organizacji, wyrównywanie wersji, refaktoryzacje i wspólne szablony.
  • 100setup
    Konfiguruje komputer do pracy w zespołowym repozytorium GitHub: instaluje git i gh, loguje się i klonuje repozytorium.
  • 100ghsync
    Klonuje hurtowo i synchronizuje wszystkie repozytoria GitHub dostępne w organizacji lub koncie osobistym, usuwa duplikaty, klonuje nowe i aktualizuje istniejące repozytoria razem z ich worktree.
  • 86gh-org-backup
    Pakuje repozytoria GitHub z organizacji lub konta, do których użytkownik ma dostęp, w jedno zip ze wszystkimi gałęziami.
  • 100repo-study
    Bada repozytorium GitHub na wyraźną prośbę użytkownika i przygotowuje raport badawczy.
  • 100librarian
    Przechowuje w pamięci podręcznej i odświeża zdalne repozytoria git w ~/.cache/checkouts, aby przy kolejnych odwołaniach używać lokalnej kopii.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.