1# Start with a simple workflow
2npx ruv-swarm actions generate-workflow \
3  --analyze-codebase \
4  --detect-languages \
5  --create-optimal-pipeline

1# Optimize existing workflow
2npx ruv-swarm actions optimize \
3  --workflow ".github/workflows/ci.yml" \
4  --suggest-parallelization
5
6# Analyze failed runs
7gh run view <run-id> --json jobs,conclusion | \
8  npx ruv-swarm actions analyze-failure \
9    --suggest-fixes

1# Usage example
2npx claude-flow@alpha github gh-coordinator \
3  "Coordinate multi-repo release across 5 repositories"

1# Create PR with automated review
2gh pr create --title "Feature: New capability" \
3  --body "Automated PR with swarm review" | \
4  npx ruv-swarm actions pr-validate \
5    --spawn-agents "linter,tester,security,docs"

1# Create coordinated issue workflow
2npx claude-flow@alpha github issue-tracker \
3  "Manage sprint issues with automated tracking"

1# Automated release management
2npx claude-flow@alpha github release-manager \
3  "Create v2.0.0 release with changelog and deployment"

1# Optimize repository structure
2npx claude-flow@alpha github repo-architect \
3  "Restructure monorepo with optimal organization"

1# Automated code review
2gh pr view 123 --json files | \
3  npx ruv-swarm actions pr-validate \
4    --deep-review \
5    --security-scan

1# Orchestrate CI/CD pipeline
2npx claude-flow@alpha github ci-orchestrator \
3  "Setup parallel test execution with smart caching"

1# Security audit
2npx ruv-swarm actions security \
3  --deep-scan \
4  --compliance-check \
5  --create-issues

 1# .github/workflows/swarm-ci.yml
 2name: Intelligent CI with Swarms
 3on: [push, pull_request]
 4
 5jobs:
 6  swarm-analysis:
 7    runs-on: ubuntu-latest
 8    steps:
 9      - uses: actions/checkout@v3
10
11      - name: Initialize Swarm
12        uses: ruvnet/swarm-action@v1
13        with:
14          topology: mesh
15          max-agents: 6
16
17      - name: Analyze Changes
18        run: |
19          npx ruv-swarm actions analyze \
20            --commit ${{ github.sha }} \
21            --suggest-tests \
22            --optimize-pipeline

 1# .github/workflows/polyglot-swarm.yml
 2name: Polyglot Project Handler
 3on: push
 4
 5jobs:
 6  detect-and-build:
 7    runs-on: ubuntu-latest
 8    steps:
 9      - uses: actions/checkout@v3
10
11      - name: Detect Languages
12        id: detect
13        run: |
14          npx ruv-swarm actions detect-stack \
15            --output json > stack.json
16
17      - name: Dynamic Build Matrix
18        run: |
19          npx ruv-swarm actions create-matrix \
20            --from stack.json \
21            --parallel-builds

 1# .github/workflows/security-swarm.yml
 2name: Intelligent Security Scan
 3on:
 4  schedule:
 5    - cron: '0 0 * * *'
 6  workflow_dispatch:
 7
 8jobs:
 9  security-swarm:
10    runs-on: ubuntu-latest
11    steps:
12      - name: Security Analysis Swarm
13        run: |
14          SECURITY_ISSUES=$(npx ruv-swarm actions security \
15            --deep-scan \
16            --format json)
17
18          echo "$SECURITY_ISSUES" | jq -r '.issues[]? | @base64' | while read -r issue; do
19            _jq() {
20              echo ${issue} | base64 --decode | jq -r ${1}
21            }
22            gh issue create \
23              --title "$(_jq '.title')" \
24              --body "$(_jq '.body')" \
25              --label "security,critical"
26          done

 1# .github/workflows/self-healing.yml
 2name: Self-Healing Pipeline
 3on: workflow_run
 4
 5jobs:
 6  heal-pipeline:
 7    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
 8    runs-on: ubuntu-latest
 9    steps:
10      - name: Diagnose and Fix
11        run: |
12          npx ruv-swarm actions self-heal \
13            --run-id ${{ github.event.workflow_run.id }} \
14            --auto-fix-common \
15            --create-pr-complex

 1# .github/workflows/smart-deployment.yml
 2name: Smart Deployment
 3on:
 4  push:
 5    branches: [main]
 6
 7jobs:
 8  progressive-deploy:
 9    runs-on: ubuntu-latest
10    steps:
11      - name: Analyze Risk
12        id: risk
13        run: |
14          npx ruv-swarm actions deploy-risk \
15            --changes ${{ github.sha }} \
16            --history 30d
17
18      - name: Choose Strategy
19        run: |
20          npx ruv-swarm actions deploy-strategy \
21            --risk ${{ steps.risk.outputs.level }} \
22            --auto-execute

 1# .github/workflows/performance-guard.yml
 2name: Performance Guard
 3on: pull_request
 4
 5jobs:
 6  perf-swarm:
 7    runs-on: ubuntu-latest
 8    steps:
 9      - name: Performance Analysis
10        run: |
11          npx ruv-swarm actions perf-test \
12            --baseline main \
13            --threshold 10% \
14            --auto-profile-regression

 1# .github/workflows/pr-validation.yml
 2name: PR Validation Swarm
 3on: pull_request
 4
 5jobs:
 6  validate:
 7    runs-on: ubuntu-latest
 8    steps:
 9      - name: Multi-Agent Validation
10        run: |
11          PR_DATA=$(gh pr view ${{ github.event.pull_request.number }} --json files,labels)
12
13          RESULTS=$(npx ruv-swarm actions pr-validate \
14            --spawn-agents "linter,tester,security,docs" \
15            --parallel \
16            --pr-data "$PR_DATA")
17
18          gh pr comment ${{ github.event.pull_request.number }} \
19            --body "$RESULTS"

 1# .github/workflows/intelligent-release.yml
 2name: Intelligent Release
 3on:
 4  push:
 5    tags: ['v*']
 6
 7jobs:
 8  release:
 9    runs-on: ubuntu-latest
10    steps:
11      - name: Release Swarm
12        run: |
13          npx ruv-swarm actions release \
14            --analyze-changes \
15            --generate-notes \
16            --create-artifacts \
17            --publish-smart

1# Analyze workflow performance
2npx ruv-swarm actions analytics \
3  --workflow "ci.yml" \
4  --period 30d \
5  --identify-bottlenecks \
6  --suggest-improvements

1# Optimize GitHub Actions costs
2npx ruv-swarm actions cost-optimize \
3  --analyze-usage \
4  --suggest-caching \
5  --recommend-self-hosted

1# Identify failure patterns
2npx ruv-swarm actions failure-patterns \
3  --period 90d \
4  --classify-failures \
5  --suggest-preventions

1# Optimize resource usage
2npx ruv-swarm actions resources \
3  --analyze-usage \
4  --suggest-runners \
5  --cost-optimize

1# Automatically select relevant tests
2- name: Swarm Test Selection
3  run: |
4    npx ruv-swarm actions smart-test \
5      --changed-files ${{ steps.files.outputs.all }} \
6      --impact-analysis \
7      --parallel-safe

 1# Generate test matrix from code analysis
 2jobs:
 3  generate-matrix:
 4    outputs:
 5      matrix: ${{ steps.set-matrix.outputs.matrix }}
 6    steps:
 7      - id: set-matrix
 8        run: |
 9          MATRIX=$(npx ruv-swarm actions test-matrix \
10            --detect-frameworks \
11            --optimize-coverage)
12          echo "matrix=${MATRIX}" >> $GITHUB_OUTPUT
13
14  test:
15    needs: generate-matrix
16    strategy:
17      matrix: ${{fromJson(needs.generate-matrix.outputs.matrix)}}

1# Determine optimal parallelization
2npx ruv-swarm actions parallel-strategy \
3  --analyze-dependencies \
4  --time-estimates \
5  --cost-aware

1# Predict potential failures
2npx ruv-swarm actions predict \
3  --analyze-history \
4  --identify-risks \
5  --suggest-preventive

1# Get workflow recommendations
2npx ruv-swarm actions recommend \
3  --analyze-repo \
4  --suggest-workflows \
5  --industry-best-practices

1# Continuously optimize workflows
2npx ruv-swarm actions auto-optimize \
3  --monitor-performance \
4  --apply-improvements \
5  --track-savings

 1// action.yml
 2name: 'Swarm Custom Action'
 3description: 'Custom swarm-powered action'
 4inputs:
 5  task:
 6    description: 'Task for swarm'
 7    required: true
 8runs:
 9  using: 'node16'
10  main: 'dist/index.js'
11
12// index.js
13const { SwarmAction } = require('ruv-swarm');
14
15async function run() {
16  const swarm = new SwarmAction({
17    topology: 'mesh',
18    agents: ['analyzer', 'optimizer']
19  });
20
21  await swarm.execute(core.getInput('task'));
22}
23
24run().catch(error => core.setFailed(error.message));

 1// Step 1: Initialize swarm coordination
 2mcp__claude-flow__swarm_init {
 3  topology: "hierarchical",
 4  maxAgents: 8
 5}
 6
 7// Step 2: Spawn specialized agents
 8mcp__claude-flow__agent_spawn { type: "coordinator", name: "GitHub Coordinator" }
 9mcp__claude-flow__agent_spawn { type: "reviewer", name: "Code Reviewer" }
10mcp__claude-flow__agent_spawn { type: "tester", name: "QA Agent" }
11mcp__claude-flow__agent_spawn { type: "analyst", name: "Security Analyst" }
12
13// Step 3: Orchestrate GitHub workflow
14mcp__claude-flow__task_orchestrate {
15  task: "Complete PR review and merge workflow",
16  strategy: "parallel",
17  priority: "high"
18}

 1# Pre-task: Setup GitHub context
 2npx claude-flow@alpha hooks pre-task \
 3  --description "PR review workflow" \
 4  --context "pr-123"
 5
 6# During task: Track progress
 7npx claude-flow@alpha hooks notify \
 8  --message "Completed security scan" \
 9  --type "github-action"
10
11# Post-task: Export results
12npx claude-flow@alpha hooks post-task \
13  --task-id "pr-review-123" \
14  --export-github-summary

 1// Single message with all GitHub operations
 2[Concurrent Execution]:
 3  Bash("gh issue create --title 'Feature A' --body 'Description A' --label 'enhancement'")
 4  Bash("gh issue create --title 'Feature B' --body 'Description B' --label 'enhancement'")
 5  Bash("gh pr create --title 'PR 1' --head 'feature-a' --base 'main'")
 6  Bash("gh pr create --title 'PR 2' --head 'feature-b' --base 'main'")
 7  Bash("gh pr checks 123 --watch")
 8  TodoWrite { todos: [
 9    {content: "Review security scan results", status: "pending"},
10    {content: "Merge approved PRs", status: "pending"},
11    {content: "Update changelog", status: "pending"}
12  ]}

 1# .github/workflows/reusable-swarm.yml
 2name: Reusable Swarm Workflow
 3on:
 4  workflow_call:
 5    inputs:
 6      topology:
 7        required: true
 8        type: string
 9
10jobs:
11  swarm-task:
12    runs-on: ubuntu-latest
13    steps:
14      - name: Initialize Swarm
15        run: |
16          npx ruv-swarm init --topology ${{ inputs.topology }}

1- name: Cache Swarm Dependencies
2  uses: actions/cache@v3
3  with:
4    path: ~/.npm
5    key: ${{ runner.os }}-swarm-${{ hashFiles('**/package-lock.json') }}

1jobs:
2  swarm-task:
3    timeout-minutes: 30
4    steps:
5      - name: Swarm Operation
6        timeout-minutes: 10

 1jobs:
 2  setup:
 3    runs-on: ubuntu-latest
 4
 5  test:
 6    needs: setup
 7    runs-on: ubuntu-latest
 8
 9  deploy:
10    needs: [setup, test]
11    runs-on: ubuntu-latest

1- name: Setup Swarm
2  env:
3    SWARM_CONFIG: ${{ secrets.SWARM_CONFIG }}
4    API_KEY: ${{ secrets.API_KEY }}
5  run: |
6    npx ruv-swarm init --config "$SWARM_CONFIG"

1permissions:
2  id-token: write
3  contents: read
4
5- name: Configure AWS Credentials
6  uses: aws-actions/configure-aws-credentials@v2
7  with:
8    role-to-assume: arn:aws:iam::123456789012:role/GitHubAction
9    aws-region: us-east-1

1permissions:
2  contents: read
3  pull-requests: write
4  issues: write

1- name: Audit Swarm Actions
2  run: |
3    npx ruv-swarm actions audit \
4      --export-logs \
5      --compliance-report

1- uses: actions/cache@v3
2  with:
3    path: |
4      ~/.npm
5      node_modules
6    key: ${{ runner.os }}-swarm-${{ hashFiles('**/package-lock.json') }}

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

1- name: Quick Fail Check
2  run: |
3    if ! npx ruv-swarm actions pre-check; then
4      echo "Pre-check failed, terminating early"
5      exit 1
6    fi

 1strategy:
 2  matrix:
 3    include:
 4      - runner: ubuntu-latest
 5        task: test
 6      - runner: ubuntu-latest
 7        task: lint
 8      - runner: ubuntu-latest
 9        task: security
10  max-parallel: 3

1- name: Debug Swarm
2  run: |
3    npx ruv-swarm actions debug \
4      --verbose \
5      --trace-agents \
6      --export-logs
7  env:
8    ACTIONS_STEP_DEBUG: true

1# Profile workflow performance
2npx ruv-swarm actions profile \
3  --workflow "ci.yml" \
4  --identify-slow-steps \
5  --suggest-optimizations

1# Analyze failed runs
2gh run view <run-id> --json jobs,conclusion | \
3  npx ruv-swarm actions analyze-failure \
4    --suggest-fixes \
5    --auto-retry-flaky

1# Download and analyze logs
2gh run download <run-id>
3npx ruv-swarm actions analyze-logs \
4  --directory ./logs \
5  --identify-errors

 1name: Full-Stack CI/CD with Swarms
 2on:
 3  push:
 4    branches: [main, develop]
 5  pull_request:
 6
 7jobs:
 8  initialize:
 9    runs-on: ubuntu-latest
10    outputs:
11      swarm-id: ${{ steps.init.outputs.swarm-id }}
12    steps:
13      - id: init
14        run: |
15          SWARM_ID=$(npx ruv-swarm init --topology mesh --output json | jq -r '.id')
16          echo "swarm-id=${SWARM_ID}" >> $GITHUB_OUTPUT
17
18  backend:
19    needs: initialize
20    runs-on: ubuntu-latest
21    steps:
22      - uses: actions/checkout@v3
23      - name: Backend Tests
24        run: |
25          npx ruv-swarm agents spawn --type tester \
26            --task "Run backend test suite" \
27            --swarm-id ${{ needs.initialize.outputs.swarm-id }}
28
29  frontend:
30    needs: initialize
31    runs-on: ubuntu-latest
32    steps:
33      - uses: actions/checkout@v3
34      - name: Frontend Tests
35        run: |
36          npx ruv-swarm agents spawn --type tester \
37            --task "Run frontend test suite" \
38            --swarm-id ${{ needs.initialize.outputs.swarm-id }}
39
40  security:
41    needs: initialize
42    runs-on: ubuntu-latest
43    steps:
44      - uses: actions/checkout@v3
45      - name: Security Scan
46        run: |
47          npx ruv-swarm agents spawn --type security \
48            --task "Security audit" \
49            --swarm-id ${{ needs.initialize.outputs.swarm-id }}
50
51  deploy:
52    needs: [backend, frontend, security]
53    if: github.ref == 'refs/heads/main'
54    runs-on: ubuntu-latest
55    steps:
56      - name: Deploy
57        run: |
58          npx ruv-swarm actions deploy \
59            --strategy progressive \
60            --swarm-id ${{ needs.initialize.outputs.swarm-id }}

 1name: Monorepo Coordination
 2on: push
 3
 4jobs:
 5  detect-changes:
 6    runs-on: ubuntu-latest
 7    outputs:
 8      packages: ${{ steps.detect.outputs.packages }}
 9    steps:
10      - uses: actions/checkout@v3
11        with:
12          fetch-depth: 0
13
14      - id: detect
15        run: |
16          PACKAGES=$(npx ruv-swarm actions detect-changes \
17            --monorepo \
18            --output json)
19          echo "packages=${PACKAGES}" >> $GITHUB_OUTPUT
20
21  build-packages:
22    needs: detect-changes
23    runs-on: ubuntu-latest
24    strategy:
25      matrix:
26        package: ${{ fromJson(needs.detect-changes.outputs.packages) }}
27    steps:
28      - name: Build Package
29        run: |
30          npx ruv-swarm actions build \
31            --package ${{ matrix.package }} \
32            --parallel-deps

1# Synchronize multiple repositories
2npx claude-flow@alpha github sync-coordinator \
3  "Synchronize version updates across:
4   - github.com/org/repo-a
5   - github.com/org/repo-b
6   - github.com/org/repo-c
7
8   Update dependencies, align versions, create PRs"

1npx ruv-swarm actions generate-workflow [options]
2  --analyze-codebase       Analyze repository structure
3  --detect-languages       Detect programming languages
4  --create-optimal-pipeline Generate optimized workflow

1npx ruv-swarm actions optimize [options]
2  --workflow <path>        Path to workflow file
3  --suggest-parallelization Suggest parallel execution
4  --reduce-redundancy      Remove redundant steps
5  --estimate-savings       Estimate time/cost savings

1npx ruv-swarm actions analyze [options]
2  --commit <sha>           Analyze specific commit
3  --suggest-tests          Suggest test improvements
4  --optimize-pipeline      Optimize pipeline structure

1npx ruv-swarm actions smart-test [options]
2  --changed-files <files>  Files that changed
3  --impact-analysis        Analyze test impact
4  --parallel-safe          Only parallel-safe tests

1npx ruv-swarm actions security [options]
2  --deep-scan             Deep security analysis
3  --format <format>       Output format (json/text)
4  --create-issues         Auto-create GitHub issues

1npx ruv-swarm actions deploy [options]
2  --strategy <type>       Deployment strategy
3  --risk <level>          Risk assessment level
4  --auto-execute          Execute automatically

1npx ruv-swarm actions analytics [options]
2  --workflow <name>       Workflow to analyze
3  --period <duration>     Analysis period
4  --identify-bottlenecks  Find bottlenecks
5  --suggest-improvements  Improvement suggestions

 1#!/bin/bash
 2# setup-github-automation.sh
 3
 4# Install dependencies
 5npm install -g claude-flow@alpha
 6
 7# Verify GitHub CLI
 8gh auth status || gh auth login
 9
10# Create workflow directory
11mkdir -p .github/workflows
12
13# Generate initial workflow
14npx ruv-swarm actions generate-workflow \
15  --analyze-codebase \
16  --create-optimal-pipeline > .github/workflows/ci.yml
17
18echo "✅ GitHub workflow automation setup complete"