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

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

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

<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

# Usage example
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: 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"

3. 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"

4. 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"

5. 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"

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

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

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

<details> <summary>Production-Ready GitHub Actions Templates<$summary>

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

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

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