1# Plan and create a release
 2gh release create v2.0.0 \
 3  --draft \
 4  --generate-notes \
 5  --title "Release v2.0.0"
 6
 7# Orchestrate with swarm
 8npx claude-flow github release-create \
 9  --version "2.0.0" \
10  --build-artifacts \
11  --deploy-targets "npm,docker,github"

1# Initialize release swarm
2npx claude-flow swarm init --topology hierarchical
3
4# Execute complete release pipeline
5npx claude-flow sparc pipeline "Release v2.0.0 with full validation"

 1# Get last release tag
 2LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
 3
 4# Generate changelog from commits
 5CHANGELOG=$(gh api repos/:owner/:repo/compare/${LAST_TAG}...HEAD \
 6  --jq '.commits[].commit.message')
 7
 8# Create draft release
 9gh release create v2.0.0 \
10  --draft \
11  --title "Release v2.0.0" \
12  --notes "$CHANGELOG" \
13  --target main

1# Update package.json version
2npm version patch  # or minor, major
3
4# Push version tag
5git push --follow-tags

1# Build and publish npm package
2npm run build
3npm publish
4
5# Create GitHub release
6gh release create $(npm pkg get version) \
7  --generate-notes

 1// Simple release preparation in Claude Code
 2[Single Message]:
 3  // Update version files
 4  Edit("package.json", { old: '"version": "1.0.0"', new: '"version": "2.0.0"' })
 5
 6  // Generate changelog
 7  Bash("gh api repos/:owner/:repo/compare/v1.0.0...HEAD --jq '.commits[].commit.message' > CHANGELOG.md")
 8
 9  // Create release branch
10  Bash("git checkout -b release/v2.0.0")
11  Bash("git add -A && git commit -m 'release: Prepare v2.0.0'")
12
13  // Create PR
14  Bash("gh pr create --title 'Release v2.0.0' --body 'Automated release preparation'")

 1// Set up coordinated release team
 2[Single Message - Swarm Initialization]:
 3  mcp__claude-flow__swarm_init {
 4    topology: "hierarchical",
 5    maxAgents: 6,
 6    strategy: "balanced"
 7  }
 8
 9  // Spawn specialized agents
10  mcp__claude-flow__agent_spawn { type: "coordinator", name: "Release Director" }
11  mcp__claude-flow__agent_spawn { type: "coder", name: "Version Manager" }
12  mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }
13  mcp__claude-flow__agent_spawn { type: "reviewer", name: "Release Reviewer" }
14  mcp__claude-flow__agent_spawn { type: "analyst", name: "Deployment Analyst" }
15  mcp__claude-flow__agent_spawn { type: "researcher", name: "Compatibility Checker" }

 1[Single Message - Full Release Coordination]:
 2  // Create release branch
 3  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')")
 4
 5  // Orchestrate release preparation
 6  mcp__claude-flow__task_orchestrate {
 7    task: "Prepare release v2.0.0 with comprehensive testing and validation",
 8    strategy: "sequential",
 9    priority: "critical",
10    maxAgents: 6
11  }
12
13  // Update all release files
14  Write("package.json", "[updated version]")
15  Write("CHANGELOG.md", "[release changelog]")
16  Write("RELEASE_NOTES.md", "[detailed notes]")
17
18  // Run comprehensive validation
19  Bash("npm install && npm test && npm run lint && npm run build")
20
21  // Create release PR
22  Bash(`gh pr create \
23    --title "Release v2.0.0: Feature Set and Improvements" \
24    --head "release/v2.0.0" \
25    --base "main" \
26    --body "$(cat RELEASE_NOTES.md)"`)
27
28  // Track progress
29  TodoWrite { todos: [
30    { content: "Prepare release branch", status: "completed", priority: "critical" },
31    { content: "Run validation suite", status: "completed", priority: "high" },
32    { content: "Create release PR", status: "completed", priority: "high" },
33    { content: "Code review approval", status: "pending", priority: "high" },
34    { content: "Merge and deploy", status: "pending", priority: "critical" }
35  ]}
36
37  // Store release state
38  mcp__claude-flow__memory_usage {
39    action: "store",
40    key: "release/v2.0.0/status",
41    value: JSON.stringify({
42      version: "2.0.0",
43      stage: "validation_complete",
44      timestamp: Date.now(),
45      ready_for_review: true
46    })
47  }

 1# Get merged PRs between versions
 2PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \
 3  --jq ".[] | select(.mergedAt > \"$(gh release view v1.0.0 --json publishedAt -q .publishedAt)\")")
 4
 5# Get commit history
 6COMMITS=$(gh api repos/:owner/:repo/compare/v1.0.0...HEAD \
 7  --jq '.commits[].commit.message')
 8
 9# Generate categorized changelog
10npx claude-flow github changelog \
11  --prs "$PRS" \
12  --commits "$COMMITS" \
13  --from v1.0.0 \
14  --to HEAD \
15  --categorize \
16  --add-migration-guide

1# Intelligent version suggestion
2npx claude-flow github version-suggest \
3  --current v1.2.3 \
4  --analyze-commits \
5  --check-compatibility \
6  --suggest-pre-release

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

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

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

 1[Single Message - Multi-Package Release]:
 2  // Initialize mesh topology for cross-package coordination
 3  mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 8 }
 4
 5  // Spawn package-specific agents
 6  Task("Package A Manager", "Coordinate claude-flow package release v1.0.72", "coder")
 7  Task("Package B Manager", "Coordinate ruv-swarm package release v1.0.12", "coder")
 8  Task("Integration Tester", "Validate cross-package compatibility", "tester")
 9  Task("Version Coordinator", "Align dependencies and versions", "coordinator")
10
11  // Update all packages simultaneously
12  Write("packages/claude-flow/package.json", "[v1.0.72 content]")
13  Write("packages/ruv-swarm/package.json", "[v1.0.12 content]")
14  Write("CHANGELOG.md", "[consolidated changelog]")
15
16  // Run cross-package validation
17  Bash("cd packages/claude-flow && npm install && npm test")
18  Bash("cd packages/ruv-swarm && npm install && npm test")
19  Bash("npm run test:integration")
20
21  // Create unified release PR
22  Bash(`gh pr create \
23    --title "Release: claude-flow v1.0.72, ruv-swarm v1.0.12" \
24    --body "Multi-package coordinated release with cross-compatibility validation"`)

 1# .github/release-deployment.yml
 2deployment:
 3  strategy: progressive
 4  stages:
 5    - name: canary
 6      percentage: 5
 7      duration: 1h
 8      metrics:
 9        - error-rate < 0.1%
10        - latency-p99 < 200ms
11      auto-advance: true
12
13    - name: partial
14      percentage: 25
15      duration: 4h
16      validation: automated-tests
17      approval: qa-team
18
19    - name: rollout
20      percentage: 50
21      duration: 8h
22      monitor: true
23
24    - name: full
25      percentage: 100
26      approval: release-manager
27      rollback-enabled: true

1# Deploy with progressive rollout
2npx claude-flow github release-deploy \
3  --version v2.0.0 \
4  --strategy progressive \
5  --config .github/release-deployment.yml \
6  --monitor-metrics \
7  --auto-rollback-on-error

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

 1[Single Message - Cross-Repo Release]:
 2  // Initialize star topology for centralized coordination
 3  mcp__claude-flow__swarm_init { topology: "star", maxAgents: 6 }
 4
 5  // Spawn repo-specific coordinators
 6  Task("Frontend Release", "Release frontend v2.0.0 with API compatibility", "coordinator")
 7  Task("Backend Release", "Release backend v2.1.0 with breaking changes", "coordinator")
 8  Task("CLI Release", "Release CLI v1.5.0 with new commands", "coordinator")
 9  Task("Compatibility Checker", "Validate cross-repo compatibility", "researcher")
10
11  // Coordinate version updates across repos
12  Bash("gh api repos/org/frontend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.0.0")
13  Bash("gh api repos/org/backend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.1.0")
14  Bash("gh api repos/org/cli/dispatches --method POST -f event_type='release' -F client_payload[version]=v1.5.0")
15
16  // Monitor all releases
17  mcp__claude-flow__swarm_monitor { interval: 5, duration: 300 }

1# Fast-track critical bug fix
2npx claude-flow github emergency-release \
3  --issue 789 \
4  --severity critical \
5  --target-version v1.2.4 \
6  --cherry-pick-commits \
7  --bypass-checks security-only \
8  --fast-track \
9  --notify-all

 1[Single Message - Emergency Hotfix]:
 2  // Create hotfix branch from last stable release
 3  Bash("git checkout -b hotfix/v1.2.4 v1.2.3")
 4
 5  // Cherry-pick critical fixes
 6  Bash("git cherry-pick abc123def")
 7
 8  // Fast validation
 9  Bash("npm run test:critical && npm run build")
10
11  // Create emergency release
12  Bash(`gh release create v1.2.4 \
13    --title "HOTFIX v1.2.4: Critical Security Patch" \
14    --notes "Emergency release addressing CVE-2024-XXXX" \
15    --prerelease=false`)
16
17  // Immediate deployment
18  Bash("npm publish --tag hotfix")
19
20  // Notify stakeholders
21  Bash(`gh issue create \
22    --title "🚨 HOTFIX v1.2.4 Deployed" \
23    --body "Critical security patch deployed. Please update immediately." \
24    --label "critical,security,hotfix"`)

  1# .github/release-swarm.yml
  2version: 2.0.0
  3
  4release:
  5  versioning:
  6    strategy: semantic
  7    breaking-keywords: ["BREAKING", "BREAKING CHANGE", "!"]
  8    feature-keywords: ["feat", "feature"]
  9    fix-keywords: ["fix", "bugfix"]
 10
 11  changelog:
 12    sections:
 13      - title: "🚀 Features"
 14        labels: ["feature", "enhancement"]
 15        emoji: true
 16      - title: "🐛 Bug Fixes"
 17        labels: ["bug", "fix"]
 18      - title: "💥 Breaking Changes"
 19        labels: ["breaking"]
 20        highlight: true
 21      - title: "📚 Documentation"
 22        labels: ["docs", "documentation"]
 23      - title: "⚡ Performance"
 24        labels: ["performance", "optimization"]
 25      - title: "🔒 Security"
 26        labels: ["security"]
 27        priority: critical
 28
 29  artifacts:
 30    - name: npm-package
 31      build: npm run build
 32      test: npm run test:all
 33      publish: npm publish
 34      registry: https://registry.npmjs.org
 35
 36    - name: docker-image
 37      build: docker build -t app:$VERSION .
 38      test: docker run app:$VERSION npm test
 39      publish: docker push app:$VERSION
 40      platforms: [linux/amd64, linux/arm64]
 41
 42    - name: binaries
 43      build: ./scripts/build-binaries.sh
 44      platforms: [linux, macos, windows]
 45      architectures: [x64, arm64]
 46      upload: github-release
 47      sign: true
 48
 49  validation:
 50    pre-release:
 51      - lint: npm run lint
 52      - typecheck: npm run typecheck
 53      - unit-tests: npm run test:unit
 54      - integration-tests: npm run test:integration
 55      - security-scan: npm audit
 56      - license-check: npm run license-check
 57
 58    post-release:
 59      - smoke-tests: npm run test:smoke
 60      - deployment-validation: ./scripts/validate-deployment.sh
 61      - performance-baseline: npm run benchmark
 62
 63  deployment:
 64    environments:
 65      - name: staging
 66        auto-deploy: true
 67        validation: npm run test:e2e
 68        approval: false
 69
 70      - name: production
 71        auto-deploy: false
 72        approval-required: true
 73        approvers: ["release-manager", "tech-lead"]
 74        rollback-enabled: true
 75        health-checks:
 76          - endpoint: /health
 77            expected: 200
 78            timeout: 30s
 79
 80  monitoring:
 81    metrics:
 82      - error-rate: <1%
 83      - latency-p95: <500ms
 84      - availability: >99.9%
 85      - memory-usage: <80%
 86
 87    alerts:
 88      - type: slack
 89        channel: releases
 90        on: [deploy, rollback, error]
 91      - type: email
 92        recipients: ["team@company.com"]
 93        on: [critical-error, rollback]
 94      - type: pagerduty
 95        service: production-releases
 96        on: [critical-error]
 97
 98  rollback:
 99    auto-rollback:
100      triggers:
101        - error-rate > 5%
102        - latency-p99 > 2000ms
103        - availability < 99%
104      grace-period: 5m
105
106    manual-rollback:
107      preserve-data: true
108      notify-users: true
109      create-incident: true

 1# Pre-release validation with all checks
 2npx claude-flow github release-validate \
 3  --checks "
 4    version-conflicts,
 5    dependency-compatibility,
 6    api-breaking-changes,
 7    security-vulnerabilities,
 8    performance-regression,
 9    documentation-completeness,
10    license-compliance,
11    backwards-compatibility
12  " \
13  --block-on-failure \
14  --generate-report \
15  --upload-results

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

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

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

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

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

1# Comprehensive security validation
2npx claude-flow github release-security \
3  --scan-dependencies \
4  --check-secrets \
5  --audit-permissions \
6  --sign-artifacts \
7  --sbom-generation \
8  --vulnerability-report

1# Ensure regulatory compliance
2npx claude-flow github release-compliance \
3  --standards "SOC2,GDPR,HIPAA" \
4  --license-audit \
5  --data-governance \
6  --audit-trail \
7  --generate-attestation

  1# .github/workflows/release.yml
  2name: Intelligent Release Workflow
  3on:
  4  push:
  5    tags: ['v*']
  6
  7jobs:
  8  release-orchestration:
  9    runs-on: ubuntu-latest
 10    permissions:
 11      contents: write
 12      packages: write
 13      issues: write
 14
 15    steps:
 16      - name: Checkout Repository
 17        uses: actions/checkout@v3
 18        with:
 19          fetch-depth: 0
 20
 21      - name: Setup Node.js
 22        uses: actions/setup-node@v3
 23        with:
 24          node-version: '20'
 25          cache: 'npm'
 26
 27      - name: Authenticate GitHub CLI
 28        run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token
 29
 30      - name: Initialize Release Swarm
 31        run: |
 32          # Extract version from tag
 33          RELEASE_TAG=${{ github.ref_name }}
 34          PREV_TAG=$(gh release list --limit 2 --json tagName -q '.[1].tagName')
 35
 36          # Get merged PRs for changelog
 37          PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \
 38            --jq ".[] | select(.mergedAt > \"$(gh release view $PREV_TAG --json publishedAt -q .publishedAt)\")")
 39
 40          # Get commit history
 41          COMMITS=$(gh api repos/${{ github.repository }}/compare/${PREV_TAG}...HEAD \
 42            --jq '.commits[].commit.message')
 43
 44          # Initialize swarm coordination
 45          npx claude-flow@alpha swarm init --topology hierarchical
 46
 47          # Store release context
 48          echo "$PRS" > /tmp/release-prs.json
 49          echo "$COMMITS" > /tmp/release-commits.txt
 50
 51      - name: Generate Release Changelog
 52        run: |
 53          # Generate intelligent changelog
 54          CHANGELOG=$(npx claude-flow@alpha github changelog \
 55            --prs "$(cat /tmp/release-prs.json)" \
 56            --commits "$(cat /tmp/release-commits.txt)" \
 57            --from $PREV_TAG \
 58            --to $RELEASE_TAG \
 59            --categorize \
 60            --add-migration-guide \
 61            --format markdown)
 62
 63          echo "$CHANGELOG" > RELEASE_CHANGELOG.md
 64
 65      - name: Build Release Artifacts
 66        run: |
 67          # Install dependencies
 68          npm ci
 69
 70          # Run comprehensive validation
 71          npm run lint
 72          npm run typecheck
 73          npm run test:all
 74          npm run build
 75
 76          # Build platform-specific binaries
 77          npx claude-flow@alpha github release-build \
 78            --platforms "linux,macos,windows" \
 79            --architectures "x64,arm64" \
 80            --parallel
 81
 82      - name: Security Scan
 83        run: |
 84          # Run security validation
 85          npm audit --audit-level=moderate
 86
 87          npx claude-flow@alpha github release-security \
 88            --scan-dependencies \
 89            --check-secrets \
 90            --sign-artifacts
 91
 92      - name: Create GitHub Release
 93        run: |
 94          # Update release with generated changelog
 95          gh release edit ${{ github.ref_name }} \
 96            --notes "$(cat RELEASE_CHANGELOG.md)" \
 97            --draft=false
 98
 99          # Upload all artifacts
100          for file in dist/*; do
101            gh release upload ${{ github.ref_name }} "$file"
102          done
103
104      - name: Deploy to Package Registries
105        run: |
106          # Publish to npm
107          echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
108          npm publish
109
110          # Build and push Docker images
111          docker build -t ${{ github.repository }}:${{ github.ref_name }} .
112          docker push ${{ github.repository }}:${{ github.ref_name }}
113
114      - name: Post-Release Validation
115        run: |
116          # Run smoke tests
117          npm run test:smoke
118
119          # Validate deployment
120          npx claude-flow@alpha github release-validate \
121            --version ${{ github.ref_name }} \
122            --smoke-tests \
123            --health-checks
124
125      - name: Create Release Announcement
126        run: |
127          # Create announcement issue
128          gh issue create \
129            --title "🎉 Released ${{ github.ref_name }}" \
130            --body "$(cat RELEASE_CHANGELOG.md)" \
131            --label "announcement,release"
132
133          # Notify via discussion
134          gh api repos/${{ github.repository }}/discussions \
135            --method POST \
136            -f title="Release ${{ github.ref_name }} Now Available" \
137            -f body="$(cat RELEASE_CHANGELOG.md)" \
138            -f category_id="$(gh api repos/${{ github.repository }}/discussions/categories --jq '.[] | select(.slug=="announcements") | .id')"
139
140      - name: Monitor Release
141        run: |
142          # Start release monitoring
143          npx claude-flow@alpha github release-monitor \
144            --version ${{ github.ref_name }} \
145            --duration 1h \
146            --alert-on-errors &

 1# .github/workflows/hotfix.yml
 2name: Emergency Hotfix Workflow
 3on:
 4  issues:
 5    types: [labeled]
 6
 7jobs:
 8  emergency-hotfix:
 9    if: contains(github.event.issue.labels.*.name, 'critical-hotfix')
10    runs-on: ubuntu-latest
11
12    steps:
13      - name: Create Hotfix Branch
14        run: |
15          LAST_STABLE=$(gh release list --limit 1 --json tagName -q '.[0].tagName')
16          HOTFIX_VERSION=$(echo $LAST_STABLE | awk -F. '{print $1"."$2"."$3+1}')
17
18          git checkout -b hotfix/$HOTFIX_VERSION $LAST_STABLE
19
20      - name: Fast-Track Testing
21        run: |
22          npm ci
23          npm run test:critical
24          npm run build
25
26      - name: Emergency Release
27        run: |
28          npx claude-flow@alpha github emergency-release \
29            --issue ${{ github.event.issue.number }} \
30            --severity critical \
31            --fast-track \
32            --notify-all

1# Debug build failures
2npx claude-flow@alpha diagnostic-run \
3  --component build \
4  --verbose
5
6# Retry with isolated environment
7docker run --rm -v $(pwd):/app node:20 \
8  bash -c "cd /app && npm ci && npm run build"

 1# Run tests with detailed output
 2npm run test -- --verbose --coverage
 3
 4# Check for environment-specific issues
 5npm run test:ci
 6
 7# Compare local vs CI environment
 8npx claude-flow@alpha github compat-test \
 9  --environments "local,ci" \
10  --compare

 1# Immediate rollback to previous version
 2npx claude-flow@alpha github rollback \
 3  --to-version v1.9.9 \
 4  --reason "Critical bug in v2.0.0" \
 5  --preserve-data \
 6  --notify-users
 7
 8# Investigate rollback cause
 9npx claude-flow@alpha github release-analytics \
10  --version v2.0.0 \
11  --identify-issues

1# Check and resolve version conflicts
2npx claude-flow@alpha github release-validate \
3  --checks version-conflicts \
4  --auto-resolve
5
6# Align multi-package versions
7npx claude-flow@alpha github version-sync \
8  --packages "package-a,package-b" \
9  --strategy semantic