Github Workflow Automation

by ruvnet60de638630abNo license74K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated today

Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management

Instructions only

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

<details> <summary>💡 Basic Usage - Click to expand</summary>

Initialize GitHub Workflow Automation

bash
# Start with a simple workflownpx ruv-swarm actions generate-workflow \  --analyze-codebase \  --detect-languages \  --create-optimal-pipeline

Common Commands

bash
# Optimize existing workflownpx ruv-swarm actions optimize \  --workflow ".github/workflows/ci.yml" \  --suggest-parallelization
# Analyze failed runsgh run view <run-id> --json jobs,conclusion | \  npx ruv-swarm actions analyze-failure \    --suggest-fixes
</details>

Core Capabilities

🤖 Swarm-Powered GitHub Modes

<details> <summary>Available GitHub Integration Modes</summary>
1. gh-coordinator

GitHub workflow orchestration and coordination

  • Coordination Mode: Hierarchical
  • Max Parallel Operations: 10
  • Batch Optimized: Yes
  • Best For: Complex GitHub workflows, multi-repo coordination
bash
# Usage examplenpx claude-flow@alpha github gh-coordinator \  "Coordinate multi-repo release across 5 repositories"
2. pr-manager

Pull request management and review coordination

  • Review Mode: Automated
  • Multi-reviewer: Yes
  • Conflict Resolution: Intelligent
bash
# Create PR with automated reviewgh 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: Automated
  • Label Management: Smart
  • Progress Tracking: Real-time
bash
# Create coordinated issue workflownpx claude-flow@alpha github issue-tracker \  "Manage sprint issues with automated tracking"
4. release-manager

Release coordination and deployment

  • Release Pipeline: Automated
  • Versioning: Semantic
  • Deployment: Multi-stage
bash
# Automated release managementnpx claude-flow@alpha github release-manager \  "Create v2.0.0 release with changelog and deployment"
5. repo-architect

Repository structure and organization

  • Structure Optimization: Yes
  • Multi-repo Support: Yes
  • Template Management: Advanced
bash
# Optimize repository structurenpx claude-flow@alpha github repo-architect \  "Restructure monorepo with optimal organization"
6. code-reviewer

Automated code review and quality assurance

  • Review Quality: Deep
  • Security Analysis: Yes
  • Performance Check: Automated
bash
# Automated code reviewgh pr view 123 --json files | \  npx ruv-swarm actions pr-validate \    --deep-review \    --security-scan
7. ci-orchestrator

CI/CD pipeline coordination

  • Pipeline Management: Advanced
  • Test Coordination: Parallel
  • Deployment: Automated
bash
# Orchestrate CI/CD pipelinenpx claude-flow@alpha github ci-orchestrator \  "Setup parallel test execution with smart caching"
8. security-guardian

Security and compliance management

  • Security Scan: Automated
  • Compliance Check: Continuous
  • Vulnerability Management: Proactive
bash
# Security auditnpx ruv-swarm actions security \  --deep-scan \  --compliance-check \  --create-issues
</details>

🔧 Workflow Templates

<details> <summary>Production-Ready GitHub Actions Templates</summary>
1. Intelligent CI with Swarms
yaml
# .github/workflows/swarm-ci.ymlname: Intelligent CI with Swarmson: [push, pull_request]
jobs:  swarm-analysis:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4
      - 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
yaml
# .github/workflows/polyglot-swarm.ymlname: Polyglot Project Handleron: push
jobs:  detect-and-build:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4
      - 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
yaml
# .github/workflows/security-swarm.ymlname: Intelligent Security Scanon:  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')" \              --body "$(_jq '.body')" \              --label "security,critical"          done
4. Self-Healing Pipeline
yaml
# .github/workflows/self-healing.ymlname: Self-Healing Pipelineon: 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
yaml
# .github/workflows/smart-deployment.ymlname: Smart Deploymenton:  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
yaml
# .github/workflows/performance-guard.ymlname: Performance Guardon: 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
yaml
# .github/workflows/pr-validation.ymlname: PR Validation Swarmon: 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
yaml
# .github/workflows/intelligent-release.ymlname: Intelligent Releaseon:  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

<details> <summary>Workflow Analysis & Optimization</summary>
Workflow Analytics
bash
# Analyze workflow performancenpx ruv-swarm actions analytics \  --workflow "ci.yml" \  --period 30d \  --identify-bottlenecks \  --suggest-improvements
Cost Optimization
bash
# Optimize GitHub Actions costsnpx ruv-swarm actions cost-optimize \  --analyze-usage \  --suggest-caching \  --recommend-self-hosted
Failure Pattern Analysis
bash
# Identify failure patternsnpx ruv-swarm actions failure-patterns \  --period 90d \  --classify-failures \  --suggest-preventions
Resource Management
bash
# Optimize resource usagenpx ruv-swarm actions resources \  --analyze-usage \  --suggest-runners \  --cost-optimize
</details>

Advanced Features

🧪 Dynamic Test Strategies

<details> <summary>Intelligent Test Selection & Execution</summary>
Smart Test Selection
yaml
# Automatically select relevant tests- name: Swarm Test Selection  run: |    npx ruv-swarm actions smart-test \      --changed-files ${{ steps.files.outputs.all }} \      --impact-analysis \      --parallel-safe
Dynamic Test Matrix
yaml
# Generate test matrix from code analysisjobs:  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
  test:    needs: generate-matrix    strategy:      matrix: ${{fromJson(needs.generate-matrix.outputs.matrix)}}
Intelligent Parallelization
bash
# Determine optimal parallelizationnpx ruv-swarm actions parallel-strategy \  --analyze-dependencies \  --time-estimates \  --cost-aware
</details>

🔮 Predictive Analysis

<details> <summary>AI-Powered Workflow Predictions</summary>
Predictive Failures
bash
# Predict potential failuresnpx ruv-swarm actions predict \  --analyze-history \  --identify-risks \  --suggest-preventive
Workflow Recommendations
bash
# Get workflow recommendationsnpx ruv-swarm actions recommend \  --analyze-repo \  --suggest-workflows \  --industry-best-practices
Automated Optimization
bash
# Continuously optimize workflowsnpx ruv-swarm actions auto-optimize \  --monitor-performance \  --apply-improvements \  --track-savings
</details>

🎯 Custom Actions Development

<details> <summary>Build Your Own Swarm Actions</summary>
Custom Swarm Action Template
javascript
// action.ymlname: 'Swarm Custom Action'description: 'Custom swarm-powered action'inputs:  task:    description: 'Task for swarm'    required: trueruns:  using: 'node16'  main: 'dist/index.js'
// index.jsconst { 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 => core.setFailed(error.message));
</details>

Integration with Claude-Flow

🔄 Swarm Coordination Patterns

<details> <summary>MCP-Based GitHub Workflow Coordination</summary>
Initialize GitHub Swarm
javascript
// Step 1: Initialize swarm coordinationmcp__claude-flow__swarm_init {  topology: "hierarchical",  maxAgents: 8}
// Step 2: Spawn specialized agentsmcp__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" }
// Step 3: Orchestrate GitHub workflowmcp__claude-flow__task_orchestrate {  task: "Complete PR review and merge workflow",  strategy: "parallel",  priority: "high"}
GitHub Hooks Integration
bash
# Pre-task: Setup GitHub contextnpx claude-flow@alpha hooks pre-task \  --description "PR review workflow" \  --context "pr-123"
# During task: Track progressnpx claude-flow@alpha hooks notify \  --message "Completed security scan" \  --type "github-action"
# Post-task: Export resultsnpx claude-flow@alpha hooks post-task \  --task-id "pr-review-123" \  --export-github-summary
</details>

📦 Batch Operations

<details> <summary>Concurrent GitHub Operations</summary>
Parallel GitHub CLI Commands
javascript
// Single message with all GitHub operations[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"}  ]}
</details>

Best Practices

🏗️ Workflow Organization

<details> <summary>Structure Your GitHub Workflows</summary>
1. Use Reusable Workflows
yaml
# .github/workflows/reusable-swarm.ymlname: Reusable Swarm Workflowon:  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
yaml
- name: Cache Swarm Dependencies  uses: actions/cache@v3  with:    path: ~/.npm    key: ${{ runner.os }}-swarm-${{ hashFiles('**/package-lock.json') }}
3. Set Appropriate Timeouts
yaml
jobs:  swarm-task:    timeout-minutes: 30    steps:      - name: Swarm Operation        timeout-minutes: 10
4. Use Workflow Dependencies
yaml
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

<details> <summary>Secure Your GitHub Workflows</summary>
1. Store Configurations Securely
yaml
- 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
yaml
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
yaml
permissions:  contents: read  pull-requests: write  issues: write
4. Audit Swarm Operations
yaml
- name: Audit Swarm Actions  run: |    npx ruv-swarm actions audit \      --export-logs \      --compliance-report
</details>

⚡ Performance Optimization

<details> <summary>Maximize Workflow Performance</summary>
1. Cache Swarm Dependencies
yaml
- uses: actions/cache@v3  with:    path: |      ~/.npm      node_modules    key: ${{ runner.os }}-swarm-${{ hashFiles('**/package-lock.json') }}
2. Use Appropriate Runner Sizes
yaml
jobs:  heavy-task:    runs-on: ubuntu-latest-4-cores    steps:      - name: Intensive Swarm Operation
3. Implement Early Termination
yaml
- 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
yaml
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

<details> <summary>Debug GitHub Workflow Issues</summary>
Debug Mode
yaml
- name: Debug Swarm  run: |    npx ruv-swarm actions debug \      --verbose \      --trace-agents \      --export-logs  env:    ACTIONS_STEP_DEBUG: true
Performance Profiling
bash
# Profile workflow performancenpx ruv-swarm actions profile \  --workflow "ci.yml" \  --identify-slow-steps \  --suggest-optimizations
Failure Analysis
bash
# Analyze failed runsgh run view <run-id> --json jobs,conclusion | \  npx ruv-swarm actions analyze-failure \    --suggest-fixes \    --auto-retry-flaky
Log Analysis
bash
# Download and analyze logsgh run download <run-id>npx ruv-swarm actions analyze-logs \  --directory ./logs \  --identify-errors
</details>

Real-World Examples

🚀 Complete Workflows

<details> <summary>Production-Ready Integration Examples</summary>
Example 1: Full-Stack Application CI/CD
yaml
name: Full-Stack CI/CD with Swarmson:  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@v4      - 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@v4      - 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@v4      - 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
yaml
name: Monorepo Coordinationon: push
jobs:  detect-changes:    runs-on: ubuntu-latest    outputs:      packages: ${{ steps.detect.outputs.packages }}    steps:      - uses: actions/checkout@v4        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
bash
# Synchronize multiple repositoriesnpx 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"
</details>

Command Reference

📚 Quick Command Guide

<details> <summary>All Available Commands</summary>
Workflow Generation
bash
npx ruv-swarm actions generate-workflow [options]  --analyze-codebase       Analyze repository structure  --detect-languages       Detect programming languages  --create-optimal-pipeline Generate optimized workflow
Optimization
bash
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
bash
npx ruv-swarm actions analyze [options]  --commit <sha>           Analyze specific commit  --suggest-tests          Suggest test improvements  --optimize-pipeline      Optimize pipeline structure
Testing
bash
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
bash
npx ruv-swarm actions security [options]  --deep-scan             Deep security analysis  --format <format>       Output format (json/text)  --create-issues         Auto-create GitHub issues
Deployment
bash
npx ruv-swarm actions deploy [options]  --strategy <type>       Deployment strategy  --risk <level>          Risk assessment level  --auto-execute          Execute automatically
Monitoring
bash
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

<details> <summary>Verify Your Setup</summary>
  • GitHub CLI (gh) installed and authenticated
  • Git configured with user credentials
  • Node.js v16+ installed
  • claude-flow@alpha package available
  • Repository has .github/workflows directory
  • GitHub Actions enabled on repository
  • Necessary secrets configured
  • Runner permissions verified
Quick Setup Script
bash
#!/bin/bash# setup-github-automation.sh
# Install dependenciesnpm install -g claude-flow@alpha
# Verify GitHub CLIgh auth status || gh auth login
# Create workflow directorymkdir -p .github/workflows
# Generate initial workflownpx 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 management
  • release-coordination - Release automation
  • swarm-coordination - Multi-agent orchestration
  • ci-cd-optimization - Pipeline optimization

Support & Documentation

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

Source and attribution

Source:ruvnet/rufloin.claude/skills/github-workflow-automationat commit60de638

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

More from ruvnet/ruflo

Cron Schedule

ruvnet

Schedules persistent background workers using CronCreate with recommended cron intervals for recurring tasks.

DevOps & Cloud74Kupdated today

Autopilot Predict

ruvnet

Predicts the next task to work on using Ruflo autopilot MCP tools and learned patterns.

AI & Agents74Kupdated today

Autopilot Loop

ruvnet

Runs one autonomous autopilot iteration: checks status, executes the predicted task, logs it, and schedules the next wake.

AI & Agents74Kupdated today

Worker Integration

ruvnet

Coordinates background workers with specialized agents, mapping triggers to agents and tracking performance.

AI & Agents74Kupdated today

Worker Benchmarks

ruvnet

Runs performance benchmarks for the agentic-flow worker system and reports latency, throughput and memory metrics.

Software Development74Kupdated today

Swarm Advanced

ruvnet

Guides advanced Claude Flow swarm orchestration patterns for research, development, testing and analysis workflows.

AI & Agents74Kupdated today