Github Release Management

作者 ruvnet60de638630ab無授權條款74K 個星標收錄於 2026年10月8日更新於 2026年10月8日儲存庫今天更新

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

僅含說明DevOps & Cloud
AI 產生的概覽

編排 GitHub 軟體發佈:版本管理、變更日誌產生、測試、部署與回復。

功能
此技能提供在 GitHub 上執行軟體發佈流程的說明與指令範例,涵蓋語意化版本分析、變更日誌與發佈說明的產生、多平台建置、發佈前驗證、分階段部署與回復。它也說明跨多個套件與儲存庫的協調發佈,以及緊急熱修復流程。它僅為指引內容,不隨附任何指令碼。
適用情境
適用於在 GitHub 上準備、驗證或發佈軟體版本時,包括單一儲存庫多套件或多儲存庫發佈,以及緊急熱修復。適合希望採用結構化、清單式發佈流程(含變更日誌、測試與部署步驟)的團隊。
執行需求
需要已通過驗證並具備儲存庫存取權限的 GitHub CLI(gh)、git,以及用於版本升級、建置與發佈的 Node.js/npm。許多範例透過 npx 呼叫外部 claude-flow CLI 與 MCP 工具,因此使用群體協調工作流程需要網路存取與這些工具。此技能不隨附指令碼,僅為說明文件。

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 releasegh release create v2.0.0 \  --draft \  --generate-notes \  --title "Release v2.0.0"
# Orchestrate with swarmnpx claude-flow github release-create \  --version "2.0.0" \  --build-artifacts \  --deploy-targets "npm,docker,github"

Full Automated Release

bash
# Initialize release swarmnpx claude-flow swarm init --topology hierarchical
# Execute complete release pipelinenpx 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 tagLAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
# Generate changelog from commitsCHANGELOG=$(gh api repos/:owner/:repo/compare/${LAST_TAG}...HEAD \  --jq '.commits[].commit.message')
# Create draft releasegh release create v2.0.0 \  --draft \  --title "Release v2.0.0" \  --notes "$CHANGELOG" \  --target main
Basic Version Bump
bash
# Update package.json versionnpm version patch  # or minor, major
# Push version taggit push --follow-tags
Simple Deployment
bash
# Build and publish npm packagenpm run buildnpm publish
# Create GitHub releasegh 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 versionsPRS=$(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 historyCOMMITS=$(gh api repos/:owner/:repo/compare/v1.0.0...HEAD \  --jq '.commits[].commit.message')
# Generate categorized changelognpx 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 suggestionnpx 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 coordinationnpx 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 testingnpx 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 orchestrationnpx 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.ymldeployment:  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 rolloutnpx 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 repositoriesnpx 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 fixnpx 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.ymlversion: 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: ["[email protected]"]        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 checksnpx 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 versionsnpx 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 baselinenpx 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-deploymentnpx 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 adoptionnpx 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-rollbacknpx 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 validationnpx claude-flow github release-security \  --scan-dependencies \  --check-secrets \  --audit-permissions \  --sign-artifacts \  --sbom-generation \  --vulnerability-report
Compliance Validation
bash
# Ensure regulatory compliancenpx 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.ymlname: Intelligent Release Workflowon:  push:    tags: ['v*']
jobs:  release-orchestration:    runs-on: ubuntu-latest    permissions:      contents: write      packages: write      issues: write
    steps:      - name: Checkout Repository        uses: actions/checkout@v4        with:          fetch-depth: 0
      - name: Setup Node.js        uses: actions/setup-node@v4        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.ymlname: Emergency Hotfix Workflowon:  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 failuresnpx claude-flow@alpha diagnostic-run \  --component build \  --verbose
# Retry with isolated environmentdocker 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 outputnpm run test -- --verbose --coverage
# Check for environment-specific issuesnpm run test:ci
# Compare local vs CI environmentnpx claude-flow@alpha github compat-test \  --environments "local,ci" \  --compare

Issue: Deployment Rollback Needed

bash
# Immediate rollback to previous versionnpx claude-flow@alpha github rollback \  --to-version v1.9.9 \  --reason "Critical bug in v2.0.0" \  --preserve-data \  --notify-users
# Investigate rollback causenpx claude-flow@alpha github release-analytics \  --version v2.0.0 \  --identify-issues

Issue: Version Conflicts

bash
# Check and resolve version conflictsnpx claude-flow@alpha github release-validate \  --checks version-conflicts \  --auto-resolve
# Align multi-package versionsnpx 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

來源與署名

來源:ruvnet/ruflo位於.claude/skills/github-release-management提交60de638

授權條款: 無授權條款

內容歸原作者所有。SourceWeft 從公開儲存庫中收錄這些內容。

檢舉或申請下架