Claude Skill

github-workflow-automation

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

LLM Mart · 0 points · 2 views 50 listing impressions 0 install-command copies

#security #deployment

Download spencermarx-open-code-review-.claude_skills_github-workflow-automation-a793b05.zip · 6 KB

Install

skills CLI npx skills add https://github.com/spencermarx/open-code-review/tree/main/.claude/skills/github-workflow-automation
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install spencermarx-open-code-review@llmmart
Git git clone https://github.com/spencermarx/open-code-review.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole spencermarx/open-code-review collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

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

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

Core Capabilities

🤖 Swarm-Powered GitHub Modes

Available GitHub Integration 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"

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

🔧 Workflow Templates

Production-Ready GitHub Actions 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

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

📊 Monitoring & Analytics

Workflow Analysis & Optimization

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

Advanced Features

🧪 Dynamic Test Strategies

Intelligent Test Selection & Execution

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

🔮 Predictive Analysis

AI-Powered Workflow Predictions

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

🎯 Custom Actions Development

Build Your Own Swarm Actions

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));

Integration with Claude-Flow

🔄 Swarm Coordination Patterns

MCP-Based GitHub Workflow Coordination

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

📦 Batch Operations

Concurrent GitHub 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"}
  ]}

Best Practices

🏗️ Workflow Organization

Structure Your GitHub Workflows

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

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

🔒 Security Best Practices

Secure Your GitHub Workflows

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

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

Debugging & Troubleshooting

🐛 Debug Tools

Debug GitHub Workflow Issues

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

Real-World Examples

🚀 Complete Workflows

Production-Ready Integration Examples

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"

Command Reference

📚 Quick Command Guide

All Available Commands

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

Integration Checklist

✅ Setup Verification

Verify Your Setup
  • 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"

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

Files (open-code-review)
  • SKILL.md 23.3 KB
    ---
    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
    
    <details>
    <summary>💡 Basic Usage - Click to expand</summary>
    
    ### Initialize GitHub Workflow Automation
    ```bash
    # Start with a simple workflow
    npx ruv-swarm actions generate-workflow \
      --analyze-codebase \
      --detect-languages \
      --create-optimal-pipeline
    ```
    
    ### Common Commands
    ```bash
    # 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
    
    ```bash
    # 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
    
    ```bash
    # 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
    
    ```bash
    # 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
    
    ```bash
    # 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
    
    ```bash
    # 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
    
    ```bash
    # 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
    
    ```bash
    # 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
    
    ```bash
    # 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
    ```yaml
    # .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
    ```yaml
    # .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
    ```yaml
    # .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
    ```yaml
    # .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
    ```yaml
    # .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
    ```yaml
    # .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
    ```yaml
    # .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
    ```yaml
    # .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
    
    <details>
    <summary>Workflow Analysis & Optimization</summary>
    
    #### Workflow Analytics
    ```bash
    # Analyze workflow performance
    npx ruv-swarm actions analytics \
      --workflow "ci.yml" \
      --period 30d \
      --identify-bottlenecks \
      --suggest-improvements
    ```
    
    #### Cost Optimization
    ```bash
    # Optimize GitHub Actions costs
    npx ruv-swarm actions cost-optimize \
      --analyze-usage \
      --suggest-caching \
      --recommend-self-hosted
    ```
    
    #### Failure Pattern Analysis
    ```bash
    # Identify failure patterns
    npx ruv-swarm actions failure-patterns \
      --period 90d \
      --classify-failures \
      --suggest-preventions
    ```
    
    #### Resource Management
    ```bash
    # Optimize resource usage
    npx 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 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
    ```bash
    # Determine optimal parallelization
    npx 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 failures
    npx ruv-swarm actions predict \
      --analyze-history \
      --identify-risks \
      --suggest-preventive
    ```
    
    #### Workflow Recommendations
    ```bash
    # Get workflow recommendations
    npx ruv-swarm actions recommend \
      --analyze-repo \
      --suggest-workflows \
      --industry-best-practices
    ```
    
    #### Automated Optimization
    ```bash
    # Continuously optimize workflows
    npx 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.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
    
    <details>
    <summary>MCP-Based GitHub Workflow Coordination</summary>
    
    #### Initialize GitHub Swarm
    ```javascript
    // 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
    ```bash
    # 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
    
    <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.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 }}
    ```
    
    #### 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 performance
    npx ruv-swarm actions profile \
      --workflow "ci.yml" \
      --identify-slow-steps \
      --suggest-optimizations
    ```
    
    #### Failure Analysis
    ```bash
    # Analyze failed runs
    gh run view <run-id> --json jobs,conclusion | \
      npx ruv-swarm actions analyze-failure \
        --suggest-fixes \
        --auto-retry-flaky
    ```
    
    #### Log Analysis
    ```bash
    # 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
    
    <details>
    <summary>Production-Ready Integration Examples</summary>
    
    #### Example 1: Full-Stack Application CI/CD
    ```yaml
    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
    ```yaml
    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
    ```bash
    # 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
    
    <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 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
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.