Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/ruvnet/ruflo --skill github-workflow-automationLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Plus depuis ce dépôt Ruflo is a multi-agent orchestration platform for AI coding agents (Claude Code, Cursor, Codex, Copilot, Gemini, Amp, +12 more). Use this skill when the user wants to (1) install/init ruflo in a project, (2) run multi-agent swarms with hierarchical coordination, (3) use ruflo's 314+ MCP tools for memory, routing, hooks, sub-agents, or workflows, (4) check ruflo status/version/doctor health, or (5) discover which of ruflo's 30+ plugins fits their task.
Multi-repository coordination, synchronization, and architecture management with AI swarm orchestration
github-release-management Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management
Métiers associés SOC
Basé sur la classification professionnelle SOC
name github-workflow-automation version 1.0.0 category github description Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management tags ["github","github-actions","ci-cd","workflow-automation","swarm-coordination","deployment","security"] authors ["claude-flow"] requires ["gh (GitHub CLI)","git","claude-flow@alpha","node (v16+)"] priority high progressive_disclosure true
GitHub Workflow Automation Skill
Overview
This skill provides comprehensive GitHub Actions automation with AI swarm coordination. It integrates intelligent CI/CD pipelines, workflow orchestration, and repository management to create self-organizing, adaptive GitHub workflows.
Quick Start
💡 Basic Usage - Click to expand<$summary>
Initialize GitHub Workflow Automation
npx ruv-swarm actions generate-workflow \
--analyze-codebase \
--detect-languages \
--create-optimal-pipeline
Common Commands
npx ruv-swarm actions optimize \
--workflow ".github$workflows$ci .yml" \
--suggest-parallelization
gh run view <run-id> --json jobs ,conclusion | \
npx ruv-swarm actions analyze-failure \
--suggest-fixes
<$details>
Core Capabilities
🤖 Swarm-Powered GitHub Modes
Available GitHub Integration Modes<$summary>
1. gh-coordinator
GitHub workflow orchestration and coordination
Coordination Mode : HierarchicalMax Parallel Operations : 10Batch Optimized : YesBest For : Complex GitHub workflows, multi-repo coordination
npx claude-flow@alpha github gh-coordinator \
"Coordinate multi-repo release across 5 repositories"
2. pr-manager
Pull request management and review coordination
Review Mode : AutomatedMulti-reviewer : YesConflict Resolution : Intelligent
gh pr create --title "Feature: New capability" \
--body "Automated PR with swarm review" | \
npx ruv-swarm actions pr-validate \
--spawn-agents "linter,tester,security,docs"
3. issue-tracker Issue management and project coordination
Issue Workflow : AutomatedLabel Management : SmartProgress Tracking : Real-time
npx claude-flow@alpha github issue-tracker \
"Manage sprint issues with automated tracking"
4. release-manager Release coordination and deployment
Release Pipeline : AutomatedVersioning : SemanticDeployment : Multi-stage
npx claude-flow@alpha github release-manager \
"Create v2.0.0 release with changelog and deployment"
5. repo-architect Repository structure and organization
Structure Optimization : YesMulti-repo Support : YesTemplate Management : Advanced
npx claude-flow@alpha github repo-architect \
"Restructure monorepo with optimal organization"
6. code-reviewer Automated code review and quality assurance
Review Quality : DeepSecurity Analysis : YesPerformance Check : Automated
gh pr view 123 --json files | \
npx ruv-swarm actions pr-validate \
--deep-review \
--security-scan
7. ci-orchestrator CI/CD pipeline coordination
Pipeline Management : AdvancedTest Coordination : ParallelDeployment : Automated
npx claude-flow@alpha github ci-orchestrator \
"Setup parallel test execution with smart caching"
8. security-guardian Security and compliance management
Security Scan : AutomatedCompliance Check : ContinuousVulnerability Management : Proactive
npx ruv-swarm actions security \
--deep-scan \
--compliance-check \
--create-issues
🔧 Workflow Templates
Production-Ready GitHub Actions Templates<$summary>
1. Intelligent CI with Swarms
name: Intelligent CI with Swarms
on: [push , pull_request ]
jobs:
swarm-analysis:
runs-on: ubuntu-latest
steps:
- uses: actions$checkout@v3
- name: Initialize Swarm
uses: ruvnet$swarm-action@v1
with:
topology: mesh
max-agents: 6
- name: Analyze Changes
run: |
npx ruv-swarm actions analyze \
--commit ${{ github.sha }} \
--suggest-tests \
--optimize-pipeline
2. Multi-Language Detection
name: Polyglot Project Handler
on: push
jobs:
detect-and-build:
runs-on: ubuntu-latest
steps:
- uses: actions$checkout@v3
- name: Detect Languages
id: detect
run: |
npx ruv-swarm actions detect-stack \
--output json > stack.json
- name: Dynamic Build Matrix
run: |
npx ruv-swarm actions create-matrix \
--from stack.json \
--parallel-builds
3. Adaptive Security Scanning
name: Intelligent Security Scan
on:
schedule:
- cron: '0 0 * * *'
workflow_dispatch:
jobs:
security-swarm:
runs-on: ubuntu-latest
steps:
- name: Security Analysis Swarm
run: |
SECURITY_ISSUES=$(npx ruv-swarm actions security \
--deep-scan \
--format json)
echo "$SECURITY_ISSUES" | jq -r '.issues[]? | @base64' | while read -r issue; do
_jq() {
echo $ {issue } | base64 --decode | jq -r $ {1 }
}
gh issue create \
--title "$(_jq '.title')" \
4. Self-Healing Pipeline
name: Self-Healing Pipeline
on: workflow_run
jobs:
heal-pipeline:
if: ${{ github.event.workflow_run.conclusion == 'failure' }}
runs-on: ubuntu-latest
steps:
- name: Diagnose and Fix
run: |
npx ruv-swarm actions self-heal \
--run-id ${{ github.event.workflow_run.id }} \
--auto-fix-common \
--create-pr-complex
5. Progressive Deployment
name: Smart Deployment
on:
push:
branches: [main ]
jobs:
progressive-deploy:
runs-on: ubuntu-latest
steps:
- name: Analyze Risk
id: risk
run: |
npx ruv-swarm actions deploy-risk \
--changes ${{ github.sha }} \
--history 30d
- name: Choose Strategy
run: |
npx ruv-swarm actions deploy-strategy \
--risk ${{ steps.risk.outputs.level }} \
--auto-execute
6. Performance Regression Detection
name: Performance Guard
on: pull_request
jobs:
perf-swarm:
runs-on: ubuntu-latest
steps:
- name: Performance Analysis
run: |
npx ruv-swarm actions perf-test \
--baseline main \
--threshold 10% \
--auto-profile-regression
7. PR Validation Swarm
name: PR Validation Swarm
on: pull_request
jobs:
validate:
runs-on: ubuntu-latest
steps:
- name: Multi-Agent Validation
run: |
PR_DATA=$(gh pr view ${{ github.event.pull_request.number }} --json files,labels)
RESULTS=$(npx ruv-swarm actions pr-validate \
--spawn-agents "linter,tester,security,docs" \
--parallel \
--pr-data "$PR_DATA" )
gh pr comment ${{ github.event.pull_request.number }} \
--body "$RESULTS"
8. Intelligent Release
name: Intelligent Release
on:
push:
tags: ['v*' ]
jobs:
release:
runs-on: ubuntu-latest
steps:
- name: Release Swarm
run: |
npx ruv-swarm actions release \
--analyze-changes \
--generate-notes \
--create-artifacts \
--publish-smart
<$details>
📊 Monitoring & Analytics
Workflow Analysis & Optimization<$summary>
Workflow Analytics
npx ruv-swarm actions analytics \
--workflow "ci.yml" \
--period 30d \
--identify-bottlenecks \
--suggest-improvements
Cost Optimization
npx ruv-swarm actions cost-optimize \
--analyze-usage \
--suggest-caching \
--recommend-self-hosted
Failure Pattern Analysis
npx ruv-swarm actions failure-patterns \
--period 90d \
--classify-failures \
--suggest-preventions
Resource Management
npx ruv-swarm actions resources \
--analyze-usage \
--suggest-runners \
--cost-optimize
<$details>
Advanced Features
🧪 Dynamic Test Strategies
Intelligent Test Selection & Execution<$summary>
Smart Test Selection
- name: Swarm Test Selection
run: |
npx ruv-swarm actions smart-test \
--changed-files ${{ steps.files.outputs.all }} \
--impact-analysis \
--parallel-safe
Dynamic Test Matrix
jobs:
generate-matrix:
outputs:
matrix: ${{ steps.set-matrix.outputs.matrix }}
steps:
- id: set-matrix
run: |
MATRIX=$(npx ruv-swarm actions test-matrix \
--detect-frameworks \
--optimize-coverage)
echo "matrix=${MATRIX}" >> $GITHUB_OUTPUT
--body
"$(_jq '.body')"
\
--label
"security,critical"
done
test:
needs:
generate-matrix
strategy:
matrix:
${{fromJson(needs.generate-matrix.outputs.matrix)}}
Intelligent Parallelization
npx ruv-swarm actions parallel-strategy \
--analyze-dependencies \
--time-estimates \
--cost-aware
🔮 Predictive Analysis
AI-Powered Workflow Predictions<$summary>
Predictive Failures
npx ruv-swarm actions predict \
--analyze-history \
--identify-risks \
--suggest-preventive
Workflow Recommendations
npx ruv-swarm actions recommend \
--analyze-repo \
--suggest-workflows \
--industry-best-practices
Automated Optimization
npx ruv-swarm actions auto-optimize \
--monitor-performance \
--apply-improvements \
--track-savings
<$details>
🎯 Custom Actions Development
Build Your Own Swarm Actions<$summary>
Custom Swarm Action Template
name : 'Swarm Custom Action'
description : 'Custom swarm-powered action'
inputs :
task :
description : 'Task for swarm'
required : true
runs :
using : 'node16'
main : 'dist$index.js'
const { SwarmAction } = require ('ruv-swarm' );
async function run (const swarm = new SwarmAction ({
topology : 'mesh' ,
agents : ['analyzer' , 'optimizer' ]
});
await swarm.execute (core.getInput ('task' ));
}
run ().catch (error =>setFailed (error.message ));
<$details>
Integration with Claude-Flow
🔄 Swarm Coordination Patterns
MCP-Based GitHub Workflow Coordination<$summary>
Initialize GitHub Swarm
mcp__claude-flow__swarm_init {
topology : "hierarchical" ,
maxAgents : 8
}
mcp__claude-flow__agent_spawn { type : "coordinator" , name : "GitHub Coordinator" }
mcp__claude-flow__agent_spawn { type : "reviewer" , name : "Code Reviewer" }
mcp__claude-flow__agent_spawn { type : "tester" , name : "QA Agent" }
mcp__claude-flow__agent_spawn { type : "analyst" , name : "Security Analyst" }
mcp__claude-flow__task_orchestrate {
task : "Complete PR review and merge workflow" ,
strategy : "parallel" ,
priority : "high"
}
GitHub Hooks Integration
npx claude-flow@alpha hooks pre-task \
--description "PR review workflow" \
--context "pr-123"
npx claude-flow@alpha hooks notify \
--message "Completed security scan" \
--type "github-action"
npx claude-flow@alpha hooks post-task \
--task-id "pr-review-123" \
--export-github-summary
<$details>
📦 Batch Operations
Concurrent GitHub Operations<$summary>
Parallel GitHub CLI Commands
[Concurrent Execution ]:
Bash ("gh issue create --title 'Feature A' --body 'Description A' --label 'enhancement'" )
Bash ("gh issue create --title 'Feature B' --body 'Description B' --label 'enhancement'" )
Bash ("gh pr create --title 'PR 1' --head 'feature-a' --base 'main'" )
Bash ("gh pr create --title 'PR 2' --head 'feature-b' --base 'main'" )
Bash ("gh pr checks 123 --watch" )
TodoWrite { todos : [
{content : "Review security scan results" , status : "pending" },
{content : "Merge approved PRs" , status : "pending" },
{content : "Update changelog" , status : "pending" }
]}
Best Practices
🏗️ Workflow Organization
Structure Your GitHub Workflows<$summary>
1. Use Reusable Workflows
name: Reusable Swarm Workflow
on:
workflow_call:
inputs:
topology:
required: true
type: string
jobs:
swarm-task:
runs-on: ubuntu-latest
steps:
- name: Initialize Swarm
run: |
npx ruv-swarm init --topology ${{ inputs.topology }}
2. Implement Proper Caching
- name: Cache Swarm Dependencies
uses: actions$cache@v3
with:
path: ~/.npm
key: ${{ runner.os }}-swarm-${{ hashFiles('**$package-lock.json') }}
3. Set Appropriate Timeouts
jobs:
swarm-task:
timeout-minutes: 30
steps:
- name: Swarm Operation
timeout-minutes: 10
4. Use Workflow Dependencies
jobs:
setup:
runs-on: ubuntu-latest
test:
needs: setup
runs-on: ubuntu-latest
deploy:
needs: [setup , test ]
runs-on: ubuntu-latest
<$details>
🔒 Security Best Practices
Secure Your GitHub Workflows<$summary>
1. Store Configurations Securely
- name: Setup Swarm
env:
SWARM_CONFIG: ${{ secrets.SWARM_CONFIG }}
API_KEY: ${{ secrets.API_KEY }}
run: |
npx ruv-swarm init --config "$SWARM_CONFIG"
2. Use OIDC Authentication
permissions:
id-token: write
contents: read
- name: Configure AWS Credentials
uses: aws-actions$configure-aws-credentials@v2
with:
role-to-assume: arn:aws:iam::123456789012:role/GitHubAction
aws-region: us-east-1
3. Implement Least-Privilege
permissions:
contents: read
pull-requests: write
issues: write
4. Audit Swarm Operations
- name: Audit Swarm Actions
run: |
npx ruv-swarm actions audit \
--export-logs \
--compliance-report
⚡ Performance Optimization
Maximize Workflow Performance<$summary>
1. Cache Swarm Dependencies
- uses: actions$cache@v3
with:
path: |
~/.npm
node_modules
key: ${{ runner.os }}-swarm-${{ hashFiles('**$package-lock.json') }}
2. Use Appropriate Runner Sizes
jobs:
heavy-task:
runs-on: ubuntu-latest-4-cores
steps:
- name: Intensive Swarm Operation
3. Implement Early Termination
- name: Quick Fail Check
run: |
if ! npx ruv-swarm actions pre-check; then
echo "Pre-check failed, terminating early"
exit 1
fi
4. Optimize Parallel Execution
strategy:
matrix:
include:
- runner: ubuntu-latest
task: test
- runner: ubuntu-latest
task: lint
- runner: ubuntu-latest
task: security
max-parallel: 3
<$details>
Debugging & Troubleshooting
🐛 Debug Tools
Debug GitHub Workflow Issues<$summary>
Debug Mode
- name: Debug Swarm
run: |
npx ruv-swarm actions debug \
--verbose \
--trace-agents \
--export-logs
env:
ACTIONS_STEP_DEBUG: true
Performance Profiling
npx ruv-swarm actions profile \
--workflow "ci.yml" \
--identify-slow-steps \
--suggest-optimizations
Failure Analysis
gh run view <run-id> --json jobs ,conclusion | \
npx ruv-swarm actions analyze-failure \
--suggest-fixes \
--auto-retry-flaky
Log Analysis
gh run download <run-id>
npx ruv-swarm actions analyze-logs \
--directory .$logs \
--identify-errors
<$details>
Real-World Examples
🚀 Complete Workflows
Production-Ready Integration Examples<$summary>
Example 1: Full-Stack Application CI/CD
name: Full-Stack CI/CD with Swarms
on:
push:
branches: [main , develop ]
pull_request:
jobs:
initialize:
runs-on: ubuntu-latest
outputs:
swarm-id: ${{ steps.init.outputs.swarm-id }}
steps:
-
id:
init
run:
|
SWARM_ID=$(npx ruv-swarm init --topology mesh --output json | jq -r '.id')
echo "swarm-id=${SWARM_ID}" >> $GITHUB_OUTPUT
backend:
needs:
initialize
runs-on:
ubuntu-latest
steps:
-
uses:
actions$checkout@v3
-
name:
Backend
Tests
run:
|
npx ruv-swarm agents spawn --type tester \
--task "Run backend test suite" \
--swarm-id ${{ needs.initialize.outputs.swarm-id }}
frontend:
needs:
initialize
runs-on:
ubuntu-latest
steps:
-
uses:
actions$checkout@v3
-
name:
Frontend
Tests
run:
|
npx ruv-swarm agents spawn --type tester \
--task "Run frontend test suite" \
--swarm-id ${{ needs.initialize.outputs.swarm-id }}
security:
needs:
initialize
runs-on:
ubuntu-latest
steps:
-
uses:
actions$checkout@v3
-
name:
Security
Scan
run:
|
npx ruv-swarm agents spawn --type security \
--task "Security audit" \
--swarm-id ${{ needs.initialize.outputs.swarm-id }}
deploy:
needs:
backend
frontend
security
if:
github.ref
==
'refs$heads$main'
runs-on:
ubuntu-latest
steps:
-
name:
Deploy
run:
|
npx ruv-swarm actions deploy \
--strategy progressive \
--swarm-id ${{ needs.initialize.outputs.swarm-id }}
Example 2: Monorepo Management name: Monorepo Coordination
on: push
jobs:
detect-changes:
runs-on: ubuntu-latest
outputs:
packages: ${{ steps.detect.outputs.packages }}
steps:
- uses: actions$checkout@v3
with:
fetch-depth: 0
- id: detect
run: |
PACKAGES=$(npx ruv-swarm actions detect-changes \
--monorepo \
--output json)
echo "packages=${PACKAGES}" >> $GITHUB_OUTPUT
build-packages:
needs: detect-changes
runs-on: ubuntu-latest
strategy:
matrix:
package: ${{ fromJson(needs.detect-changes.outputs.packages) }}
steps:
- name: Build Package
run: |
npx ruv-swarm actions build \
--package ${{ matrix.package }} \
--parallel-deps
Example 3: Multi-Repo Synchronization
npx claude-flow@alpha github sync-coordinator \
"Synchronize version updates across:
- github.com$org$repo -a
- github.com$org$repo -b
- github.com$org$repo -c
Update dependencies, align versions, create PRs"
Command Reference
📚 Quick Command Guide
All Available Commands<$summary>
Workflow Generation
npx ruv-swarm actions generate-workflow [options]
--analyze-codebase Analyze repository structure
--detect-languages Detect programming languages
--create-optimal-pipeline Generate optimized workflow
Optimization
npx ruv-swarm actions optimize [options]
--workflow <path> Path to workflow file
--suggest-parallelization Suggest parallel execution
--reduce-redundancy Remove redundant steps
--estimate-savings Estimate time $cost savings
Analysis
npx ruv-swarm actions analyze [options]
--commit <sha> Analyze specific commit
--suggest-tests Suggest test improvements
--optimize-pipeline Optimize pipeline structure
Testing
npx ruv-swarm actions smart-test [options]
--changed-files <files> Files that changed
--impact-analysis Analyze test impact
--parallel-safe Only parallel-safe tests
Security
npx ruv-swarm actions security [options]
--deep-scan Deep security analysis
--format <format> Output format (json$text )
--create-issues Auto-create GitHub issues
Deployment
npx ruv-swarm actions deploy [options]
--strategy <type > Deployment strategy
--risk <level> Risk assessment level
--auto-execute Execute automatically
Monitoring
npx ruv-swarm actions analytics [options]
--workflow <name> Workflow to analyze
--period <duration> Analysis period
--identify-bottlenecks Find bottlenecks
--suggest-improvements Improvement suggestions
<$details>
Integration Checklist
✅ Setup Verification
Verify Your Setup<$summary>
Quick Setup Script
npm install -g claude-flow@alpha
gh auth status || gh auth login
mkdir -p .github$workflows
npx ruv-swarm actions generate-workflow \
--analyze-codebase \
--create-optimal-pipeline > .github$workflows$ci .yml
echo "✅ GitHub workflow automation setup complete"
<$details>
Related Skills
github-pr-enhancement - Advanced PR managementrelease-coordination - Release automationswarm-coordination - Multi-agent orchestrationci-cd-optimization - Pipeline optimization
Support & Documentation
GitHub CLI Docs : https:/$cli.github.com$manual/GitHub Actions : https:/$docs.github.com$en$actionsClaude-Flow : https:/$github.com$ruvnet$claude-flowRuv-Swarm : https:/$github.com$ruvnet$ruv-swarm
Version History
v1.0.0 (2025-01-19): Initial skill consolidation
Merged workflow-automation.md (441 lines)
Merged github-modes.md (146 lines)
Added progressive disclosure
Enhanced with swarm coordination patterns
Added comprehensive examples and best practices
Skill Status : ✅ Production Ready
Last Updated : 2025-01-19
Maintainer : claude-flow team
