Przejdź do treści
Biblioteka skilli
DevOps i chmura · Automatyzacja

release

/release

Prowadzi wydanie repozytorium agent-skills-vrc-udon: synchronizuje gałęzie, podbija pięć pól wersji, scala PR i publikuje paczkę npm.

Licencja
MIT
Ostatnia zmiana repozytorium
11.11.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
3
Skrypty
2
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

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

Co sprawdzić przed instalacją
  • 2 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/bump-version.sh, scripts/sync-main-into-dev.sh

Co robi i kiedy

Prowadzi wydanie repozytorium agent-skills-vrc-udon: synchronizuje gałęzie, podbija pięć pól wersji, scala PR i publikuje paczkę npm.

Oryginalny opis (EN)

Release procedure for agent-skills-vrc-udon: sync main into dev, bump the five version fields, open and merge the release PR, rewrite the Release Drafter notes, and publish to npm. Use when asked to cut, prepare, or publish a release, to bump the version, or to sync main into dev. Maintainer-only; not distributed.

Jak działa

  1. Step 1: Synchronize main into dev when needed
  2. Step 2: Bump the version fields on dev
  3. Step 3: Create the release PR from dev to main
  4. Step 4: Merge the release PR
  5. Step 5: Publish the GitHub Release draft
  6. Version resolution (label-driven)
  7. What NOT to do
Sekcje z nagłówków SKILL.md, w oryginale · 119 linii, 1 024 słów
Podgląd SKILL.md
---
name: release
description: >-
    Release procedure for agent-skills-vrc-udon: sync main into dev, bump the five version fields,
    open and merge the release PR, rewrite the Release Drafter notes, and publish to npm. Use when
    asked to cut, prepare, or publish a release, to bump the version, or to sync main into dev.
    Maintainer-only; not distributed.
metadata:
    internal: true
---

# Release

```
main ──sync PR──> dev (when the ancestry check fails)
dev ──version-bump PR──> dev ──release PR──> main ──Release Drafter draft──> publish ──> npm
```

GitHub Release notes are drafted by Release Drafter, and GitHub Releases are the canonical release history. `CHANGELOG.md` is a historical archive through v1.2.0; later releases are not backfilled.

Version numbers must be bumped by hand on `dev` before the release PR is opened (Step 2). `publish.yml` does run `npm version "$VERSION" --no-git-tag-version` in the CI runner as a safety net, but those edits are not committed back, so the git tree has to be kept current by hand.

## Step 1: Synchronize `main` into `dev` when needed

```bash
bash .claude/skills/release/scripts/sync-main-into-dev.sh
```

The script fetches both branches and checks that `dev` contains the current `main` history. If it does not, it opens a sync PR from a new `chore/sync-main-into-dev-<timestamp>` branch, waits for the seven required checks (Symlink Integrity, Hook Scripts, Documentation Smoke Tests, Markdown Links, npm Pack Test, EditorConfig, Version Sync), merges with a merge commit, and repeats the ancestry check. Do not continue until that final check succeeds.

## Step 2: Bump the version fields on `dev`

Decide the target version vX.Y.Z from the labels on the PRs merged into `dev` since the last release (see [Version resolution](#version-resolution-label-driven)). From this point until the release PR is merged, merge nothing else into `dev`. If another PR does land, resolve the version again before continuing. Then:

```bash
set -e   # stop at the first failing command
git checkout dev && git pull
git checkout -b chore/release-vX.Y.Z

bash .claude/skills/release/scripts/bump-version.sh X.Y.Z

git commit -am "chore(version): bump to vX.Y.Z"
git push -u origin chore/release-vX.Y.Z
gh pr create --base dev --label "release: maintenance" \
  --title "chore(version): bump to vX.Y.Z" \
  --body "Pre-release version bump for Step 3 of the release flow."
```

The script moves these five fields together and stops unless exactly those five lines changed:

- `package.json` → `.version`
- `.claude-plugin/marketplace.json` → `.metadata.version`
- `skills/unity-vrc-udon-sharp/SKILL.md` → frontmatter `metadata.version`
- `skills/unity-vrc-world-sdk-3/SKILL.md` → frontmatter `metadata.version`
- `.claude/skills/unity-vrc-skills-renovator/SKILL.md` → frontmatter `metadata.version`

Wait for all seven required CI checks. Version Sync verifies that the five fields agree. Merge the bump PR into `dev` (squash is fine here; it is a single-purpose commit). CodeRabbit review is optional on this PR.

## Step 3: Create the release PR from `dev` to `main`

```bash
gh pr create --base main --head dev \
  --title "Release vX.Y.Z" \
  --body "Merge dev into main for release"
```

The title must include the version that matches `package.json#version` on `dev` after Step 2. The body can follow `.github/PULL_REQUEST_TEMPLATE/release.md`. Wait for CI to pass. CodeRabbit approval is not required for release PRs: they are mechanical merges of commits that were already reviewed.

## Step 4: Merge the release PR

Merge with a merge commit. Do NOT squash: Release Drafter needs each underlying PR commit. The merge triggers Release Drafter to update the draft release on `main`.

## Step 5: Publish the GitHub Release draft

```bash
# List draft releases
gh release list --exclude-drafts=false

# Rewrite the auto-generated notes, then publish
gh release edit vX.Y.Z --notes "$(cat <<'NOTES'
## What's New in vX.Y.Z
...

## vX.Y.Z の変更点
...
NOTES
)"

# Publishing triggers publish.yml → npm publish
gh release edit vX.Y.Z --draft=false
```

Always rewrite the notes before publishing:

- Remove the "Release vX.Y.Z (#N)" self-reference line.
- Replace bare PR titles with user-facing prose.
- Use a bilingual structure: English release notes first, then a Japanese version of the same user-facing content.
- Add a contributor acknowledgement section when a bundled PR closed an externally reported Issue. Name the Issue number and the reporter, keep it respectful, and mirror the reporter's language when possible.

The `published` event triggers `publish.yml`, which validates the tag, runs `npm version "$VERSION" --allow-same-version` (a no-op when Step 2 was done), syncs `SKILL.md` and `marketplace.json` again as a safety net, and runs `npm publish`. It authenticates with npm trusted publishing (OIDC) instead of a stored token, runs in the `npm-publish` environment, and npm adds provenance automatically.

If the Publish step fails with an authentication error (`ENEEDAUTH`, `E401`, or `E404` on `PUT`), check the trusted publisher on npmjs.com (package Settings, Trusted Publisher). Every field is case-sensitive and npm does not validate them on save: user `niaka3dayo`, repository `agent-skills-vrc-udon`, workflow filename `publish.yml`, environment `npm-publish`, and `npm publish` allowed (not only `npm stage publish`). Also confirm the job still has `id-token: write` and the workflow still uses Node 24 or later (npm 11.5.1 or later). After correcting the configuration, re-run the failed Publish job from the Actions tab; do not create a second release.

A newly created trusted publisher expires unless the first publish succeeds within two days, so create or recreate one right before a release, not in advance.

Afterwards, `npm view agent-skills-vrc-udon version` should return the new version.

## Version resolution (label-driven)

Count the labels on the PRs merged into `dev` since the last release:

| Label | Bump |
|-------|------|
| `release: breaking` | major |
| `release: feature` | minor |
| `release: fix` | patch |
| `release: docs` | patch |
| `release: maintenance` | patch |

The highest bump wins. If no label matches, default to **patch**. Release Drafter resolves the same labels for the draft body, so the draft and `package.json` agree as long as the manual bump matches.

## What NOT to do

- Do NOT skip Step 2. `publish.yml` changes the version only inside the runner and does not commit it back, so a missed bump leaves the git tree frozen. Version Sync passes when all five fields agree on the wrong value; this drifted for five release cycles before it was caught (PR #169).
- Do NOT create tags manually. Release Drafter creates the tag when the release is published.
- Do NOT delete a release or a tag. Published versions may be referenced by tag (`git clone --branch vX.Y.Z`), and deleting a tag breaks every user who pinned it (Issue #290).
- Do NOT push directly to `dev` or `main`. Branch protection blocks it; use the PR flows above.
- Do NOT merge feature branches directly to `main`. Always go through `dev`.
Pliki w paczce (3)
  • SKILL.md 7 KB
  • scripts/bump-version.sh 2 KB
  • scripts/sync-main-into-dev.sh 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · niaka3dayo/agent-skills-vrc-udon100MIT
josephfung/curia100MIT
max-sixty/worktrunk100MIT
gtapps/hermitd100MIT
gtapps/hermitd100MIT
anthony-chaudhary/fak100Apache-2.0
tractorjuice/arc-kit100MIT
drvoss/everything-copilot-cli100MIT
sma1lboy/rove100MIT

Migawka bazy z 13.11.2026 · wersja paczki 82823bdbd588 (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

  • 100publish
    Przygotowuje podbicie wersji przez gałąź funkcji i pull request, a scalenie do main automatycznie taguje i publikuje wydanie.
  • 100publish-npm-version
    Wydaje kolejną wersję minor Prisma Next: podbija wersję w root package.json i pakietach workspace oraz otwiera PR, po którego scaleniu workflow publikuje wersję w npm i GitHub Release.
  • 100publish
    Publikuje pakiet Pythona Octop: tworzy gałąź wydania z develop, podbija wersję, aktualizuje CHANGELOG i otwiera PR do main, a po scaleniu tag uruchamia publikację w PyPI i Docker Hub.
  • 100nf-core-pipeline-release
    Przeprowadza pełną procedurę wydania pipeline'u nf-core: kontrole przed wydaniem, podbicie wersji, CHANGELOG i PR z dev do main.
  • 91nacl-tl-release
    Prowadzi wydanie: scala zweryfikowane PR, czeka na CI produkcji, sprawdza zdrowie systemu, podbija wersję i tworzy tag.
  • 100nvidia-nemoclaw-maintainer-cut-release-tag
    Wydaje nową wersję semver: podbija numery wersji skryptem bump-version.ts, otwiera pull request wydania, a po scaleniu taguje main i wypycha tag.

Uwagi i zgłoszenia

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