agentic-flow 1.9.0 → 1.9.1

package/.claude/skills/github-workflow-automation/SKILL.md

@@ -1,1065 +0,0 @@
----
-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