Skip to main content Início Criadores ruvnet ruflo github-workflow-automation
github-workflow-automation Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management
Ir para a instalação Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/ruvnet/ruflo --skill github-workflow-automationO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... 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.
Ocupações relacionadas SOC
Baseado na classificação ocupacional 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
