github-release-management

GitHub Release Management Skill

Intelligent release automation and orchestration using AI swarms for comprehensive software releases - from changelog generation to multi-platform deployment with rollback capabilities.

Quick Start

Simple Release Flow

# Plan and create a release
gh release create v2.0.0 \
  --draft \
  --generate-notes \
  --title "Release v2.0.0"

# Orchestrate with swarm
npx claude-flow github release-create \
  --version "2.0.0" \
  --build-artifacts \
  --deploy-targets "npm,docker,github"

Full Automated Release

# Initialize release swarm
npx claude-flow swarm init --topology hierarchical

# Execute complete release pipeline
npx claude-flow sparc pipeline "Release v2.0.0 with full validation"

---

Core Capabilities

1. Release Planning & Version Management

• Semantic version analysis and suggestion
• Breaking change detection from commits
• Release timeline generation
• Multi-package version coordination

2. Automated Testing & Validation

• Multi-stage test orchestration
• Cross-platform compatibility testing
• Performance regression detection
• Security vulnerability scanning

3. Build & Deployment Orchestration

• Multi-platform build coordination
• Parallel artifact generation
• Progressive deployment strategies
• Automated rollback mechanisms

4. Documentation & Communication

• Automated changelog generation
• Release notes with categorization
• Migration guide creation
• Stakeholder notification

---

Progressive Disclosure: Level 1 - Basic Usage

Essential Release Commands

Create Release Draft

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

# Generate changelog from commits
CHANGELOG=$(gh api repos/:owner/:repo$compare/${LAST_TAG}...HEAD \
  --jq '.commits[].commit.message')

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

Basic Version Bump

# Update package.json version
npm version patch  # or minor, major

# Push version tag
git push --follow-tags

Simple Deployment

# Build and publish npm package
npm run build
npm publish

# Create GitHub release
gh release create $(npm pkg get version) \
  --generate-notes

Quick Integration Example

// Simple release preparation in Claude Code
[Single Message]:
  // Update version files
  Edit("package.json", { old: '"version": "1.0.0"', new: '"version": "2.0.0"' })

  // Generate changelog
  Bash("gh api repos/:owner/:repo$compare$v1.0.0...HEAD --jq '.commits[].commit.message' > CHANGELOG.md")

  // Create release branch
  Bash("git checkout -b release$v2.0.0")
  Bash("git add -A && git commit -m 'release: Prepare v2.0.0'")

  // Create PR
  Bash("gh pr create --title 'Release v2.0.0' --body 'Automated release preparation'")

---

Progressive Disclosure: Level 2 - Swarm Coordination

AI Swarm Release Orchestration

Initialize Release Swarm

// Set up coordinated release team
[Single Message - Swarm Initialization]:
  mcp__claude-flow__swarm_init {
    topology: "hierarchical",
    maxAgents: 6,
    strategy: "balanced"
  }

  // Spawn specialized agents
  mcp__claude-flow__agent_spawn { type: "coordinator", name: "Release Director" }
  mcp__claude-flow__agent_spawn { type: "coder", name: "Version Manager" }
  mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }
  mcp__claude-flow__agent_spawn { type: "reviewer", name: "Release Reviewer" }
  mcp__claude-flow__agent_spawn { type: "analyst", name: "Deployment Analyst" }
  mcp__claude-flow__agent_spawn { type: "researcher", name: "Compatibility Checker" }

Coordinated Release Workflow

[Single Message - Full Release Coordination]:
  // Create release branch
  Bash("gh api repos/:owner/:repo$git$refs --method POST -f ref='refs$heads$release$v2.0.0' -f sha=$(gh api repos/:owner/:repo$git$refs$heads$main --jq '.object.sha')")

  // Orchestrate release preparation
  mcp__claude-flow__task_orchestrate {
    task: "Prepare release v2.0.0 with comprehensive testing and validation",
    strategy: "sequential",
    priority: "critical",
    maxAgents: 6
  }

  // Update all release files
  Write("package.json", "[updated version]")
  Write("CHANGELOG.md", "[release changelog]")
  Write("RELEASE_NOTES.md", "[detailed notes]")

  // Run comprehensive validation
  Bash("npm install && npm test && npm run lint && npm run build")

  // Create release PR
  Bash(`gh pr create \
    --title "Release v2.0.0: Feature Set and Improvements" \
    --head "release$v2.0.0" \
    --base "main" \
    --body "$(cat RELEASE_NOTES.md)"`)

  // Track progress
  TodoWrite { todos: [
    { content: "Prepare release branch", status: "completed", priority: "critical" },
    { content: "Run validation suite", status: "completed", priority: "high" },
    { content: "Create release PR", status: "completed", priority: "high" },
    { content: "Code review approval", status: "pending", priority: "high" },
    { content: "Merge and deploy", status: "pending", priority: "critical" }
  ]}

  // Store release state
  mcp__claude-flow__memory_usage {
    action: "store",
    key: "release$v2.0.0$status",
    value: JSON.stringify({
      version: "2.0.0",
      stage: "validation_complete",
      timestamp: Date.now(),
      ready_for_review: true
    })
  }

Release Agent Specializations

Changelog Agent

# Get 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 commit history
COMMITS=$(gh api repos/:owner/:repo$compare$v1.0.0...HEAD \
  --jq '.commits[].commit.message')

# Generate categorized changelog
npx claude-flow github changelog \
  --prs "$PRS" \
  --commits "$COMMITS" \
  --from v1.0.0 \
  --to HEAD \
  --categorize \
  --add-migration-guide

Capabilities:

• Semantic commit analysis
• Breaking change detection
• Contributor attribution
• Migration guide generation
• Multi-language support

Version Agent

# Intelligent version suggestion
npx claude-flow github version-suggest \
  --current v1.2.3 \
  --analyze-commits \
  --check-compatibility \
  --suggest-pre-release

Logic:

• Analyzes commit messages and PR labels
• Detects breaking changes via keywords
• Suggests appropriate version bump
• Handles pre-release versioning
• Validates version constraints

Build Agent

# Multi-platform build coordination
npx claude-flow github release-build \
  --platforms "linux,macos,windows" \
  --architectures "x64,arm64" \
  --parallel \
  --optimize-size

Features:

• Cross-platform compilation
• Parallel build execution
• Artifact optimization and compression
• Dependency bundling
• Build caching and reuse

Test Agent

# Comprehensive pre-release testing
npx claude-flow github release-test \
  --suites "unit,integration,e2e,performance" \
  --environments "node:16,node:18,node:20" \
  --fail-fast false \
  --generate-report

Deploy Agent

# Multi-target deployment orchestration
npx claude-flow github release-deploy \
  --targets "npm,docker,github,s3" \
  --staged-rollout \
  --monitor-metrics \
  --auto-rollback

---

Progressive Disclosure: Level 3 - Advanced Workflows

Multi-Package Release Coordination

Monorepo Release Strategy

[Single Message - Multi-Package Release]:
  // Initialize mesh topology for cross-package coordination
  mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 8 }

  // Spawn package-specific agents
  Task("Package A Manager", "Coordinate claude-flow package release v1.0.72", "coder")
  Task("Package B Manager", "Coordinate ruv-swarm package release v1.0.12", "coder")
  Task("Integration Tester", "Validate cross-package compatibility", "tester")
  Task("Version Coordinator", "Align dependencies and versions", "coordinator")

  // Update all packages simultaneously
  Write("packages$claude-flow$package.json", "[v1.0.72 content]")
  Write("packages$ruv-swarm$package.json", "[v1.0.12 content]")
  Write("CHANGELOG.md", "[consolidated changelog]")

  // Run cross-package validation
  Bash("cd packages$claude-flow && npm install && npm test")
  Bash("cd packages$ruv-swarm && npm install && npm test")
  Bash("npm run test:integration")

  // Create unified release PR
  Bash(`gh pr create \
    --title "Release: claude-flow v1.0.72, ruv-swarm v1.0.12" \
    --body "Multi-package coordinated release with cross-compatibility validation"`)

Progressive Deployment Strategy

Staged Rollout Configuration

# .github$release-deployment.yml
deployment:
  strategy: progressive
  stages:
    - name: canary
      percentage: 5
      duration: 1h
      metrics:
        - error-rate < 0.1%
        - latency-p99 < 200ms
      auto-advance: true

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

    - name: rollout
      percentage: 50
      duration: 8h
      monitor: true

    - name: full
      percentage: 100
      approval: release-manager
      rollback-enabled: true

Execute Staged Deployment

# Deploy with progressive rollout
npx claude-flow github release-deploy \
  --version v2.0.0 \
  --strategy progressive \
  --config .github$release-deployment.yml \
  --monitor-metrics \
  --auto-rollback-on-error

Multi-Repository Coordination

Coordinated Multi-Repo Release

# Synchronize releases across repositories
npx claude-flow github multi-release \
  --repos "frontend:v2.0.0,backend:v2.1.0,cli:v1.5.0" \
  --ensure-compatibility \
  --atomic-release \
  --synchronized \
  --rollback-all-on-failure

Cross-Repo Dependency Management

[Single Message - Cross-Repo 

---

*Content truncated.*