github-workflow-automation

GitHub Workflow Automation Skill

Safety Notice

This listing is imported from skills.sh public index metadata. Review upstream SKILL.md and repository scripts before running.

Copy this and send it to your AI assistant to learn

Install skill "github-workflow-automation" with this command: npx skills add ruvnet/claude-flow/ruvnet-claude-flow-github-workflow-automation

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

Initialize GitHub Workflow Automation

Start with a simple workflow

npx ruv-swarm actions generate-workflow
--analyze-codebase
--detect-languages
--create-optimal-pipeline

Common Commands

Optimize existing workflow

npx ruv-swarm actions optimize
--workflow ".github$workflows$ci.yml"
--suggest-parallelization

Analyze failed runs

gh run view <run-id> --json jobs,conclusion |
npx ruv-swarm actions analyze-failure
--suggest-fixes

<$details>

Core Capabilities

🤖 Swarm-Powered GitHub Modes

  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

Usage example

npx claude-flow@alpha github gh-coordinator
"Coordinate multi-repo release across 5 repositories"

  1. pr-manager

Pull request management and review coordination

  • Review Mode: Automated

  • Multi-reviewer: Yes

  • Conflict Resolution: Intelligent

Create PR with automated review

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"

  1. issue-tracker

Issue management and project coordination

  • Issue Workflow: Automated

  • Label Management: Smart

  • Progress Tracking: Real-time

Create coordinated issue workflow

npx claude-flow@alpha github issue-tracker
"Manage sprint issues with automated tracking"

  1. release-manager

Release coordination and deployment

  • Release Pipeline: Automated

  • Versioning: Semantic

  • Deployment: Multi-stage

Automated release management

npx claude-flow@alpha github release-manager
"Create v2.0.0 release with changelog and deployment"

  1. repo-architect

Repository structure and organization

  • Structure Optimization: Yes

  • Multi-repo Support: Yes

  • Template Management: Advanced

Optimize repository structure

npx claude-flow@alpha github repo-architect
"Restructure monorepo with optimal organization"

  1. code-reviewer

Automated code review and quality assurance

  • Review Quality: Deep

  • Security Analysis: Yes

  • Performance Check: Automated

Automated code review

gh pr view 123 --json files |
npx ruv-swarm actions pr-validate
--deep-review
--security-scan

  1. ci-orchestrator

CI/CD pipeline coordination

  • Pipeline Management: Advanced

  • Test Coordination: Parallel

  • Deployment: Automated

Orchestrate CI/CD pipeline

npx claude-flow@alpha github ci-orchestrator
"Setup parallel test execution with smart caching"

  1. security-guardian

Security and compliance management

  • Security Scan: Automated

  • Compliance Check: Continuous

  • Vulnerability Management: Proactive

Security audit

npx ruv-swarm actions security
--deep-scan
--compliance-check
--create-issues

<$details>

🔧 Workflow Templates

  1. Intelligent CI with Swarms

.github$workflows$swarm-ci.yml

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

.github$workflows$polyglot-swarm.yml

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

.github$workflows$security-swarm.yml

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')" \
          --body "$(_jq '.body')" \
          --label "security,critical"
      done

4. Self-Healing Pipeline

.github$workflows$self-healing.yml

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

  1. Progressive Deployment

.github$workflows$smart-deployment.yml

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

.github$workflows$performance-guard.yml

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

  1. PR Validation Swarm

.github$workflows$pr-validation.yml

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

.github$workflows$intelligent-release.yml

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 Analytics

Analyze workflow performance

npx ruv-swarm actions analytics
--workflow "ci.yml"
--period 30d
--identify-bottlenecks
--suggest-improvements

Cost Optimization

Optimize GitHub Actions costs

npx ruv-swarm actions cost-optimize
--analyze-usage
--suggest-caching
--recommend-self-hosted

Failure Pattern Analysis

Identify failure patterns

npx ruv-swarm actions failure-patterns
--period 90d
--classify-failures
--suggest-preventions

Resource Management

Optimize resource usage

npx ruv-swarm actions resources
--analyze-usage
--suggest-runners
--cost-optimize

<$details>

Advanced Features

🧪 Dynamic Test Strategies

Smart Test Selection

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

Generate test matrix from code analysis

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

test: needs: generate-matrix strategy: matrix: ${{fromJson(needs.generate-matrix.outputs.matrix)}}

Intelligent Parallelization

Determine optimal parallelization

npx ruv-swarm actions parallel-strategy
--analyze-dependencies
--time-estimates
--cost-aware

<$details>

🔮 Predictive Analysis

Predictive Failures

Predict potential failures

npx ruv-swarm actions predict
--analyze-history
--identify-risks
--suggest-preventive

Workflow Recommendations

Get workflow recommendations

npx ruv-swarm actions recommend
--analyze-repo
--suggest-workflows
--industry-best-practices

Automated Optimization

Continuously optimize workflows

npx ruv-swarm actions auto-optimize
--monitor-performance
--apply-improvements
--track-savings

<$details>

🎯 Custom Actions Development

Custom Swarm Action Template

// action.yml name: 'Swarm Custom Action' description: 'Custom swarm-powered action' inputs: task: description: 'Task for swarm' required: true runs: using: 'node16' main: 'dist$index.js'

// 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 => core.setFailed(error.message));

<$details>

Integration with Claude-Flow

🔄 Swarm Coordination Patterns

Initialize GitHub Swarm

// Step 1: Initialize swarm coordination mcp__claude-flow__swarm_init { topology: "hierarchical", maxAgents: 8 }

// Step 2: Spawn specialized agents 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" }

// Step 3: Orchestrate GitHub workflow mcp__claude-flow__task_orchestrate { task: "Complete PR review and merge workflow", strategy: "parallel", priority: "high" }

GitHub Hooks Integration

Pre-task: Setup GitHub context

npx claude-flow@alpha hooks pre-task
--description "PR review workflow"
--context "pr-123"

During task: Track progress

npx claude-flow@alpha hooks notify
--message "Completed security scan"
--type "github-action"

Post-task: Export results

npx claude-flow@alpha hooks post-task
--task-id "pr-review-123"
--export-github-summary

<$details>

📦 Batch Operations

Parallel GitHub CLI Commands

// 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

  1. Use Reusable Workflows

.github$workflows$reusable-swarm.yml

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 }}

  1. Implement Proper Caching
  • name: Cache Swarm Dependencies uses: actions$cache@v3 with: path: ~/.npm key: ${{ runner.os }}-swarm-${{ hashFiles('**$package-lock.json') }}
  1. Set Appropriate Timeouts

jobs: swarm-task: timeout-minutes: 30 steps: - name: Swarm Operation timeout-minutes: 10

  1. 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

  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"
  1. 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
  1. Implement Least-Privilege

permissions: contents: read pull-requests: write issues: write

  1. Audit Swarm Operations
  • name: Audit Swarm Actions run: | npx ruv-swarm actions audit
    --export-logs
    --compliance-report

<$details>

⚡ Performance Optimization

  1. Cache Swarm Dependencies
  • uses: actions$cache@v3 with: path: | ~/.npm node_modules key: ${{ runner.os }}-swarm-${{ hashFiles('**$package-lock.json') }}
  1. Use Appropriate Runner Sizes

jobs: heavy-task: runs-on: ubuntu-latest-4-cores steps: - name: Intensive Swarm Operation

  1. 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
  1. 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 Mode

  • name: Debug Swarm run: | npx ruv-swarm actions debug
    --verbose
    --trace-agents
    --export-logs env: ACTIONS_STEP_DEBUG: true

Performance Profiling

Profile workflow performance

npx ruv-swarm actions profile
--workflow "ci.yml"
--identify-slow-steps
--suggest-optimizations

Failure Analysis

Analyze failed runs

gh run view <run-id> --json jobs,conclusion |
npx ruv-swarm actions analyze-failure
--suggest-fixes
--auto-retry-flaky

Log Analysis

Download and analyze logs

gh run download <run-id> npx ruv-swarm actions analyze-logs
--directory .$logs
--identify-errors

<$details>

Real-World Examples

🚀 Complete Workflows

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

Synchronize multiple repositories

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"

<$details>

Command Reference

📚 Quick Command Guide

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

  • 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

#!$bin$bash

setup-github-automation.sh

Install dependencies

npm install -g claude-flow@alpha

Verify GitHub CLI

gh auth status || gh auth login

Create workflow directory

mkdir -p .github$workflows

Generate initial workflow

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 management

  • release-coordination

  • Release automation

  • swarm-coordination

  • Multi-agent orchestration

  • ci-cd-optimization

  • Pipeline optimization

Support & Documentation

  • GitHub CLI Docs: https:/$cli.github.com$manual/

  • GitHub Actions: https:/$docs.github.com$en$actions

  • Claude-Flow: https:/$github.com$ruvnet$claude-flow

  • Ruv-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

Source Transparency

This detail page is rendered from real SKILL.md content. Trust labels are metadata-based hints, not a safety guarantee.

Open in GitHubOpen in ClawHub

Related Skills

Related by shared tags or category signals.

Coding

github-project-management

No summary provided by upstream source.

Repository SourceNeeds Review
106-ruvnet
Coding

github-code-review

No summary provided by upstream source.

Repository SourceNeeds Review
72-ruvnet
Coding

pair programming

No summary provided by upstream source.

Repository SourceNeeds Review
53-ruvnet
Coding

github-release-management

No summary provided by upstream source.

Repository SourceNeeds Review
51-ruvnet