npm - monomind - Versions diffs - 1.6.0 → 1.6.1 - Mend

monomind 1.6.0 → 1.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1234) hide show

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

@@ -1,1111 +0,0 @@
----
-name: github-workflow-automation
-description: |
-  Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management
----
-# 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 monomind@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 monomind@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 monomind@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 monomind@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 monomind@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@v1
-      - name: Initialize Swarm
-        uses: nokhodian/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@v1
-      - 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 Monomind
-### 🔄 Swarm Coordination Patterns
-<details>
-<summary>MCP-Based GitHub Workflow Coordination</summary>
-#### Initialize GitHub Swarm
-```javascript
-// Step 1: Initialize swarm coordination
-mcp__monomind__swarm_init {
-  topology: "hierarchical",
-  maxAgents: 8
-}
-// Step 2: Spawn specialized agents
-mcp__monomind__agent_spawn { type: "coordinator", name: "GitHub Coordinator" }
-mcp__monomind__agent_spawn { type: "reviewer", name: "Code Reviewer" }
-mcp__monomind__agent_spawn { type: "tester", name: "QA Agent" }
-mcp__monomind__agent_spawn { type: "analyst", name: "Security Analyst" }
-// Step 3: Orchestrate GitHub workflow
-mcp__monomind__task_orchestrate {
-  task: "Complete PR review and merge workflow",
-  strategy: "parallel",
-  priority: "high"
-}
-```
-#### GitHub Hooks Integration
-```bash
-# Pre-task: Setup GitHub context
-npx monomind@alpha hooks pre-task \
-  --description "PR review workflow" \
-  --context "pr-123"
-# During task: Track progress
-npx monomind@alpha hooks notify \
-  --message "Completed security scan" \
-  --type "github-action"
-# Post-task: Export results
-npx monomind@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@v1
-  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@v1
-  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@v1
-      - 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@v1
-      - 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@v1
-      - 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@v1
-        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 monomind@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
-- [ ] `monomind@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 monomind@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
-- **Monomind**: https://github.com/nokhodian/monomind
-- **Ruv-Swarm**: https://github.com/nokhodian/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**: monomind team