CrmClinicas/.claude/commands/github/workflow-automation.md

Workflow Automation - GitHub Actions Integration

Overview

Integrate AI swarms with GitHub Actions to create intelligent, self-organizing CI/CD pipelines that adapt to your codebase.

Core Features

1. Swarm-Powered Actions

# .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. Dynamic Workflow Generation

# Generate workflows based on code analysis
npx ruv-swarm actions generate-workflow \
  --analyze-codebase \
  --detect-languages \
  --create-optimal-pipeline

3. Intelligent Test Selection

# Smart test runner
- name: Swarm Test Selection
  run: |
    npx ruv-swarm actions smart-test \
      --changed-files ${{ steps.files.outputs.all }} \
      --impact-analysis \
      --parallel-safe

Workflow Templates

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

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: |
          # Use gh CLI for issue creation
          SECURITY_ISSUES=$(npx ruv-swarm actions security \
            --deep-scan \
            --format json)
          
          # Create issues for complex security problems
          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

Action Commands

Pipeline Optimization

# Optimize existing workflows
npx ruv-swarm actions optimize \
  --workflow ".github/workflows/ci.yml" \
  --suggest-parallelization \
  --reduce-redundancy \
  --estimate-savings

Failure Analysis

# Analyze failed runs using gh CLI
gh run view ${{ github.run_id }} --json jobs,conclusion | \
  npx ruv-swarm actions analyze-failure \
    --suggest-fixes \
    --auto-retry-flaky

# Create issue for persistent failures
if [ $? -ne 0 ]; then
  gh issue create \
    --title "CI Failure: Run ${{ github.run_id }}" \
    --body "Automated analysis detected persistent failures" \
    --label "ci-failure"
fi

Resource Management

# Optimize resource usage
npx ruv-swarm actions resources \
  --analyze-usage \
  --suggest-runners \
  --cost-optimize

Advanced Workflows

1. Self-Healing CI/CD

# Auto-fix common CI failures
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

2. Progressive Deployment

# Intelligent deployment strategy
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

3. Performance Regression Detection

# Automatic performance testing
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

Custom Actions

Swarm Action Development

// 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'));
}

Matrix Strategies

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

Monitoring & Insights

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 Patterns

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

Integration Examples

1. PR Validation Swarm

name: PR Validation Swarm
on: pull_request

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - name: Multi-Agent Validation
        run: |
          # Get PR details using gh CLI
          PR_DATA=$(gh pr view ${{ github.event.pull_request.number }} --json files,labels)
          
          # Run validation with swarm
          RESULTS=$(npx ruv-swarm actions pr-validate \
            --spawn-agents "linter,tester,security,docs" \
            --parallel \
            --pr-data "$PR_DATA")
          
          # Post results as PR comment
          gh pr comment ${{ github.event.pull_request.number }} \
            --body "$RESULTS"

2. Release Automation

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

3. Documentation Updates

name: Auto Documentation
on:
  push:
    paths: ['src/**']

jobs:
  docs:
    runs-on: ubuntu-latest
    steps:
      - name: Documentation Swarm
        run: |
          npx ruv-swarm actions update-docs \
            --analyze-changes \
            --update-api-docs \
            --check-examples

Best Practices

1. Workflow Organization

• Use reusable workflows for swarm operations
• Implement proper caching strategies
• Set appropriate timeouts
• Use workflow dependencies wisely

2. Security

• Store swarm configs in secrets
• Use OIDC for authentication
• Implement least-privilege principles
• Audit swarm operations

3. Performance

• Cache swarm dependencies
• Use appropriate runner sizes
• Implement early termination
• Optimize parallel execution

Advanced Features

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

Debugging & Troubleshooting

Debug Mode

- name: Debug Swarm
  run: |
    npx ruv-swarm actions debug \
      --verbose \
      --trace-agents \
      --export-logs

Performance Profiling

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

See also: swarm-pr.md, release-swarm.md