GitHub Release Management

Name: GitHub Release Management
Author: ruvnet

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

You say

Buy it · $19 Read it before you buy $19 Written by ruvnet · unverified publisher

Context cost: 7.3k tokensestimated from the bundle, loaded when it triggers
Bundle: 1 file · 29.2 kBtext throughout, nothing executable
Licence: MITpaid listing
Last change: —no release on file
Servers it uses: Noneruns standalone

What it does

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

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Output format

Produces one artefact, exactly shaped.

devopsgithub

Filed under

Cloud & DevOps

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md29.2 kB · 1065 lines

--- name: github-release-management description: | Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management ---

7# GitHub Release Management Skill

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

11## Quick Start

13### Simple Release Flow

14```bash

15# Plan and create a release

16gh release create v2.0.0 \

17 --draft \

18 --generate-notes \

19 --title "Release v2.0.0"

21# Orchestrate with swarm

22npx claude-flow github release-create \

23 --version "2.0.0" \

24 --build-artifacts \

25 --deploy-targets "npm,docker,github"

26```

28### Full Automated Release

29```bash

30# Initialize release swarm

31npx claude-flow swarm init --topology hierarchical

33# Execute complete release pipeline

34npx claude-flow sparc pipeline "Release v2.0.0 with full validation"

35```

37---

39## Core Capabilities

41### 1. Release Planning & Version Management

42- Semantic version analysis and suggestion

43- Breaking change detection from commits

44- Release timeline generation

45- Multi-package version coordination

47### 2. Automated Testing & Validation

48- Multi-stage test orchestration

49- Cross-platform compatibility testing

50- Performance regression detection

51- Security vulnerability scanning

53### 3. Build & Deployment Orchestration

54- Multi-platform build coordination

55- Parallel artifact generation

56- Progressive deployment strategies

57- Automated rollback mechanisms

59### 4. Documentation & Communication

60- Automated changelog generation

61- Release notes with categorization

62- Migration guide creation

63- Stakeholder notification

65---

67## Progressive Disclosure: Level 1 - Basic Usage

69### Essential Release Commands

71#### Create Release Draft

72```bash

73# Get last release tag

74LAST_TAG=$(gh release list --limit 1 --json tagName -q '.[0].tagName')

76# Generate changelog from commits

77CHANGELOG=$(gh api repos/:owner/:repo/compare/${LAST_TAG}...HEAD \

78 --jq '.commits[].commit.message')

80# Create draft release

81gh release create v2.0.0 \

82 --draft \

83 --title "Release v2.0.0" \

84 --notes "$CHANGELOG" \

85 --target main

86```

88#### Basic Version Bump

89```bash

90# Update package.json version

91npm version patch # or minor, major

93# Push version tag

94git push --follow-tags

95```

97#### Simple Deployment

98```bash

99# Build and publish npm package

100npm run build

101npm publish

102

103# Create GitHub release

104gh release create $(npm pkg get version) \

105 --generate-notes

106```

107

108### Quick Integration Example

109```javascript

110// Simple release preparation in Claude Code

111[Single Message]:

112 // Update version files

113 Edit("package.json", { old: '"version": "1.0.0"', new: '"version": "2.0.0"' })

114

115 // Generate changelog

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

117

118 // Create release branch

119 Bash("git checkout -b release/v2.0.0")

120 Bash("git add -A && git commit -m 'release: Prepare v2.0.0'")

121

122 // Create PR

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

124```

125

126---

127

128## Progressive Disclosure: Level 2 - Swarm Coordination

129

130### AI Swarm Release Orchestration

131

132#### Initialize Release Swarm

133```javascript

134// Set up coordinated release team

135[Single Message - Swarm Initialization]:

136 mcp__claude-flow__swarm_init {

137 topology: "hierarchical",

138 maxAgents: 6,

139 strategy: "balanced"

140 }

141

142 // Spawn specialized agents

143 mcp__claude-flow__agent_spawn { type: "coordinator", name: "Release Director" }

144 mcp__claude-flow__agent_spawn { type: "coder", name: "Version Manager" }

145 mcp__claude-flow__agent_spawn { type: "tester", name: "QA Engineer" }

146 mcp__claude-flow__agent_spawn { type: "reviewer", name: "Release Reviewer" }

147 mcp__claude-flow__agent_spawn { type: "analyst", name: "Deployment Analyst" }

148 mcp__claude-flow__agent_spawn { type: "researcher", name: "Compatibility Checker" }

149```

150

151#### Coordinated Release Workflow

152```javascript

153[Single Message - Full Release Coordination]:

154 // Create release branch

155 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')")

156

157 // Orchestrate release preparation

158 mcp__claude-flow__task_orchestrate {

159 task: "Prepare release v2.0.0 with comprehensive testing and validation",

160 strategy: "sequential",

161 priority: "critical",

162 maxAgents: 6

163 }

164

165 // Update all release files

166 Write("package.json", "[updated version]")

167 Write("CHANGELOG.md", "[release changelog]")

168 Write("RELEASE_NOTES.md", "[detailed notes]")

169

170 // Run comprehensive validation

171 Bash("npm install && npm test && npm run lint && npm run build")

172

173 // Create release PR

174 Bash(`gh pr create \

175 --title "Release v2.0.0: Feature Set and Improvements" \

176 --head "release/v2.0.0" \

177 --base "main" \

178 --body "$(cat RELEASE_NOTES.md)"`)

179

180 // Track progress

181 TodoWrite { todos: [

182 { content: "Prepare release branch", status: "completed", priority: "critical" },

183 { content: "Run validation suite", status: "completed", priority: "high" },

184 { content: "Create release PR", status: "completed", priority: "high" },

185 { content: "Code review approval", status: "pending", priority: "high" },

186 { content: "Merge and deploy", status: "pending", priority: "critical" }

187 ]}

188

189 // Store release state

190 mcp__claude-flow__memory_usage {

191 action: "store",

192 key: "release/v2.0.0/status",

193 value: JSON.stringify({

194 version: "2.0.0",

195 stage: "validation_complete",

196 timestamp: Date.now(),

197 ready_for_review: true

198 })

199 }

200```

201

202### Release Agent Specializations

203

204#### Changelog Agent

205```bash

206# Get merged PRs between versions

207PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \

208 --jq ".[] | select(.mergedAt > \"$(gh release view v1.0.0 --json publishedAt -q .publishedAt)\")")

209

210# Get commit history

211COMMITS=$(gh api repos/:owner/:repo/compare/v1.0.0...HEAD \

212 --jq '.commits[].commit.message')

213

214# Generate categorized changelog

215npx claude-flow github changelog \

216 --prs "$PRS" \

217 --commits "$COMMITS" \

218 --from v1.0.0 \

219 --to HEAD \

220 --categorize \

221 --add-migration-guide

222```

223

224**Capabilities:**

225- Semantic commit analysis

226- Breaking change detection

227- Contributor attribution

228- Migration guide generation

229- Multi-language support

230

231#### Version Agent

232```bash

233# Intelligent version suggestion

234npx claude-flow github version-suggest \

235 --current v1.2.3 \

236 --analyze-commits \

237 --check-compatibility \

238 --suggest-pre-release

239```

240

241**Logic:**

242- Analyzes commit messages and PR labels

243- Detects breaking changes via keywords

244- Suggests appropriate version bump

245- Handles pre-release versioning

246- Validates version constraints

247

248#### Build Agent

249```bash

250# Multi-platform build coordination

251npx claude-flow github release-build \

252 --platforms "linux,macos,windows" \

253 --architectures "x64,arm64" \

254 --parallel \

255 --optimize-size

256```

257

258**Features:**

259- Cross-platform compilation

260- Parallel build execution

261- Artifact optimization and compression

262- Dependency bundling

263- Build caching and reuse

264

265#### Test Agent

266```bash

267# Comprehensive pre-release testing

268npx claude-flow github release-test \

269 --suites "unit,integration,e2e,performance" \

270 --environments "node:16,node:18,node:20" \

271 --fail-fast false \

272 --generate-report

273```

274

275#### Deploy Agent

276```bash

277# Multi-target deployment orchestration

278npx claude-flow github release-deploy \

279 --targets "npm,docker,github,s3" \

280 --staged-rollout \

281 --monitor-metrics \

282 --auto-rollback

283```

284

285---

286

287## Progressive Disclosure: Level 3 - Advanced Workflows

288

289### Multi-Package Release Coordination

290

291#### Monorepo Release Strategy

292```javascript

293[Single Message - Multi-Package Release]:

294 // Initialize mesh topology for cross-package coordination

295 mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 8 }

296

297 // Spawn package-specific agents

298 Task("Package A Manager", "Coordinate claude-flow package release v1.0.72", "coder")

299 Task("Package B Manager", "Coordinate ruv-swarm package release v1.0.12", "coder")

300 Task("Integration Tester", "Validate cross-package compatibility", "tester")

301 Task("Version Coordinator", "Align dependencies and versions", "coordinator")

302

303 // Update all packages simultaneously

304 Write("packages/claude-flow/package.json", "[v1.0.72 content]")

305 Write("packages/ruv-swarm/package.json", "[v1.0.12 content]")

306 Write("CHANGELOG.md", "[consolidated changelog]")

307

308 // Run cross-package validation

309 Bash("cd packages/claude-flow && npm install && npm test")

310 Bash("cd packages/ruv-swarm && npm install && npm test")

311 Bash("npm run test:integration")

312

313 // Create unified release PR

314 Bash(`gh pr create \

315 --title "Release: claude-flow v1.0.72, ruv-swarm v1.0.12" \

316 --body "Multi-package coordinated release with cross-compatibility validation"`)

317```

318

319### Progressive Deployment Strategy

320

321#### Staged Rollout Configuration

322```yaml

323# .github/release-deployment.yml

324deployment:

325 strategy: progressive

326 stages:

327 - name: canary

328 percentage: 5

329 duration: 1h

330 metrics:

331 - error-rate < 0.1%

332 - latency-p99 < 200ms

333 auto-advance: true

334

335 - name: partial

336 percentage: 25

337 duration: 4h

338 validation: automated-tests

339 approval: qa-team

340

341 - name: rollout

342 percentage: 50

343 duration: 8h

344 monitor: true

345

346 - name: full

347 percentage: 100

348 approval: release-manager

349 rollback-enabled: true

350```

351

352#### Execute Staged Deployment

353```bash

354# Deploy with progressive rollout

355npx claude-flow github release-deploy \

356 --version v2.0.0 \

357 --strategy progressive \

358 --config .github/release-deployment.yml \

359 --monitor-metrics \

360 --auto-rollback-on-error

361```

362

363### Multi-Repository Coordination

364

365#### Coordinated Multi-Repo Release

366```bash

367# Synchronize releases across repositories

368npx claude-flow github multi-release \

369 --repos "frontend:v2.0.0,backend:v2.1.0,cli:v1.5.0" \

370 --ensure-compatibility \

371 --atomic-release \

372 --synchronized \

373 --rollback-all-on-failure

374```

375

376#### Cross-Repo Dependency Management

377```javascript

378[Single Message - Cross-Repo Release]:

379 // Initialize star topology for centralized coordination

380 mcp__claude-flow__swarm_init { topology: "star", maxAgents: 6 }

381

382 // Spawn repo-specific coordinators

383 Task("Frontend Release", "Release frontend v2.0.0 with API compatibility", "coordinator")

384 Task("Backend Release", "Release backend v2.1.0 with breaking changes", "coordinator")

385 Task("CLI Release", "Release CLI v1.5.0 with new commands", "coordinator")

386 Task("Compatibility Checker", "Validate cross-repo compatibility", "researcher")

387

388 // Coordinate version updates across repos

389 Bash("gh api repos/org/frontend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.0.0")

390 Bash("gh api repos/org/backend/dispatches --method POST -f event_type='release' -F client_payload[version]=v2.1.0")

391 Bash("gh api repos/org/cli/dispatches --method POST -f event_type='release' -F client_payload[version]=v1.5.0")

392

393 // Monitor all releases

394 mcp__claude-flow__swarm_monitor { interval: 5, duration: 300 }

395```

396

397### Hotfix Emergency Procedures

398

399#### Emergency Hotfix Workflow

400```bash

401# Fast-track critical bug fix

402npx claude-flow github emergency-release \

403 --issue 789 \

404 --severity critical \

405 --target-version v1.2.4 \

406 --cherry-pick-commits \

407 --bypass-checks security-only \

408 --fast-track \

409 --notify-all

410```

411

412#### Automated Hotfix Process

413```javascript

414[Single Message - Emergency Hotfix]:

415 // Create hotfix branch from last stable release

416 Bash("git checkout -b hotfix/v1.2.4 v1.2.3")

417

418 // Cherry-pick critical fixes

419 Bash("git cherry-pick abc123def")

420

421 // Fast validation

422 Bash("npm run test:critical && npm run build")

423

424 // Create emergency release

425 Bash(`gh release create v1.2.4 \

426 --title "HOTFIX v1.2.4: Critical Security Patch" \

427 --notes "Emergency release addressing CVE-2024-XXXX" \

428 --prerelease=false`)

429

430 // Immediate deployment

431 Bash("npm publish --tag hotfix")

432

433 // Notify stakeholders

434 Bash(`gh issue create \

435 --title "🚨 HOTFIX v1.2.4 Deployed" \

436 --body "Critical security patch deployed. Please update immediately." \

437 --label "critical,security,hotfix"`)

438```

439

440---

441

442## Progressive Disclosure: Level 4 - Enterprise Features

443

444### Release Configuration Management

445

446#### Comprehensive Release Config

447```yaml

448# .github/release-swarm.yml

449version: 2.0.0

450

451release:

452 versioning:

453 strategy: semantic

454 breaking-keywords: ["BREAKING", "BREAKING CHANGE", "!"]

455 feature-keywords: ["feat", "feature"]

456 fix-keywords: ["fix", "bugfix"]

457

458 changelog:

459 sections:

460 - title: "🚀 Features"

461 labels: ["feature", "enhancement"]

462 emoji: true

463 - title: "🐛 Bug Fixes"

464 labels: ["bug", "fix"]

465 - title: "💥 Breaking Changes"

466 labels: ["breaking"]

467 highlight: true

468 - title: "📚 Documentation"

469 labels: ["docs", "documentation"]

470 - title: "⚡ Performance"

471 labels: ["performance", "optimization"]

472 - title: "🔒 Security"

473 labels: ["security"]

474 priority: critical

475

476 artifacts:

477 - name: npm-package

478 build: npm run build

479 test: npm run test:all

480 publish: npm publish

481 registry: https://registry.npmjs.org

482

483 - name: docker-image

484 build: docker build -t app:$VERSION .

485 test: docker run app:$VERSION npm test

486 publish: docker push app:$VERSION

487 platforms: [linux/amd64, linux/arm64]

488

489 - name: binaries

490 build: ./scripts/build-binaries.sh

491 platforms: [linux, macos, windows]

492 architectures: [x64, arm64]

493 upload: github-release

494 sign: true

495

496 validation:

497 pre-release:

498 - lint: npm run lint

499 - typecheck: npm run typecheck

500 - unit-tests: npm run test:unit

501 - integration-tests: npm run test:integration

502 - security-scan: npm audit

503 - license-check: npm run license-check

504

505 post-release:

506 - smoke-tests: npm run test:smoke

507 - deployment-validation: ./scripts/validate-deployment.sh

508 - performance-baseline: npm run benchmark

509

510 deployment:

511 environments:

512 - name: staging

513 auto-deploy: true

514 validation: npm run test:e2e

515 approval: false

516

517 - name: production

518 auto-deploy: false

519 approval-required: true

520 approvers: ["release-manager", "tech-lead"]

521 rollback-enabled: true

522 health-checks:

523 - endpoint: /health

524 expected: 200

525 timeout: 30s

526

527 monitoring:

528 metrics:

529 - error-rate: <1%

530 - latency-p95: <500ms

531 - availability: >99.9%

532 - memory-usage: <80%

533

534 alerts:

535 - type: slack

536 channel: releases

537 on: [deploy, rollback, error]

538 - type: email

539 recipients: ["team@company.com"]

540 on: [critical-error, rollback]

541 - type: pagerduty

542 service: production-releases

543 on: [critical-error]

544

545 rollback:

546 auto-rollback:

547 triggers:

548 - error-rate > 5%

549 - latency-p99 > 2000ms

550 - availability < 99%

551 grace-period: 5m

552

553 manual-rollback:

554 preserve-data: true

555 notify-users: true

556 create-incident: true

557```

558

559### Advanced Testing Strategies

560

561#### Comprehensive Validation Suite

562```bash

563# Pre-release validation with all checks

564npx claude-flow github release-validate \

565 --checks "

566 version-conflicts,

567 dependency-compatibility,

568 api-breaking-changes,

569 security-vulnerabilities,

570 performance-regression,

571 documentation-completeness,

572 license-compliance,

573 backwards-compatibility

574 " \

575 --block-on-failure \

576 --generate-report \

577 --upload-results

578```

579

580#### Backward Compatibility Testing

581```bash

582# Test against previous versions

583npx claude-flow github compat-test \

584 --previous-versions "v1.0,v1.1,v1.2" \

585 --api-contracts \

586 --data-migrations \

587 --integration-tests \

588 --generate-report

589```

590

591#### Performance Regression Detection

592```bash

593# Benchmark against baseline

594npx claude-flow github performance-test \

595 --baseline v1.9.0 \

596 --candidate v2.0.0 \

597 --metrics "throughput,latency,memory,cpu" \

598 --threshold 5% \

599 --fail-on-regression

600```

601

602### Release Monitoring & Analytics

603

604#### Real-Time Release Monitoring

605```bash

606# Monitor release health post-deployment

607npx claude-flow github release-monitor \

608 --version v2.0.0 \

609 --metrics "error-rate,latency,throughput,adoption" \

610 --alert-thresholds \

611 --duration 24h \

612 --export-dashboard

613```

614

615#### Release Analytics & Insights

616```bash

617# Analyze release performance and adoption

618npx claude-flow github release-analytics \

619 --version v2.0.0 \

620 --compare-with v1.9.0 \

621 --metrics "adoption,performance,stability,feedback" \

622 --generate-insights \

623 --export-report

624```

625

626#### Automated Rollback Configuration

627```bash

628# Configure intelligent auto-rollback

629npx claude-flow github rollback-config \

630 --triggers '{

631 "error-rate": ">5%",

632 "latency-p99": ">1000ms",

633 "availability": "<99.9%",

634 "failed-health-checks": ">3"

635 }' \

636 --grace-period 5m \

637 --notify-on-rollback \

638 --preserve-metrics

639```

640

641### Security & Compliance

642

643#### Security Scanning

644```bash

645# Comprehensive security validation

646npx claude-flow github release-security \

647 --scan-dependencies \

648 --check-secrets \

649 --audit-permissions \

650 --sign-artifacts \

651 --sbom-generation \

652 --vulnerability-report

653```

654

655#### Compliance Validation

656```bash

657# Ensure regulatory compliance

658npx claude-flow github release-compliance \

659 --standards "SOC2,GDPR,HIPAA" \

660 --license-audit \

661 --data-governance \

662 --audit-trail \

663 --generate-attestation

664```

665

666---

667

668## GitHub Actions Integration

669

670### Complete Release Workflow

671```yaml

672# .github/workflows/release.yml

673name: Intelligent Release Workflow

674on:

675 push:

676 tags: ['v*']

677

678jobs:

679 release-orchestration:

680 runs-on: ubuntu-latest

681 permissions:

682 contents: write

683 packages: write

684 issues: write

685

686 steps:

687 - name: Checkout Repository

688 uses: actions/checkout@v4

689 with:

690 fetch-depth: 0

691

692 - name: Setup Node.js

693 uses: actions/setup-node@v4

694 with:

695 node-version: '20'

696 cache: 'npm'

697

698 - name: Authenticate GitHub CLI

699 run: echo "${{ secrets.GITHUB_TOKEN }}" | gh auth login --with-token

700

701 - name: Initialize Release Swarm

702 run: |

703 # Extract version from tag

704 RELEASE_TAG=${{ github.ref_name }}

705 PREV_TAG=$(gh release list --limit 2 --json tagName -q '.[1].tagName')

706

707 # Get merged PRs for changelog

708 PRS=$(gh pr list --state merged --base main --json number,title,labels,author,mergedAt \

709 --jq ".[] | select(.mergedAt > \"$(gh release view $PREV_TAG --json publishedAt -q .publishedAt)\")")

710

711 # Get commit history

712 COMMITS=$(gh api repos/${{ github.repository }}/compare/${PREV_TAG}...HEAD \

713 --jq '.commits[].commit.message')

714

715 # Initialize swarm coordination

716 npx claude-flow@alpha swarm init --topology hierarchical

717

718 # Store release context

719 echo "$PRS" > /tmp/release-prs.json

720 echo "$COMMITS" > /tmp/release-commits.txt

721

722 - name: Generate Release Changelog

723 run: |

724 # Generate intelligent changelog

725 CHANGELOG=$(npx claude-flow@alpha github changelog \

726 --prs "$(cat /tmp/release-prs.json)" \

727 --commits "$(cat /tmp/release-commits.txt)" \

728 --from $PREV_TAG \

729 --to $RELEASE_TAG \

730 --categorize \

731 --add-migration-guide \

732 --format markdown)

733

734 echo "$CHANGELOG" > RELEASE_CHANGELOG.md

735

736 - name: Build Release Artifacts

737 run: |

738 # Install dependencies

739 npm ci

740

741 # Run comprehensive validation

742 npm run lint

743 npm run typecheck

744 npm run test:all

745 npm run build

746

747 # Build platform-specific binaries

748 npx claude-flow@alpha github release-build \

749 --platforms "linux,macos,windows" \

750 --architectures "x64,arm64" \

751 --parallel

752

753 - name: Security Scan

754 run: |

755 # Run security validation

756 npm audit --audit-level=moderate

757

758 npx claude-flow@alpha github release-security \

759 --scan-dependencies \

760 --check-secrets \

761 --sign-artifacts

762

763 - name: Create GitHub Release

764 run: |

765 # Update release with generated changelog

766 gh release edit ${{ github.ref_name }} \

767 --notes "$(cat RELEASE_CHANGELOG.md)" \

768 --draft=false

769

770 # Upload all artifacts

771 for file in dist/*; do

772 gh release upload ${{ github.ref_name }} "$file"

773 done

774

775 - name: Deploy to Package Registries

776 run: |

777 # Publish to npm

778 echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc

779 npm publish

780

781 # Build and push Docker images

782 docker build -t ${{ github.repository }}:${{ github.ref_name }} .

783 docker push ${{ github.repository }}:${{ github.ref_name }}

784

785 - name: Post-Release Validation

786 run: |

787 # Run smoke tests

788 npm run test:smoke

789

790 # Validate deployment

791 npx claude-flow@alpha github release-validate \

792 --version ${{ github.ref_name }} \

793 --smoke-tests \

794 --health-checks

795

796 - name: Create Release Announcement

797 run: |

798 # Create announcement issue

799 gh issue create \

800 --title "🎉 Released ${{ github.ref_name }}" \

801 --body "$(cat RELEASE_CHANGELOG.md)" \

802 --label "announcement,release"

803

804 # Notify via discussion

805 gh api repos/${{ github.repository }}/discussions \

806 --method POST \

807 -f title="Release ${{ github.ref_name }} Now Available" \

808 -f body="$(cat RELEASE_CHANGELOG.md)" \

809 -f category_id="$(gh api repos/${{ github.repository }}/discussions/categories --jq '.[] | select(.slug=="announcements") | .id')"

810

811 - name: Monitor Release

812 run: |

813 # Start release monitoring

814 npx claude-flow@alpha github release-monitor \

815 --version ${{ github.ref_name }} \

816 --duration 1h \

817 --alert-on-errors &

818```

819

820### Hotfix Workflow

821```yaml

822# .github/workflows/hotfix.yml

823name: Emergency Hotfix Workflow

824on:

825 issues:

826 types: [labeled]

827

828jobs:

829 emergency-hotfix:

830 if: contains(github.event.issue.labels.*.name, 'critical-hotfix')

831 runs-on: ubuntu-latest

832

833 steps:

834 - name: Create Hotfix Branch

835 run: |

836 LAST_STABLE=$(gh release list --limit 1 --json tagName -q '.[0].tagName')

837 HOTFIX_VERSION=$(echo $LAST_STABLE | awk -F. '{print $1"."$2"."$3+1}')

838

839 git checkout -b hotfix/$HOTFIX_VERSION $LAST_STABLE

840

841 - name: Fast-Track Testing

842 run: |

843 npm ci

844 npm run test:critical

845 npm run build

846

847 - name: Emergency Release

848 run: |

849 npx claude-flow@alpha github emergency-release \

850 --issue ${{ github.event.issue.number }} \

851 --severity critical \

852 --fast-track \

853 --notify-all

854```

855

856---

857

858## Best Practices & Patterns

859

860### Release Planning Guidelines

861

862#### 1. Regular Release Cadence

863- **Weekly**: Patch releases with bug fixes

864- **Bi-weekly**: Minor releases with features

865- **Quarterly**: Major releases with breaking changes

866- **On-demand**: Hotfixes for critical issues

867

868#### 2. Feature Freeze Strategy

869- Code freeze 3 days before release

870- Only critical bug fixes allowed

871- Beta testing period for major releases

872- Stakeholder communication plan

873

874#### 3. Version Management Rules

875- Strict semantic versioning compliance

876- Breaking changes only in major versions

877- Deprecation warnings one minor version ahead

878- Cross-package version synchronization

879

880### Automation Recommendations

881

882#### 1. Comprehensive CI/CD Pipeline

883- Automated testing at every stage

884- Security scanning before release

885- Performance benchmarking

886- Documentation generation

887

888#### 2. Progressive Deployment

889- Canary releases for early detection

890- Staged rollouts with monitoring

891- Automated health checks

892- Quick rollback mechanisms

893

894#### 3. Monitoring & Observability

895- Real-time error tracking

896- Performance metrics collection

897- User adoption analytics

898- Feedback collection automation

899

900### Documentation Standards

901

902#### 1. Changelog Requirements

903- Categorized changes by type

904- Breaking changes highlighted

905- Migration guides for major versions

906- Contributor attribution

907

908#### 2. Release Notes Content

909- High-level feature summaries

910- Detailed technical changes

911- Upgrade instructions

912- Known issues and limitations

913

914#### 3. API Documentation

915- Automated API doc generation

916- Example code updates

917- Deprecation notices

918- Version compatibility matrix

919

920---

921

922## Troubleshooting & Common Issues

923

924### Issue: Failed Release Build

925```bash

926# Debug build failures

927npx claude-flow@alpha diagnostic-run \

928 --component build \

929 --verbose

930

931# Retry with isolated environment

932docker run --rm -v $(pwd):/app node:20 \

933 bash -c "cd /app && npm ci && npm run build"

934```

935

936### Issue: Test Failures in CI

937```bash

938# Run tests with detailed output

939npm run test -- --verbose --coverage

940

941# Check for environment-specific issues

942npm run test:ci

943

944# Compare local vs CI environment

945npx claude-flow@alpha github compat-test \

946 --environments "local,ci" \

947 --compare

948```

949

950### Issue: Deployment Rollback Needed

951```bash

952# Immediate rollback to previous version

953npx claude-flow@alpha github rollback \

954 --to-version v1.9.9 \

955 --reason "Critical bug in v2.0.0" \

956 --preserve-data \

957 --notify-users

958

959# Investigate rollback cause

960npx claude-flow@alpha github release-analytics \

961 --version v2.0.0 \

962 --identify-issues

963```

964

965### Issue: Version Conflicts

966```bash

967# Check and resolve version conflicts

968npx claude-flow@alpha github release-validate \

969 --checks version-conflicts \

970 --auto-resolve

971

972# Align multi-package versions

973npx claude-flow@alpha github version-sync \

974 --packages "package-a,package-b" \

975 --strategy semantic

976```

977

978---

979

980## Performance Metrics & Benchmarks

981

982### Expected Performance

983- **Release Planning**: < 2 minutes

984- **Build Process**: 3-8 minutes (varies by project)

985- **Test Execution**: 5-15 minutes

986- **Deployment**: 2-5 minutes per target

987- **Complete Pipeline**: 15-30 minutes

988

989### Optimization Tips

9901. **Parallel Execution**: Use swarm coordination for concurrent tasks

9912. **Caching**: Enable build and dependency caching

9923. **Incremental Builds**: Only rebuild changed components

9934. **Test Optimization**: Run critical tests first, full suite in parallel

994

995### Success Metrics

996- **Release Frequency**: Target weekly minor releases

997- **Lead Time**: < 2 hours from commit to production

998- **Failure Rate**: < 2% of releases require rollback

999- **MTTR**: < 30 minutes for critical hotfixes

1000

1001---

1002

1003## Related Resources

1004

1005### Documentation

1006- [GitHub CLI Documentation](https://cli.github.com/manual/)

1007- [Semantic Versioning Spec](https://semver.org/)

1008- [Claude Flow SPARC Guide](../../docs/sparc-methodology.md)

1009- [Swarm Coordination Patterns](../../docs/swarm-patterns.md)

1010

1011### Related Skills

1012- **github-pr-management**: PR review and merge automation

1013- **github-workflow-automation**: CI/CD workflow orchestration

1014- **multi-repo-coordination**: Cross-repository synchronization

1015- **deployment-orchestration**: Advanced deployment strategies

1016

1017### Support & Community

1018- Issues: https://github.com/ruvnet/claude-flow/issues

1019- Discussions: https://github.com/ruvnet/claude-flow/discussions

1020- Documentation: https://claude-flow.dev/docs

1021

1022---

1023

1024## Appendix: Release Checklist Template

1025

1026### Pre-Release Checklist

1027- [ ] Version numbers updated across all packages

1028- [ ] Changelog generated and reviewed

1029- [ ] Breaking changes documented with migration guide

1030- [ ] All tests passing (unit, integration, e2e)

1031- [ ] Security scan completed with no critical issues

1032- [ ] Performance benchmarks within acceptable range

1033- [ ] Documentation updated (API docs, README, examples)

1034- [ ] Release notes drafted and reviewed

1035- [ ] Stakeholders notified of upcoming release

1036- [ ] Deployment plan reviewed and approved

1037

1038### Release Checklist

1039- [ ] Release branch created and validated

1040- [ ] CI/CD pipeline completed successfully

1041- [ ] Artifacts built and verified

1042- [ ] GitHub release created with proper notes

1043- [ ] Packages published to registries

1044- [ ] Docker images pushed to container registry

1045- [ ] Deployment to staging successful

1046- [ ] Smoke tests passing in staging

1047- [ ] Production deployment completed

1048- [ ] Health checks passing

1049

1050### Post-Release Checklist

1051- [ ] Release announcement published

1052- [ ] Monitoring dashboards reviewed

1053- [ ] Error rates within normal range

1054- [ ] Performance metrics stable

1055- [ ] User feedback collected

1056- [ ] Documentation links verified

1057- [ ] Release retrospective scheduled

1058- [ ] Next release planning initiated

1059

1060---

1061

1062**Version**: 2.0.0

1063**Last Updated**: 2025-10-19

1064**Maintained By**: Claude Flow Team

1065

In the file

SKILL.md3,292 words

Files1

LicenceMIT

Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈50

always loaded

The name and description, so the model knows the skill exists and when to reach for it.

7,250

on trigger

The instruction body, read only when the skill fires.

3.6%

of a 200k window

Ten skills this size would take about 37% of the window before you open a file.

050k100k150k200k context window

7.3k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption

Installsnone yet

Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for

Writes filesno

Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

If this is not it

14 other skills in Cloud & DevOps

What is in the bundle

1 file, 29.2 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

SKILL.md29.2 kB

What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$19 once

GitHub Release Management · MIT · ruvnet

one-time

Price$19 once

LicenceMIT — the author’s, unchanged by this purchase

Paid throughStripe, once, on the card you add at the checkout

Keeps workingfor good — the files are yours once they are on disk

Updatesevery update its author ships, delivered through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are MIT, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/

Claude Desktop

ChatGPT

Cursor.cursor/skills/

VS Code.github/skills/

Codex CLI.agents/skills/

Gemini CLI.gemini/skills/

Grok.grok/skills/

Zed.agents/skills/

Windsurf.windsurf/skills/

Agent SDK.claude/skills/

HTTP / API

This release

Versionnot versioned

Publishedno release date on file

Price$19

Referenceruvnet/github-release-management

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

No earlier releases have been published to the marketplace.

Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

ruvnet

Publishes on mcprush.

0 servers listed20 skills listednot claimed

Profile

Publisher

Servers0