Claude Skill

github-release-management

Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management

LLM Mart · 0 points · 2 views 31 listing impressions 0 install-command copies

#deployment #automation

Download spencermarx-open-code-review-.claude_skills_github-release-management-a793b05.zip · 9 KB

Install

skills CLI npx skills add https://github.com/spencermarx/open-code-review/tree/main/.claude/skills/github-release-management
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install spencermarx-open-code-review@llmmart
Git git clone https://github.com/spencermarx/open-code-review.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole spencermarx/open-code-review collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

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 Release]:
  // Initialize star topology for centralized coordination
  mcp__claude-flow__swarm_init { topology: "star", maxAgents: 6 }

  // Spawn repo-specific coordinators
  Task("Frontend Release", "Release frontend v2.0.0 with API compatibility", "coordinator")
  Task("Backend Release", "Release backend v2.1.0 with breaking changes", "coordinator")
  Task("CLI Release", "Release CLI v1.5.0 with new commands", "coordinator")
  Task("Compatibility Checker", "Validate cross-repo compatibility", "researcher")

  // Coordinate version updates across repos
  Bash("gh api repos/org/frontend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.0.0")
  Bash("gh api repos/org/backend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.1.0")
  Bash("gh api repos/org/cli/dispatches --method POST -f event_type='release' -F client_payload[version]=v1.5.0")

  // Monitor all releases
  mcp__claude-flow__swarm_monitor { interval: 5, duration: 300 }

Hotfix Emergency Procedures

Emergency Hotfix Workflow

# Fast-track critical bug fix
npx claude-flow github emergency-release \
  --issue 789 \
  --severity critical \
  --target-version v1.2.4 \
  --cherry-pick-commits \
  --bypass-checks security-only \
  --fast-track \
  --notify-all

Automated Hotfix Process

[Single Message - Emergency Hotfix]:
  // Create hotfix branch from last stable release
  Bash("git checkout -b hotfix/v1.2.4 v1.2.3")

  // Cherry-pick critical fixes
  Bash("git cherry-pick abc123def")

  // Fast validation
  Bash("npm run test:critical && npm run build")

  // Create emergency release
  Bash(`gh release create v1.2.4 \
    --title "HOTFIX v1.2.4: Critical Security Patch" \
    --notes "Emergency release addressing CVE-2024-XXXX" \
    --prerelease=false`)

  // Immediate deployment
  Bash("npm publish --tag hotfix")

  // Notify stakeholders
  Bash(`gh issue create \
    --title "🚨 HOTFIX v1.2.4 Deployed" \
    --body "Critical security patch deployed. Please update immediately." \
    --label "critical,security,hotfix"`)

Progressive Disclosure: Level 4 - Enterprise Features

Release Configuration Management

Comprehensive Release Config

# .github/release-swarm.yml
version: 2.0.0

release:
  versioning:
    strategy: semantic
    breaking-keywords: ["BREAKING", "BREAKING CHANGE", "!"]
    feature-keywords: ["feat", "feature"]
    fix-keywords: ["fix", "bugfix"]

  changelog:
    sections:
      - title: "🚀 Features"
        labels: ["feature", "enhancement"]
        emoji: true
      - title: "🐛 Bug Fixes"
        labels: ["bug", "fix"]
      - title: "💥 Breaking Changes"
        labels: ["breaking"]
        highlight: true
      - title: "📚 Documentation"
        labels: ["docs", "documentation"]
      - title: "⚡ Performance"
        labels: ["performance", "optimization"]
      - title: "🔒 Security"
        labels: ["security"]
        priority: critical

  artifacts:
    - name: npm-package
      build: npm run build
      test: npm run test:all
      publish: npm publish
      registry: https://registry.npmjs.org

    - name: docker-image
      build: docker build -t app:$VERSION .
      test: docker run app:$VERSION npm test
      publish: docker push app:$VERSION
      platforms: [linux/amd64, linux/arm64]

    - name: binaries
      build: ./scripts/build-binaries.sh
      platforms: [linux, macos, windows]
      architectures: [x64, arm64]
      upload: github-release
      sign: true

  validation:
    pre-release:
      - lint: npm run lint
      - typecheck: npm run typecheck
      - unit-tests: npm run test:unit
      - integration-tests: npm run test:integration
      - security-scan: npm audit
      - license-check: npm run license-check

    post-release:
      - smoke-tests: npm run test:smoke
      - deployment-validation: ./scripts/validate-deployment.sh
      - performance-baseline: npm run benchmark

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

      - name: production
        auto-deploy: false
        approval-required: true
        approvers: ["release-manager", "tech-lead"]
        rollback-enabled: true
        health-checks:
          - endpoint: /health
            expected: 200
            timeout: 30s

  monitoring:
    metrics:
      - error-rate: <1%
      - latency-p95: <500ms
      - availability: >99.9%
      - memory-usage: <80%

    alerts:
      - type: slack
        channel: releases
        on: [deploy, rollback, error]
      - type: email
        recipients: ["team@company.com"]
        on: [critical-error, rollback]
      - type: pagerduty
        service: production-releases
        on: [critical-error]

  rollback:
    auto-rollback:
      triggers:
        - error-rate > 5%
        - latency-p99 > 2000ms
        - availability < 99%
      grace-period: 5m

    manual-rollback:
      preserve-data: true
      notify-users: true
      create-incident: true

Advanced Testing Strategies

Comprehensive Validation Suite

# Pre-release validation with all checks
npx claude-flow github release-validate \
  --checks "
    version-conflicts,
    dependency-compatibility,
    api-breaking-changes,
    security-vulnerabilities,
    performance-regression,
    documentation-completeness,
    license-compliance,
    backwards-compatibility
  " \
  --block-on-failure \
  --generate-report \
  --upload-results

Backward Compatibility Testing

# Test against previous versions
npx claude-flow github compat-test \
  --previous-versions "v1.0,v1.1,v1.2" \
  --api-contracts \
  --data-migrations \
  --integration-tests \
  --generate-report

Performance Regression Detection

# Benchmark against baseline
npx claude-flow github performance-test \
  --baseline v1.9.0 \
  --candidate v2.0.0 \
  --metrics "throughput,latency,memory,cpu" \
  --threshold 5% \
  --fail-on-regression

Release Monitoring & Analytics

Real-Time Release Monitoring

# Monitor release health post-deployment
npx claude-flow github release-monitor \
  --version v2.0.0 \
  --metrics "error-rate,latency,throughput,adoption" \
  --alert-thresholds \
  --duration 24h \
  --export-dashboard

Release Analytics & Insights

# Analyze release performance and adoption
npx claude-flow github release-analytics \
  --version v2.0.0 \
  --compare-with v1.9.0 \
  --metrics "adoption,performance,stability,feedback" \
  --generate-insights \
  --export-report

Automated Rollback Configuration

# Configure intelligent auto-rollback
npx claude-flow github rollback-config \
  --triggers '{
    "error-rate": ">5%",
    "latency-p99": ">1000ms",
    "availability": "<99.9%",
    "failed-health-checks": ">3"
  }' \
  --grace-period 5m \
  --notify-on-rollback \
  --preserve-metrics

Security & Compliance

Security Scanning

# Comprehensive security validation
npx claude-flow github release-security \
  --scan-dependencies \
  --check-secrets \
  --audit-permissions \
  --sign-artifacts \
  --sbom-generation \
  --vulnerability-report

Compliance Validation

# Ensure regulatory compliance
npx claude-flow github release-compliance \
  --standards "SOC2,GDPR,HIPAA" \
  --license-audit \
  --data-governance \
  --audit-trail \
  --generate-attestation

GitHub Actions Integration

Complete Release Workflow

# .github/workflows/release.yml
name: Intelligent Release Workflow
on:
  push:
    tags: ['v*']

jobs:
  release-orchestration:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      packages: write
      issues: write

    steps:
      - name: Checkout Repository
        uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
          cache: 'npm'

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

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

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

          # Get commit history
          COMMITS=$(gh api repos/${{ github.repository }}/compare/${PREV_TAG}...HEAD \
            --jq '.commits[].commit.message')

          # Initialize swarm coordination
          npx claude-flow@alpha swarm init --topology hierarchical

          # Store release context
          echo "$PRS" > /tmp/release-prs.json
          echo "$COMMITS" > /tmp/release-commits.txt

      - name: Generate Release Changelog
        run: |
          # Generate intelligent changelog
          CHANGELOG=$(npx claude-flow@alpha github changelog \
            --prs "$(cat /tmp/release-prs.json)" \
            --commits "$(cat /tmp/release-commits.txt)" \
            --from $PREV_TAG \
            --to $RELEASE_TAG \
            --categorize \
            --add-migration-guide \
            --format markdown)

          echo "$CHANGELOG" > RELEASE_CHANGELOG.md

      - name: Build Release Artifacts
        run: |
          # Install dependencies
          npm ci

          # Run comprehensive validation
          npm run lint
          npm run typecheck
          npm run test:all
          npm run build

          # Build platform-specific binaries
          npx claude-flow@alpha github release-build \
            --platforms "linux,macos,windows" \
            --architectures "x64,arm64" \
            --parallel

      - name: Security Scan
        run: |
          # Run security validation
          npm audit --audit-level=moderate

          npx claude-flow@alpha github release-security \
            --scan-dependencies \
            --check-secrets \
            --sign-artifacts

      - name: Create GitHub Release
        run: |
          # Update release with generated changelog
          gh release edit ${{ github.ref_name }} \
            --notes "$(cat RELEASE_CHANGELOG.md)" \
            --draft=false

          # Upload all artifacts
          for file in dist/*; do
            gh release upload ${{ github.ref_name }} "$file"
          done

      - name: Deploy to Package Registries
        run: |
          # Publish to npm
          echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
          npm publish

          # Build and push Docker images
          docker build -t ${{ github.repository }}:${{ github.ref_name }} .
          docker push ${{ github.repository }}:${{ github.ref_name }}

      - name: Post-Release Validation
        run: |
          # Run smoke tests
          npm run test:smoke

          # Validate deployment
          npx claude-flow@alpha github release-validate \
            --version ${{ github.ref_name }} \
            --smoke-tests \
            --health-checks

      - name: Create Release Announcement
        run: |
          # Create announcement issue
          gh issue create \
            --title "🎉 Released ${{ github.ref_name }}" \
            --body "$(cat RELEASE_CHANGELOG.md)" \
            --label "announcement,release"

          # Notify via discussion
          gh api repos/${{ github.repository }}/discussions \
            --method POST \
            -f title="Release ${{ github.ref_name }} Now Available" \
            -f body="$(cat RELEASE_CHANGELOG.md)" \
            -f category_id="$(gh api repos/${{ github.repository }}/discussions/categories --jq '.[] | select(.slug=="announcements") | .id')"

      - name: Monitor Release
        run: |
          # Start release monitoring
          npx claude-flow@alpha github release-monitor \
            --version ${{ github.ref_name }} \
            --duration 1h \
            --alert-on-errors &

Hotfix Workflow

# .github/workflows/hotfix.yml
name: Emergency Hotfix Workflow
on:
  issues:
    types: [labeled]

jobs:
  emergency-hotfix:
    if: contains(github.event.issue.labels.*.name, 'critical-hotfix')
    runs-on: ubuntu-latest

    steps:
      - name: Create Hotfix Branch
        run: |
          LAST_STABLE=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
          HOTFIX_VERSION=$(echo $LAST_STABLE | awk -F. '{print $1"."$2"."$3+1}')

          git checkout -b hotfix/$HOTFIX_VERSION $LAST_STABLE

      - name: Fast-Track Testing
        run: |
          npm ci
          npm run test:critical
          npm run build

      - name: Emergency Release
        run: |
          npx claude-flow@alpha github emergency-release \
            --issue ${{ github.event.issue.number }} \
            --severity critical \
            --fast-track \
            --notify-all

Best Practices & Patterns

Release Planning Guidelines

1. Regular Release Cadence

  • Weekly: Patch releases with bug fixes
  • Bi-weekly: Minor releases with features
  • Quarterly: Major releases with breaking changes
  • On-demand: Hotfixes for critical issues

2. Feature Freeze Strategy

  • Code freeze 3 days before release
  • Only critical bug fixes allowed
  • Beta testing period for major releases
  • Stakeholder communication plan

3. Version Management Rules

  • Strict semantic versioning compliance
  • Breaking changes only in major versions
  • Deprecation warnings one minor version ahead
  • Cross-package version synchronization

Automation Recommendations

1. Comprehensive CI/CD Pipeline

  • Automated testing at every stage
  • Security scanning before release
  • Performance benchmarking
  • Documentation generation

2. Progressive Deployment

  • Canary releases for early detection
  • Staged rollouts with monitoring
  • Automated health checks
  • Quick rollback mechanisms

3. Monitoring & Observability

  • Real-time error tracking
  • Performance metrics collection
  • User adoption analytics
  • Feedback collection automation

Documentation Standards

1. Changelog Requirements

  • Categorized changes by type
  • Breaking changes highlighted
  • Migration guides for major versions
  • Contributor attribution

2. Release Notes Content

  • High-level feature summaries
  • Detailed technical changes
  • Upgrade instructions
  • Known issues and limitations

3. API Documentation

  • Automated API doc generation
  • Example code updates
  • Deprecation notices
  • Version compatibility matrix

Troubleshooting & Common Issues

Issue: Failed Release Build

# Debug build failures
npx claude-flow@alpha diagnostic-run \
  --component build \
  --verbose

# Retry with isolated environment
docker run --rm -v $(pwd):/app node:20 \
  bash -c "cd /app && npm ci && npm run build"

Issue: Test Failures in CI

# Run tests with detailed output
npm run test -- --verbose --coverage

# Check for environment-specific issues
npm run test:ci

# Compare local vs CI environment
npx claude-flow@alpha github compat-test \
  --environments "local,ci" \
  --compare

Issue: Deployment Rollback Needed

# Immediate rollback to previous version
npx claude-flow@alpha github rollback \
  --to-version v1.9.9 \
  --reason "Critical bug in v2.0.0" \
  --preserve-data \
  --notify-users

# Investigate rollback cause
npx claude-flow@alpha github release-analytics \
  --version v2.0.0 \
  --identify-issues

Issue: Version Conflicts

# Check and resolve version conflicts
npx claude-flow@alpha github release-validate \
  --checks version-conflicts \
  --auto-resolve

# Align multi-package versions
npx claude-flow@alpha github version-sync \
  --packages "package-a,package-b" \
  --strategy semantic

Performance Metrics & Benchmarks

Expected Performance

  • Release Planning: < 2 minutes
  • Build Process: 3-8 minutes (varies by project)
  • Test Execution: 5-15 minutes
  • Deployment: 2-5 minutes per target
  • Complete Pipeline: 15-30 minutes

Optimization Tips

  1. Parallel Execution: Use swarm coordination for concurrent tasks
  2. Caching: Enable build and dependency caching
  3. Incremental Builds: Only rebuild changed components
  4. Test Optimization: Run critical tests first, full suite in parallel

Success Metrics

  • Release Frequency: Target weekly minor releases
  • Lead Time: < 2 hours from commit to production
  • Failure Rate: < 2% of releases require rollback
  • MTTR: < 30 minutes for critical hotfixes

Related Resources

Documentation

Related Skills

  • github-pr-management: PR review and merge automation
  • github-workflow-automation: CI/CD workflow orchestration
  • multi-repo-coordination: Cross-repository synchronization
  • deployment-orchestration: Advanced deployment strategies

Support & Community


Appendix: Release Checklist Template

Pre-Release Checklist

  • Version numbers updated across all packages
  • Changelog generated and reviewed
  • Breaking changes documented with migration guide
  • All tests passing (unit, integration, e2e)
  • Security scan completed with no critical issues
  • Performance benchmarks within acceptable range
  • Documentation updated (API docs, README, examples)
  • Release notes drafted and reviewed
  • Stakeholders notified of upcoming release
  • Deployment plan reviewed and approved

Release Checklist

  • Release branch created and validated
  • CI/CD pipeline completed successfully
  • Artifacts built and verified
  • GitHub release created with proper notes
  • Packages published to registries
  • Docker images pushed to container registry
  • Deployment to staging successful
  • Smoke tests passing in staging
  • Production deployment completed
  • Health checks passing

Post-Release Checklist

  • Release announcement published
  • Monitoring dashboards reviewed
  • Error rates within normal range
  • Performance metrics stable
  • User feedback collected
  • Documentation links verified
  • Release retrospective scheduled
  • Next release planning initiated

Version: 2.0.0 Last Updated: 2025-10-19 Maintained By: Claude Flow Team

Files (open-code-review)
  • SKILL.md 28.9 KB
    ---
    name: github-release-management
    version: 2.0.0
    description: Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management
    category: github
    tags: [release, deployment, versioning, automation, ci-cd, swarm, orchestration]
    author: Claude Flow Team
    requires:
      - gh (GitHub CLI)
      - claude-flow
      - ruv-swarm (optional for enhanced coordination)
      - mcp-github (optional for MCP integration)
    dependencies:
      - git
      - npm or yarn
      - node >= 20.0.0
    related_skills:
      - github-pr-management
      - github-issue-tracking
      - github-workflow-automation
      - multi-repo-coordination
    ---
    
    # 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
    ```bash
    # 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
    ```bash
    # 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
    ```bash
    # 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
    ```bash
    # Update package.json version
    npm version patch  # or minor, major
    
    # Push version tag
    git push --follow-tags
    ```
    
    #### Simple Deployment
    ```bash
    # 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
    ```javascript
    // 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
    ```javascript
    // 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
    ```javascript
    [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
    ```bash
    # 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
    ```bash
    # 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
    ```bash
    # 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
    ```bash
    # 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
    ```bash
    # 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
    ```javascript
    [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
    ```yaml
    # .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
    ```bash
    # 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
    ```bash
    # 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
    ```javascript
    [Single Message - Cross-Repo Release]:
      // Initialize star topology for centralized coordination
      mcp__claude-flow__swarm_init { topology: "star", maxAgents: 6 }
    
      // Spawn repo-specific coordinators
      Task("Frontend Release", "Release frontend v2.0.0 with API compatibility", "coordinator")
      Task("Backend Release", "Release backend v2.1.0 with breaking changes", "coordinator")
      Task("CLI Release", "Release CLI v1.5.0 with new commands", "coordinator")
      Task("Compatibility Checker", "Validate cross-repo compatibility", "researcher")
    
      // Coordinate version updates across repos
      Bash("gh api repos/org/frontend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.0.0")
      Bash("gh api repos/org/backend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.1.0")
      Bash("gh api repos/org/cli/dispatches --method POST -f event_type='release' -F client_payload[version]=v1.5.0")
    
      // Monitor all releases
      mcp__claude-flow__swarm_monitor { interval: 5, duration: 300 }
    ```
    
    ### Hotfix Emergency Procedures
    
    #### Emergency Hotfix Workflow
    ```bash
    # Fast-track critical bug fix
    npx claude-flow github emergency-release \
      --issue 789 \
      --severity critical \
      --target-version v1.2.4 \
      --cherry-pick-commits \
      --bypass-checks security-only \
      --fast-track \
      --notify-all
    ```
    
    #### Automated Hotfix Process
    ```javascript
    [Single Message - Emergency Hotfix]:
      // Create hotfix branch from last stable release
      Bash("git checkout -b hotfix/v1.2.4 v1.2.3")
    
      // Cherry-pick critical fixes
      Bash("git cherry-pick abc123def")
    
      // Fast validation
      Bash("npm run test:critical && npm run build")
    
      // Create emergency release
      Bash(`gh release create v1.2.4 \
        --title "HOTFIX v1.2.4: Critical Security Patch" \
        --notes "Emergency release addressing CVE-2024-XXXX" \
        --prerelease=false`)
    
      // Immediate deployment
      Bash("npm publish --tag hotfix")
    
      // Notify stakeholders
      Bash(`gh issue create \
        --title "🚨 HOTFIX v1.2.4 Deployed" \
        --body "Critical security patch deployed. Please update immediately." \
        --label "critical,security,hotfix"`)
    ```
    
    ---
    
    ## Progressive Disclosure: Level 4 - Enterprise Features
    
    ### Release Configuration Management
    
    #### Comprehensive Release Config
    ```yaml
    # .github/release-swarm.yml
    version: 2.0.0
    
    release:
      versioning:
        strategy: semantic
        breaking-keywords: ["BREAKING", "BREAKING CHANGE", "!"]
        feature-keywords: ["feat", "feature"]
        fix-keywords: ["fix", "bugfix"]
    
      changelog:
        sections:
          - title: "🚀 Features"
            labels: ["feature", "enhancement"]
            emoji: true
          - title: "🐛 Bug Fixes"
            labels: ["bug", "fix"]
          - title: "💥 Breaking Changes"
            labels: ["breaking"]
            highlight: true
          - title: "📚 Documentation"
            labels: ["docs", "documentation"]
          - title: "⚡ Performance"
            labels: ["performance", "optimization"]
          - title: "🔒 Security"
            labels: ["security"]
            priority: critical
    
      artifacts:
        - name: npm-package
          build: npm run build
          test: npm run test:all
          publish: npm publish
          registry: https://registry.npmjs.org
    
        - name: docker-image
          build: docker build -t app:$VERSION .
          test: docker run app:$VERSION npm test
          publish: docker push app:$VERSION
          platforms: [linux/amd64, linux/arm64]
    
        - name: binaries
          build: ./scripts/build-binaries.sh
          platforms: [linux, macos, windows]
          architectures: [x64, arm64]
          upload: github-release
          sign: true
    
      validation:
        pre-release:
          - lint: npm run lint
          - typecheck: npm run typecheck
          - unit-tests: npm run test:unit
          - integration-tests: npm run test:integration
          - security-scan: npm audit
          - license-check: npm run license-check
    
        post-release:
          - smoke-tests: npm run test:smoke
          - deployment-validation: ./scripts/validate-deployment.sh
          - performance-baseline: npm run benchmark
    
      deployment:
        environments:
          - name: staging
            auto-deploy: true
            validation: npm run test:e2e
            approval: false
    
          - name: production
            auto-deploy: false
            approval-required: true
            approvers: ["release-manager", "tech-lead"]
            rollback-enabled: true
            health-checks:
              - endpoint: /health
                expected: 200
                timeout: 30s
    
      monitoring:
        metrics:
          - error-rate: <1%
          - latency-p95: <500ms
          - availability: >99.9%
          - memory-usage: <80%
    
        alerts:
          - type: slack
            channel: releases
            on: [deploy, rollback, error]
          - type: email
            recipients: ["team@company.com"]
            on: [critical-error, rollback]
          - type: pagerduty
            service: production-releases
            on: [critical-error]
    
      rollback:
        auto-rollback:
          triggers:
            - error-rate > 5%
            - latency-p99 > 2000ms
            - availability < 99%
          grace-period: 5m
    
        manual-rollback:
          preserve-data: true
          notify-users: true
          create-incident: true
    ```
    
    ### Advanced Testing Strategies
    
    #### Comprehensive Validation Suite
    ```bash
    # Pre-release validation with all checks
    npx claude-flow github release-validate \
      --checks "
        version-conflicts,
        dependency-compatibility,
        api-breaking-changes,
        security-vulnerabilities,
        performance-regression,
        documentation-completeness,
        license-compliance,
        backwards-compatibility
      " \
      --block-on-failure \
      --generate-report \
      --upload-results
    ```
    
    #### Backward Compatibility Testing
    ```bash
    # Test against previous versions
    npx claude-flow github compat-test \
      --previous-versions "v1.0,v1.1,v1.2" \
      --api-contracts \
      --data-migrations \
      --integration-tests \
      --generate-report
    ```
    
    #### Performance Regression Detection
    ```bash
    # Benchmark against baseline
    npx claude-flow github performance-test \
      --baseline v1.9.0 \
      --candidate v2.0.0 \
      --metrics "throughput,latency,memory,cpu" \
      --threshold 5% \
      --fail-on-regression
    ```
    
    ### Release Monitoring & Analytics
    
    #### Real-Time Release Monitoring
    ```bash
    # Monitor release health post-deployment
    npx claude-flow github release-monitor \
      --version v2.0.0 \
      --metrics "error-rate,latency,throughput,adoption" \
      --alert-thresholds \
      --duration 24h \
      --export-dashboard
    ```
    
    #### Release Analytics & Insights
    ```bash
    # Analyze release performance and adoption
    npx claude-flow github release-analytics \
      --version v2.0.0 \
      --compare-with v1.9.0 \
      --metrics "adoption,performance,stability,feedback" \
      --generate-insights \
      --export-report
    ```
    
    #### Automated Rollback Configuration
    ```bash
    # Configure intelligent auto-rollback
    npx claude-flow github rollback-config \
      --triggers '{
        "error-rate": ">5%",
        "latency-p99": ">1000ms",
        "availability": "<99.9%",
        "failed-health-checks": ">3"
      }' \
      --grace-period 5m \
      --notify-on-rollback \
      --preserve-metrics
    ```
    
    ### Security & Compliance
    
    #### Security Scanning
    ```bash
    # Comprehensive security validation
    npx claude-flow github release-security \
      --scan-dependencies \
      --check-secrets \
      --audit-permissions \
      --sign-artifacts \
      --sbom-generation \
      --vulnerability-report
    ```
    
    #### Compliance Validation
    ```bash
    # Ensure regulatory compliance
    npx claude-flow github release-compliance \
      --standards "SOC2,GDPR,HIPAA" \
      --license-audit \
      --data-governance \
      --audit-trail \
      --generate-attestation
    ```
    
    ---
    
    ## GitHub Actions Integration
    
    ### Complete Release Workflow
    ```yaml
    # .github/workflows/release.yml
    name: Intelligent Release Workflow
    on:
      push:
        tags: ['v*']
    
    jobs:
      release-orchestration:
        runs-on: ubuntu-latest
        permissions:
          contents: write
          packages: write
          issues: write
    
        steps:
          - name: Checkout Repository
            uses: actions/checkout@v3
            with:
              fetch-depth: 0
    
          - name: Setup Node.js
            uses: actions/setup-node@v3
            with:
              node-version: '20'
              cache: 'npm'
    
          - name: Authenticate GitHub CLI
            run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
    
          - name: Initialize Release Swarm
            run: |
              # Extract version from tag
              RELEASE_TAG=${{ github.ref_name }}
              PREV_TAG=$(gh release list --limit 2 --json tagName -q '.[1].tagName')
    
              # Get merged PRs for changelog
              PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \
                --jq ".[] | select(.mergedAt > \"$(gh release view $PREV_TAG --json publishedAt -q .publishedAt)\")")
    
              # Get commit history
              COMMITS=$(gh api repos/${{ github.repository }}/compare/${PREV_TAG}...HEAD \
                --jq '.commits[].commit.message')
    
              # Initialize swarm coordination
              npx claude-flow@alpha swarm init --topology hierarchical
    
              # Store release context
              echo "$PRS" > /tmp/release-prs.json
              echo "$COMMITS" > /tmp/release-commits.txt
    
          - name: Generate Release Changelog
            run: |
              # Generate intelligent changelog
              CHANGELOG=$(npx claude-flow@alpha github changelog \
                --prs "$(cat /tmp/release-prs.json)" \
                --commits "$(cat /tmp/release-commits.txt)" \
                --from $PREV_TAG \
                --to $RELEASE_TAG \
                --categorize \
                --add-migration-guide \
                --format markdown)
    
              echo "$CHANGELOG" > RELEASE_CHANGELOG.md
    
          - name: Build Release Artifacts
            run: |
              # Install dependencies
              npm ci
    
              # Run comprehensive validation
              npm run lint
              npm run typecheck
              npm run test:all
              npm run build
    
              # Build platform-specific binaries
              npx claude-flow@alpha github release-build \
                --platforms "linux,macos,windows" \
                --architectures "x64,arm64" \
                --parallel
    
          - name: Security Scan
            run: |
              # Run security validation
              npm audit --audit-level=moderate
    
              npx claude-flow@alpha github release-security \
                --scan-dependencies \
                --check-secrets \
                --sign-artifacts
    
          - name: Create GitHub Release
            run: |
              # Update release with generated changelog
              gh release edit ${{ github.ref_name }} \
                --notes "$(cat RELEASE_CHANGELOG.md)" \
                --draft=false
    
              # Upload all artifacts
              for file in dist/*; do
                gh release upload ${{ github.ref_name }} "$file"
              done
    
          - name: Deploy to Package Registries
            run: |
              # Publish to npm
              echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
              npm publish
    
              # Build and push Docker images
              docker build -t ${{ github.repository }}:${{ github.ref_name }} .
              docker push ${{ github.repository }}:${{ github.ref_name }}
    
          - name: Post-Release Validation
            run: |
              # Run smoke tests
              npm run test:smoke
    
              # Validate deployment
              npx claude-flow@alpha github release-validate \
                --version ${{ github.ref_name }} \
                --smoke-tests \
                --health-checks
    
          - name: Create Release Announcement
            run: |
              # Create announcement issue
              gh issue create \
                --title "🎉 Released ${{ github.ref_name }}" \
                --body "$(cat RELEASE_CHANGELOG.md)" \
                --label "announcement,release"
    
              # Notify via discussion
              gh api repos/${{ github.repository }}/discussions \
                --method POST \
                -f title="Release ${{ github.ref_name }} Now Available" \
                -f body="$(cat RELEASE_CHANGELOG.md)" \
                -f category_id="$(gh api repos/${{ github.repository }}/discussions/categories --jq '.[] | select(.slug=="announcements") | .id')"
    
          - name: Monitor Release
            run: |
              # Start release monitoring
              npx claude-flow@alpha github release-monitor \
                --version ${{ github.ref_name }} \
                --duration 1h \
                --alert-on-errors &
    ```
    
    ### Hotfix Workflow
    ```yaml
    # .github/workflows/hotfix.yml
    name: Emergency Hotfix Workflow
    on:
      issues:
        types: [labeled]
    
    jobs:
      emergency-hotfix:
        if: contains(github.event.issue.labels.*.name, 'critical-hotfix')
        runs-on: ubuntu-latest
    
        steps:
          - name: Create Hotfix Branch
            run: |
              LAST_STABLE=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
              HOTFIX_VERSION=$(echo $LAST_STABLE | awk -F. '{print $1"."$2"."$3+1}')
    
              git checkout -b hotfix/$HOTFIX_VERSION $LAST_STABLE
    
          - name: Fast-Track Testing
            run: |
              npm ci
              npm run test:critical
              npm run build
    
          - name: Emergency Release
            run: |
              npx claude-flow@alpha github emergency-release \
                --issue ${{ github.event.issue.number }} \
                --severity critical \
                --fast-track \
                --notify-all
    ```
    
    ---
    
    ## Best Practices & Patterns
    
    ### Release Planning Guidelines
    
    #### 1. Regular Release Cadence
    - **Weekly**: Patch releases with bug fixes
    - **Bi-weekly**: Minor releases with features
    - **Quarterly**: Major releases with breaking changes
    - **On-demand**: Hotfixes for critical issues
    
    #### 2. Feature Freeze Strategy
    - Code freeze 3 days before release
    - Only critical bug fixes allowed
    - Beta testing period for major releases
    - Stakeholder communication plan
    
    #### 3. Version Management Rules
    - Strict semantic versioning compliance
    - Breaking changes only in major versions
    - Deprecation warnings one minor version ahead
    - Cross-package version synchronization
    
    ### Automation Recommendations
    
    #### 1. Comprehensive CI/CD Pipeline
    - Automated testing at every stage
    - Security scanning before release
    - Performance benchmarking
    - Documentation generation
    
    #### 2. Progressive Deployment
    - Canary releases for early detection
    - Staged rollouts with monitoring
    - Automated health checks
    - Quick rollback mechanisms
    
    #### 3. Monitoring & Observability
    - Real-time error tracking
    - Performance metrics collection
    - User adoption analytics
    - Feedback collection automation
    
    ### Documentation Standards
    
    #### 1. Changelog Requirements
    - Categorized changes by type
    - Breaking changes highlighted
    - Migration guides for major versions
    - Contributor attribution
    
    #### 2. Release Notes Content
    - High-level feature summaries
    - Detailed technical changes
    - Upgrade instructions
    - Known issues and limitations
    
    #### 3. API Documentation
    - Automated API doc generation
    - Example code updates
    - Deprecation notices
    - Version compatibility matrix
    
    ---
    
    ## Troubleshooting & Common Issues
    
    ### Issue: Failed Release Build
    ```bash
    # Debug build failures
    npx claude-flow@alpha diagnostic-run \
      --component build \
      --verbose
    
    # Retry with isolated environment
    docker run --rm -v $(pwd):/app node:20 \
      bash -c "cd /app && npm ci && npm run build"
    ```
    
    ### Issue: Test Failures in CI
    ```bash
    # Run tests with detailed output
    npm run test -- --verbose --coverage
    
    # Check for environment-specific issues
    npm run test:ci
    
    # Compare local vs CI environment
    npx claude-flow@alpha github compat-test \
      --environments "local,ci" \
      --compare
    ```
    
    ### Issue: Deployment Rollback Needed
    ```bash
    # Immediate rollback to previous version
    npx claude-flow@alpha github rollback \
      --to-version v1.9.9 \
      --reason "Critical bug in v2.0.0" \
      --preserve-data \
      --notify-users
    
    # Investigate rollback cause
    npx claude-flow@alpha github release-analytics \
      --version v2.0.0 \
      --identify-issues
    ```
    
    ### Issue: Version Conflicts
    ```bash
    # Check and resolve version conflicts
    npx claude-flow@alpha github release-validate \
      --checks version-conflicts \
      --auto-resolve
    
    # Align multi-package versions
    npx claude-flow@alpha github version-sync \
      --packages "package-a,package-b" \
      --strategy semantic
    ```
    
    ---
    
    ## Performance Metrics & Benchmarks
    
    ### Expected Performance
    - **Release Planning**: < 2 minutes
    - **Build Process**: 3-8 minutes (varies by project)
    - **Test Execution**: 5-15 minutes
    - **Deployment**: 2-5 minutes per target
    - **Complete Pipeline**: 15-30 minutes
    
    ### Optimization Tips
    1. **Parallel Execution**: Use swarm coordination for concurrent tasks
    2. **Caching**: Enable build and dependency caching
    3. **Incremental Builds**: Only rebuild changed components
    4. **Test Optimization**: Run critical tests first, full suite in parallel
    
    ### Success Metrics
    - **Release Frequency**: Target weekly minor releases
    - **Lead Time**: < 2 hours from commit to production
    - **Failure Rate**: < 2% of releases require rollback
    - **MTTR**: < 30 minutes for critical hotfixes
    
    ---
    
    ## Related Resources
    
    ### Documentation
    - [GitHub CLI Documentation](https://cli.github.com/manual/)
    - [Semantic Versioning Spec](https://semver.org/)
    - [Claude Flow SPARC Guide](../../docs/sparc-methodology.md)
    - [Swarm Coordination Patterns](../../docs/swarm-patterns.md)
    
    ### Related Skills
    - **github-pr-management**: PR review and merge automation
    - **github-workflow-automation**: CI/CD workflow orchestration
    - **multi-repo-coordination**: Cross-repository synchronization
    - **deployment-orchestration**: Advanced deployment strategies
    
    ### Support & Community
    - Issues: https://github.com/ruvnet/claude-flow/issues
    - Discussions: https://github.com/ruvnet/claude-flow/discussions
    - Documentation: https://claude-flow.dev/docs
    
    ---
    
    ## Appendix: Release Checklist Template
    
    ### Pre-Release Checklist
    - [ ] Version numbers updated across all packages
    - [ ] Changelog generated and reviewed
    - [ ] Breaking changes documented with migration guide
    - [ ] All tests passing (unit, integration, e2e)
    - [ ] Security scan completed with no critical issues
    - [ ] Performance benchmarks within acceptable range
    - [ ] Documentation updated (API docs, README, examples)
    - [ ] Release notes drafted and reviewed
    - [ ] Stakeholders notified of upcoming release
    - [ ] Deployment plan reviewed and approved
    
    ### Release Checklist
    - [ ] Release branch created and validated
    - [ ] CI/CD pipeline completed successfully
    - [ ] Artifacts built and verified
    - [ ] GitHub release created with proper notes
    - [ ] Packages published to registries
    - [ ] Docker images pushed to container registry
    - [ ] Deployment to staging successful
    - [ ] Smoke tests passing in staging
    - [ ] Production deployment completed
    - [ ] Health checks passing
    
    ### Post-Release Checklist
    - [ ] Release announcement published
    - [ ] Monitoring dashboards reviewed
    - [ ] Error rates within normal range
    - [ ] Performance metrics stable
    - [ ] User feedback collected
    - [ ] Documentation links verified
    - [ ] Release retrospective scheduled
    - [ ] Next release planning initiated
    
    ---
    
    **Version**: 2.0.0
    **Last Updated**: 2025-10-19
    **Maintained By**: Claude Flow Team
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.