Menu
Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
| name | github-workflow-automation |
| description | Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management |
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.
# Start with a simple workflow
npx ruv-swarm actions generate-workflow \
--analyze-codebase \
--detect-languages \
--create-optimal-pipeline
# 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
GitHub workflow orchestration and coordination
# Usage example
npx claude-flow@alpha github gh-coordinator \
"Coordinate multi-repo release across 5 repositories"
Pull request management and review coordination
# 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"
Issue management and project coordination
# Create coordinated issue workflow
npx claude-flow@alpha github issue-tracker \
"Manage sprint issues with automated tracking"
Release coordination and deployment
# Automated release management
npx claude-flow@alpha github release-manager \
"Create v2.0.0 release with changelog and deployment"
Repository structure and organization
# Optimize repository structure
npx claude-flow@alpha github repo-architect \
"Restructure monorepo with optimal organization"
Automated code review and quality assurance
# Automated code review
gh pr view 123 --json files | \
npx ruv-swarm actions pr-validate \
--deep-review \
--security-scan
CI/CD pipeline coordination
# Orchestrate CI/CD pipeline
npx claude-flow@alpha github ci-orchestrator \
"Setup parallel test execution with smart caching"
Security and compliance management
# Security audit
npx ruv-swarm actions security \
--deep-scan \
--compliance-check \
--create-issues
# .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@v4
- 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
# .github/workflows/polyglot-swarm.yml
name: Polyglot Project Handler
on: push
jobs:
detect-and-build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- 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
# .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
# .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
# .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
# .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
# .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"
# .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
# Analyze workflow performance
npx ruv-swarm actions analytics \
--workflow "ci.yml" \
--period 30d \
--identify-bottlenecks \
--suggest-improvements
# Optimize GitHub Actions costs
npx ruv-swarm actions cost-optimize \
--analyze-usage \
--suggest-caching \
--recommend-self-hosted
# Identify failure patterns
npx ruv-swarm actions failure-patterns \
--period 90d \
--classify-failures \
--suggest-preventions
# Optimize resource usage
npx ruv-swarm actions resources \
--analyze-usage \
--suggest-runners \
--cost-optimize
# 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
# 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)}}
# Determine optimal parallelization
npx ruv-swarm actions parallel-strategy \
--analyze-dependencies \
--time-estimates \
--cost-aware
# Predict potential failures
npx ruv-swarm actions predict \
--analyze-history \
--identify-risks \
--suggest-preventive
# Get workflow recommendations
npx ruv-swarm actions recommend \
--analyze-repo \
--suggest-workflows \
--industry-best-practices
# Continuously optimize workflows
npx ruv-swarm actions auto-optimize \
--monitor-performance \
--apply-improvements \
--track-savings
// 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));
// Step 1: Initialize swarm coordination
mcp__ruflo__swarm_init {
topology: "hierarchical",
maxAgents: 8
}
// Step 2: Spawn specialized agents
mcp__ruflo__agent_spawn { type: "coordinator", name: "GitHub Coordinator" }
mcp__ruflo__agent_spawn { type: "reviewer", name: "Code Reviewer" }
mcp__ruflo__agent_spawn { type: "tester", name: "QA Agent" }
mcp__ruflo__agent_spawn { type: "analyst", name: "Security Analyst" }
// Step 3: Orchestrate GitHub workflow
mcp__ruflo__task_orchestrate {
task: "Complete PR review and merge workflow",
strategy: "parallel",
priority: "high"
}
# 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
// 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"}
]}
# .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 }}
- name: Cache Swarm Dependencies
uses: actions/cache@v3
with:
path: ~/.npm
key: ${{ runner.os }}-swarm-${{ hashFiles('**/package-lock.json') }}
jobs:
swarm-task:
timeout-minutes: 30
steps:
- name: Swarm Operation
timeout-minutes: 10
jobs:
setup:
runs-on: ubuntu-latest
test:
needs: setup
runs-on: ubuntu-latest
deploy:
needs: [setup, test]
runs-on: ubuntu-latest
- name: Setup Swarm
env:
SWARM_CONFIG: ${{ secrets.SWARM_CONFIG }}
API_KEY: ${{ secrets.API_KEY }}
run: |
npx ruv-swarm init --config "$SWARM_CONFIG"
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
permissions:
contents: read
pull-requests: write
issues: write
- name: Audit Swarm Actions
run: |
npx ruv-swarm actions audit \
--export-logs \
--compliance-report
- uses: actions/cache@v3
with:
path: |
~/.npm
node_modules
key: ${{ runner.os }}-swarm-${{ hashFiles('**/package-lock.json') }}
jobs:
heavy-task:
runs-on: ubuntu-latest-4-cores
steps:
- name: Intensive Swarm Operation
- name: Quick Fail Check
run: |
if ! npx ruv-swarm actions pre-check; then
echo "Pre-check failed, terminating early"
exit 1
fi
strategy:
matrix:
include:
- runner: ubuntu-latest
task: test
- runner: ubuntu-latest
task: lint
- runner: ubuntu-latest
task: security
max-parallel: 3
- name: Debug Swarm
run: |
npx ruv-swarm actions debug \
--verbose \
--trace-agents \
--export-logs
env:
ACTIONS_STEP_DEBUG: true
# Profile workflow performance
npx ruv-swarm actions profile \
--workflow "ci.yml" \
--identify-slow-steps \
--suggest-optimizations
# Analyze failed runs
gh run view <run-id> --json jobs,conclusion | \
npx ruv-swarm actions analyze-failure \
--suggest-fixes \
--auto-retry-flaky
# Download and analyze logs
gh run download <run-id>
npx ruv-swarm actions analyze-logs \
--directory ./logs \
--identify-errors
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@v4
- 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@v4
- 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@v4
- 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 }}
name: Monorepo Coordination
on: push
jobs:
detect-changes:
runs-on: ubuntu-latest
outputs:
packages: ${{ steps.detect.outputs.packages }}
steps:
- uses: actions/checkout@v4
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
# 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"
npx ruv-swarm actions generate-workflow [options]
--analyze-codebase Analyze repository structure
--detect-languages Detect programming languages
--create-optimal-pipeline Generate optimized workflow
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
npx ruv-swarm actions analyze [options]
--commit <sha> Analyze specific commit
--suggest-tests Suggest test improvements
--optimize-pipeline Optimize pipeline structure
npx ruv-swarm actions smart-test [options]
--changed-files <files> Files that changed
--impact-analysis Analyze test impact
--parallel-safe Only parallel-safe tests
npx ruv-swarm actions security [options]
--deep-scan Deep security analysis
--format <format> Output format (json/text)
--create-issues Auto-create GitHub issues
npx ruv-swarm actions deploy [options]
--strategy <type> Deployment strategy
--risk <level> Risk assessment level
--auto-execute Execute automatically
npx ruv-swarm actions analytics [options]
--workflow <name> Workflow to analyze
--period <duration> Analysis period
--identify-bottlenecks Find bottlenecks
--suggest-improvements Improvement suggestions
gh) installed and authenticatedclaude-flow@alpha package available.github/workflows directory#!/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"
github-pr-enhancement - Advanced PR managementrelease-coordination - Release automationswarm-coordination - Multi-agent orchestrationci-cd-optimization - Pipeline optimizationSkill Status: ✅ Production Ready Last Updated: 2025-01-19 Maintainer: claude-flow team
Build or rebuild the ADR index + dependency graph in AgentDB by running the in-process `agentdb index` command (one cold-start, all surfaces in one pass — no per-record npx round-trips). Handles v3-style and plugin-style ADR formats.
Create a new Architecture Decision Record with sequential numbering and AgentDB registration
Hive Mind orchestration patterns — queen-led multi-agent coordination with Byzantine/Raft/Gossip/CRDT consensus, typed collective memory, dialectic council, and session checkpoint/resume. Use for decision-bearing work; use swarm-advanced for parallel execution without consensus.
Analyze git diffs for risk scoring, reviewer recommendations, and change classification
Detect missing test coverage and generate test suggestions
Hive Mind orchestration patterns — queen-led multi-agent coordination with Byzantine/Raft/Gossip/CRDT consensus, typed collective memory, dialectic council, and session checkpoint/resume. Use for decision-bearing work; use swarm-advanced for parallel execution without consensus.