| name | github-release-management |
| description | Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback 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
gh release create v2.0.0 \
--draft \
--generate-notes \
--title "Release v2.0.0"
npx Codex-flow github release-create \
--version "2.0.0" \
--build-artifacts \
--deploy-targets "npm,docker,github"
Full Automated Release
npx Codex-flow swarm init --topology hierarchical
npx Codex-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
LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
CHANGELOG=$(gh api repos/:owner/:repo/compare/${LAST_TAG}...HEAD \
--jq '.commits[].commit.message')
gh release create v2.0.0 \
--draft \
--title "Release v2.0.0" \
--notes "$CHANGELOG" \
--target main
Basic Version Bump
npm version patch
git push --follow-tags
Simple Deployment
npm run build
npm publish
gh release create $(npm pkg get version) \
--generate-notes
Quick Integration Example
[Single Message]:
Edit("package.json", { old: '"version": "1.0.0"', new: '"version": "2.0.0"' })
Bash("gh api repos/:owner/:repo/compare/v1.0.0...HEAD --jq '.commits[].commit.message' > CHANGELOG.md")
Bash("git checkout -b release/v2.0.0")
Bash("git add -A && git commit -m 'release: Prepare v2.0.0'")
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
[Single Message - Swarm Initialization]:
mcp__ruflo__swarm_init {
topology: "hierarchical",
maxAgents: 6,
strategy: "balanced"
}
mcp__ruflo__agent_spawn { type: "coordinator", name: "Release Director" }
mcp__ruflo__agent_spawn { type: "coder", name: "Version Manager" }
mcp__ruflo__agent_spawn { type: "tester", name: "QA Engineer" }
mcp__ruflo__agent_spawn { type: "reviewer", name: "Release Reviewer" }
mcp__ruflo__agent_spawn { type: "analyst", name: "Deployment Analyst" }
mcp__ruflo__agent_spawn { type: "researcher", name: "Compatibility Checker" }
Coordinated Release Workflow
[Single Message - Full Release Coordination]:
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')")
mcp__ruflo__task_orchestrate {
task: "Prepare release v2.0.0 with comprehensive testing and validation",
strategy: "sequential",
priority: "critical",
maxAgents: 6
}
Write("package.json", "[updated version]")
Write("CHANGELOG.md", "[release changelog]")
Write("RELEASE_NOTES.md", "[detailed notes]")
Bash("npm install && npm test && npm run lint && npm run build")
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)"`)
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" }
]}
mcp__ruflo__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
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)\")")
COMMITS=$(gh api repos/:owner/:repo/compare/v1.0.0...HEAD \
--jq '.commits[].commit.message')
npx Codex-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
npx Codex-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
npx Codex-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
npx Codex-flow github release-test \
--suites "unit,integration,e2e,performance" \
--environments "node:16,node:18,node:20" \
--fail-fast false \
--generate-report
Deploy Agent
npx Codex-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]:
mcp__ruflo__swarm_init { topology: "mesh", maxAgents: 8 }
Task("Package A Manager", "Coordinate Codex-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")
Write("packages/Codex-flow/package.json", "[v1.0.72 content]")
Write("packages/ruv-swarm/package.json", "[v1.0.12 content]")
Write("CHANGELOG.md", "[consolidated changelog]")
Bash("cd packages/Codex-flow && npm install && npm test")
Bash("cd packages/ruv-swarm && npm install && npm test")
Bash("npm run test:integration")
Bash(`gh pr create \
--title "Release: Codex-flow v1.0.72, ruv-swarm v1.0.12" \
--body "Multi-package coordinated release with cross-compatibility validation"`)
Progressive Deployment Strategy
Staged Rollout Configuration
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
npx Codex-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
npx Codex-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]:
mcp__ruflo__swarm_init { topology: "star", maxAgents: 6 }
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")
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")
mcp__ruflo__swarm_monitor { interval: 5, duration: 300 }
Hotfix Emergency Procedures
Emergency Hotfix Workflow
npx Codex-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]:
Bash("git checkout -b hotfix/v1.2.4 v1.2.3")
Bash("git cherry-pick abc123def")
Bash("npm run test:critical && npm run build")
Bash(`gh release create v1.2.4 \
--title "HOTFIX v1.2.4: Critical Security Patch" \
--notes "Emergency release addressing CVE-2024-XXXX" \
--prerelease=false`)
Bash("npm publish --tag hotfix")
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
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
npx Codex-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
npx Codex-flow github compat-test \
--previous-versions "v1.0,v1.1,v1.2" \
--api-contracts \
--data-migrations \
--integration-tests \
--generate-report
Performance Regression Detection
npx Codex-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
npx Codex-flow github release-monitor \
--version v2.0.0 \
--metrics "error-rate,latency,throughput,adoption" \
--alert-thresholds \
--duration 24h \
--export-dashboard
Release Analytics & Insights
npx Codex-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
npx Codex-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
npx Codex-flow github release-security \
--scan-dependencies \
--check-secrets \
--audit-permissions \
--sign-artifacts \
--sbom-generation \
--vulnerability-report
Compliance Validation
npx Codex-flow github release-compliance \
--standards "SOC2,GDPR,HIPAA" \
--license-audit \
--data-governance \
--audit-trail \
--generate-attestation
GitHub Actions Integration
Complete Release Workflow
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@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')
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)\")")
COMMITS=$(gh api repos/${{ github.repository }}/compare/${PREV_TAG}...HEAD \
--jq '.commits[].commit.message')
npx @sparkleideas/ruflo@latest swarm init --topology hierarchical
echo "$PRS" > /tmp/release-prs.json
echo "$COMMITS" > /tmp/release-commits.txt
- name: Generate Release Changelog
run: |
# Generate intelligent changelog
CHANGELOG=$(npx @sparkleideas/ruflo@latest 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
npm run lint
npm run typecheck
npm run test:all
npm run build
npx @sparkleideas/ruflo@latest github release-build \
--platforms "linux,macos,windows" \
--architectures "x64,arm64" \
--parallel
- name: Security Scan
run: |
# Run security validation
npm audit --audit-level=moderate
npx @sparkleideas/ruflo@latest 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
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
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
npx @sparkleideas/ruflo@latest 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"
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 @sparkleideas/ruflo@latest github release-monitor \
--version ${{ github.ref_name }} \
--duration 1h \
--alert-on-errors &
Hotfix Workflow
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 @sparkleideas/ruflo@latest 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
npx @sparkleideas/ruflo@latest diagnostic-run \
--component build \
--verbose
docker run --rm -v $(pwd):/app node:20 \
bash -c "cd /app && npm ci && npm run build"
Issue: Test Failures in CI
npm run test -- --verbose --coverage
npm run test:ci
npx @sparkleideas/ruflo@latest github compat-test \
--environments "local,ci" \
--compare
Issue: Deployment Rollback Needed
npx @sparkleideas/ruflo@latest github rollback \
--to-version v1.9.9 \
--reason "Critical bug in v2.0.0" \
--preserve-data \
--notify-users
npx @sparkleideas/ruflo@latest github release-analytics \
--version v2.0.0 \
--identify-issues
Issue: Version Conflicts
npx @sparkleideas/ruflo@latest github release-validate \
--checks version-conflicts \
--auto-resolve
npx @sparkleideas/ruflo@latest 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
- Parallel Execution: Use swarm coordination for concurrent tasks
- Caching: Enable build and dependency caching
- Incremental Builds: Only rebuild changed components
- 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
Release Checklist
Post-Release Checklist
Version: 2.0.0
Last Updated: 2025-10-19
Maintained By: Codex Flow Team
