GitHub Release Swarm Skill

GitHub Release Swarm Skill

Overview

Orchestrate complex software releases using AI swarms. This skill handles release planning, automated versioning, changelog generation, artifact building, progressive deployment, and multi-repo release coordination.

Quick Start

# Get last release tag
LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')

# Get commits since last release
gh api repos/​owner/​repo/​compare/​${LAST_TAG}...HEAD --jq '.commits[].commit.message'

# Get merged PRs since last release
gh pr list --state merged --base main --json number,title,labels,mergedAt

# Create release
gh release create v2.0.0 --title "Release v2.0.0" --notes "..."

When to Use

• Planning and coordinating major releases
• Automated changelog generation
• Multi-platform artifact building
• Progressive deployment strategies
• Multi-repository release coordination
• Hotfix automation

Release Agents

Usage Examples

1. Release Planning

# Get commit history since last release
LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
COMMITS=$(gh api repos/​owner/​repo/​compare/​${LAST_TAG}...HEAD --jq '.commits')

# Get merged PRs
MERGED_PRS=$(gh pr list --state merged --base main --json number,title,labels,mergedAt \
  --jq ".[] | select(.mergedAt > \"$(gh release view $LAST_TAG --json publishedAt -q .publishedAt)\")")

# Plan release with commit analysis
npx ruv-swarm github release-plan \
  --commits "$COMMITS" \
  --merged-prs "$MERGED_PRS" \
  --analyze-commits \
  --suggest-version \
  --identify-breaking \
  --generate-timeline

2. Generate Changelog

# Get all merged PRs between versions
PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \
  --jq ".[] | select(.mergedAt > \"$(gh release view v1.0.0 --json publishedAt -q .publishedAt)\")")

# Get contributors
CONTRIBUTORS=$(echo "$PRS" | jq -r '[.author.login] | unique | join(", ")')

# Get commit messages
COMMITS=$(gh api repos/​owner/​repo/​compare/​v1.0.0...HEAD --jq '.commits[].commit.message')

# Generate categorized changelog
CHANGELOG=$(npx ruv-swarm github changelog \
  --prs "$PRS" \
  --commits "$COMMITS" \
  --contributors "$CONTRIBUTORS" \
  --from v1.0.0 \
  --to HEAD \
  --categorize \
  --add-migration-guide)

echo "$CHANGELOG" > CHANGELOG.md

3. Create Release with Assets

# Generate changelog from PRs and commits
CHANGELOG=$(gh api repos/​owner/​repo/​compare/​${LAST_TAG}...HEAD \
  --jq '.commits[].commit.message' | \
  npx ruv-swarm github generate-changelog)

# Create release draft
gh release create v2.0.0 \
  --draft \
  --title "Release v2.0.0" \
  --notes "$CHANGELOG" \
  --target main

# Build and upload assets
npm run build
gh release upload v2.0.0 dist/​*.tar.gz dist/​*.zip

# Publish release
gh release edit v2.0.0 --draft=false

# Create announcement issue
gh issue create \
  --title "Released v2.0.0" \
  --body "$CHANGELOG" \
  --label "announcement,release"

4. Initialize Release Swarm

// Initialize release swarm
mcp__claude-flow__swarm_init({ topology: "hierarchical", maxAgents: 6 })
mcp__claude-flow__agent_spawn({ type: "coordinator", name: "Release Director" })
mcp__claude-flow__agent_spawn({ type: "coder", name: "Changelog Agent" })
mcp__claude-flow__agent_spawn({ type: "analyst", name: "Version Agent" })
mcp__claude-flow__agent_spawn({ type: "coder", name: "Build Agent" })
mcp__claude-flow__agent_spawn({ type: "tester", name: "Test Agent" })
mcp__claude-flow__agent_spawn({ type: "specialist", name: "Deploy Agent" })

// Orchestrate release
mcp__claude-flow__task_orchestrate({
    task: "Complete release v2.0.0 with changelog, build, test, and deploy",
    strategy: "sequential",
    priority: "critical"
})

5. Multi-Repo Release

# Coordinate releases across repos
REPOS=("frontend:v2.0.0" "backend:v2.1.0" "cli:v1.5.0")

for entry in "${REPOS[@]}"; do
  IFS=':' read -r repo version <<< "$entry"

  # Create release in each repo
  gh release create "$version" \
    --repo "org/​$repo" \
    --title "Release $version" \
    --generate-notes

  echo "Released $repo $version"
done

# Link releases
npx ruv-swarm github multi-release-link \
  --releases "${REPOS[@]}" \
  --create-summary

Release Configuration

# .github/​release-swarm.yml
version: 1
release:
  versioning:
    strategy: semantic
    breaking-keywords: ["BREAKING", "!"]

  changelog:
    sections:
      - title: "Features"
        labels: ["feature", "enhancement"]
      - title: "Bug Fixes"
        labels: ["bug", "fix"]
      - title: "Documentation"
        labels: ["docs", "documentation"]

  artifacts:
    - name: npm-package
      build: npm run build
      publish: npm publish

    - name: docker-image
      build: docker build -t app:$VERSION .
      publish: docker push app:$VERSION

    - name: binaries
      build: ./​scripts/​build-binaries.sh
      upload: github-release

  deployment:
    environments:
      - name: staging
        auto-deploy: true
        validation: npm run test:e2e

      - name: production
        approval-required: true
        rollback-enabled: true

  notifications:
    - slack: releases-channel
    - email: [email protected]

Progressive Deployment

# Staged rollout configuration
deployment:
  strategy: progressive
  stages:
    - name: canary
      percentage: 5
      duration: 1h
      metrics:
        - error-rate < 0.1%
        - latency-p99 < 200ms

    - name: partial
      percentage: 25
      duration: 4h
      validation: automated-tests

    - name: full
      percentage: 100
      approval: required

MCP Tool Integration

Swarm Coordination

mcp__claude-flow__swarm_init({
    topology: "hierarchical",
    maxAgents: 6,
    strategy: "sequential"
})

mcp__claude-flow__parallel_execute({
    tasks: [
        { task: "generate-changelog", agent: "changelog-agent" },
        { task: "build-artifacts", agent: "build-agent" },
        { task: "run-tests", agent: "test-agent" }
    ]
})

mcp__claude-flow__load_balance({
    swarmId: "release-swarm",
    tasks: ["build-linux", "build-macos", "build-windows"]
})

Memory for Release State

mcp__claude-flow__memory_usage({
    action: "store",
    key: "release/​v2.0.0/​state",
    value: JSON.stringify({
        stage: "testing",
        changelog: "generated",
        artifacts: ["npm", "docker"],
        tests: "running"
    })
})

GitHub Actions Workflow

name: Release Workflow
on:
  push:
    tags: ['v*']

jobs:
  release-swarm:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/​checkout@v3
        with:
          fetch-depth: 0

      - name: Setup GitHub CLI
        run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token

      - name: Initialize Release Swarm
        run: |
          RELEASE_TAG=${{ github.ref_name }}
          PREV_TAG=$(gh release list --limit 2 --json tagName -q '.[1].tagName')

          PRS=$(gh pr list --state merged --base main --json number,title,labels,author \
            --search "merged:>=$(gh release view $PREV_TAG --json publishedAt -q .publishedAt)")

          npx ruv-swarm github release-init \
            --tag $RELEASE_TAG \
            --previous-tag $PREV_TAG \
            --prs "$PRS" \
            --spawn-agents "changelog,version,build,test,deploy"

      - name: Generate Release Assets
        run: |
          CHANGELOG=$(npx ruv-swarm github release-changelog --format markdown)
          gh release edit ${{ github.ref_name }} --notes "$CHANGELOG"

          npm run build
          for file in dist/​*; do
            gh release upload ${{ github.ref_name }} "$file"
          done

      - name: Publish Release
        run: |
          npm publish
          gh issue create \
            --title "Released ${{ github.ref_name }}" \
            --body "Release notes at releases page" \
            --label "announcement"

Emergency Procedures

Hotfix Process

# Emergency hotfix
npx ruv-swarm github emergency-release \
  --severity critical \
  --bypass-checks security-only \
  --fast-track \
  --notify-all

Rollback Procedure

# Immediate rollback
npx ruv-swarm github rollback \
  --to-version v1.9.9 \
  --reason "Critical bug in v2.0.0" \
  --preserve-data \
  --notify-users

Best Practices

1. Release Planning

• Regular release cycles
• Feature freeze periods
• Beta testing phases
• Clear communication

2. Automation

• Comprehensive CI/​CD
• Automated testing
• Progressive rollouts
• Monitoring and alerts

3. Documentation

• Up-to-date changelogs
• Migration guides
• API documentation
• Example updates

---

Version History

• 1.0.0 (2025-01-02): Initial release - converted from release-swarm agent