monomind 2.7.12 → 2.7.13

package/packages/@monomind/cli/.claude/agents/github/multi-repo-swarm.md

@@ -1,525 +0,0 @@
----
-name: multi-repo-swarm
-description: Cross-repository swarm orchestration for organization-wide automation and intelligent collaboration
-tools: Bash, Read, Write, Edit, Glob, Grep, LS, TodoWrite, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__swarm_status, mcp__monomind__memory_usage, mcp__monomind__github_repo_analyze, mcp__monomind__github_pr_manage, mcp__monomind__github_sync_coord, mcp__monomind__github_metrics
----
-
-# Multi-Repo Swarm - Cross-Repository Swarm Orchestration
-
-## Overview
-Coordinate AI swarms across multiple repositories, enabling organization-wide automation and intelligent cross-project collaboration.
-
-## Core Features
-
-### 1. Cross-Repo Initialization
-```bash
-# Initialize multi-repo swarm with gh CLI
-# List organization repositories
-REPOS=$(gh repo list org --limit 100 --json name,description,languages \
-  --jq '.[] | select(.name | test("frontend|backend|shared"))')
-
-# Get repository details
-REPO_DETAILS=$(echo "$REPOS" | jq -r '.name' | while read -r repo; do
-  gh api repos/org/$repo --jq '{name, default_branch, languages, topics}'
-done | jq -s '.')
-
-# Initialize swarm with repository context
-npx monomind github multi-repo-init \
-  --repo-details "$REPO_DETAILS" \
-  --repos "org/frontend,org/backend,org/shared" \
-  --topology hierarchical \
-  --shared-memory \
-  --sync-strategy eventual
-```
-
-### 2. Repository Discovery
-```bash
-# Auto-discover related repositories with gh CLI
-# Search organization repositories
-REPOS=$(gh repo list my-organization --limit 100 \
-  --json name,description,languages,topics \
-  --jq '.[] | select(.languages | keys | contains(["TypeScript"]))')
-
-# Analyze repository dependencies
-DEPS=$(echo "$REPOS" | jq -r '.name' | while read -r repo; do
-  # Get package.json if it exists
-  if gh api repos/my-organization/$repo/contents/package.json --jq '.content' 2>/dev/null; then
-    gh api repos/my-organization/$repo/contents/package.json \
-      --jq '.content' | base64 -d | jq '{name, dependencies, devDependencies}'
-  fi
-done | jq -s '.')
-
-# Discover and analyze
-npx monomind github discover-repos \
-  --repos "$REPOS" \
-  --dependencies "$DEPS" \
-  --analyze-dependencies \
-  --suggest-swarm-topology
-```
-
-### 3. Synchronized Operations
-```bash
-# Execute synchronized changes across repos with gh CLI
-# Get matching repositories
-MATCHING_REPOS=$(gh repo list org --limit 100 --json name \
-  --jq '.[] | select(.name | test("-service$")) | .name')
-
-# Execute task and create PRs
-echo "$MATCHING_REPOS" | while read -r repo; do
-  # Clone repo
-  gh repo clone org/$repo /tmp/$repo -- --depth=1
-  
-  # Execute task
-  cd /tmp/$repo
-  npx monomind github task-execute \
-    --task "update-dependencies" \
-    --repo "org/$repo"
-  
-  # Create PR if changes exist
-  if [[ -n $(git status --porcelain) ]]; then
-    git checkout -b update-dependencies-$(date +%Y%m%d)
-    git add -A
-    git commit -m "chore: Update dependencies"
-    
-    # Push and create PR
-    git push origin HEAD
-    PR_URL=$(gh pr create \
-      --title "Update dependencies" \
-      --body "Automated dependency update across services" \
-      --label "dependencies,automated")
-    
-    echo "$PR_URL" >> /tmp/created-prs.txt
-  fi
-  cd -
-done
-
-# Link related PRs
-PR_URLS=$(cat /tmp/created-prs.txt)
-npx monomind github link-prs --urls "$PR_URLS"
-```
-
-## Configuration
-
-### Multi-Repo Config File
-```yaml
-# .swarm/multi-repo.yml
-version: 1
-organization: my-org
-repositories:
-  - name: frontend
-    url: github.com/my-org/frontend
-    role: ui
-    agents: [coder, designer, tester]
-    
-  - name: backend
-    url: github.com/my-org/backend
-    role: api
-    agents: [architect, coder, tester]
-    
-  - name: shared
-    url: github.com/my-org/shared
-    role: library
-    agents: [analyst, coder]
-
-coordination:
-  topology: hierarchical
-  communication: webhook
-  memory: redis://shared-memory
-  
-dependencies:
-  - from: frontend
-    to: [backend, shared]
-  - from: backend
-    to: [shared]
-```
-
-### Repository Roles
-```javascript
-// Define repository roles and responsibilities
-{
-  "roles": {
-    "ui": {
-      "responsibilities": ["user-interface", "ux", "accessibility"],
-      "default-agents": ["designer", "coder", "tester"]
-    },
-    "api": {
-      "responsibilities": ["endpoints", "business-logic", "data"],
-      "default-agents": ["architect", "coder", "security"]
-    },
-    "library": {
-      "responsibilities": ["shared-code", "utilities", "types"],
-      "default-agents": ["analyst", "coder", "documenter"]
-    }
-  }
-}
-```
-
-## Orchestration Commands
-
-### Dependency Management
-```bash
-# Update dependencies across all repos with gh CLI
-# Create tracking issue first
-TRACKING_ISSUE=$(gh issue create \
-  --title "Dependency Update: typescript@5.0.0" \
-  --body "Tracking issue for updating TypeScript across all repositories" \
-  --label "dependencies,tracking" \
-  --json number -q .number)
-
-# Get all repos with TypeScript
-TS_REPOS=$(gh repo list org --limit 100 --json name | jq -r '.[].name' | \
-  while read -r repo; do
-    if gh api repos/org/$repo/contents/package.json 2>/dev/null | \
-       jq -r '.content' | base64 -d | grep -q '"typescript"'; then
-      echo "$repo"
-    fi
-  done)
-
-# Update each repository
-echo "$TS_REPOS" | while read -r repo; do
-  # Clone and update
-  gh repo clone org/$repo /tmp/$repo -- --depth=1
-  cd /tmp/$repo
-  
-  # Update dependency
-  npm install --save-dev typescript@5.0.0
-  
-  # Test changes
-  if npm test; then
-    # Create PR
-    git checkout -b update-typescript-5
-    git add package.json package-lock.json
-    git commit -m "chore: Update TypeScript to 5.0.0
-
-Part of #$TRACKING_ISSUE"
-    
-    git push origin HEAD
-    gh pr create \
-      --title "Update TypeScript to 5.0.0" \
-      --body "Updates TypeScript to version 5.0.0\n\nTracking: #$TRACKING_ISSUE" \
-      --label "dependencies"
-  else
-    # Report failure
-    gh issue comment $TRACKING_ISSUE \
-      --body "❌ Failed to update $repo - tests failing"
-  fi
-  cd -
-done
-```
-
-### Refactoring Operations
-```bash
-# Coordinate large-scale refactoring
-npx monomind github multi-repo-refactor \
-  --pattern "rename:OldAPI->NewAPI" \
-  --analyze-impact \
-  --create-migration-guide \
-  --staged-rollout
-```
-
-### Security Updates
-```bash
-# Coordinate security patches
-npx monomind github multi-repo-security \
-  --scan-all \
-  --patch-vulnerabilities \
-  --verify-fixes \
-  --compliance-report
-```
-
-## Communication Strategies
-
-### 1. Webhook-Based Coordination
-```javascript
-// webhook-coordinator.js
-const { MultiRepoSwarm } = require('monomind');
-
-const swarm = new MultiRepoSwarm({
-  webhook: {
-    url: 'https://swarm-coordinator.example.com',
-    secret: process.env.WEBHOOK_SECRET
-  }
-});
-
-// Handle cross-repo events
-swarm.on('repo:update', async (event) => {
-  await swarm.propagate(event, {
-    to: event.dependencies,
-    strategy: 'eventual-consistency'
-  });
-});
-```
-
-### 2. GraphQL Federation
-```graphql
-# Federated schema for multi-repo queries
-type Repository @key(fields: "id") {
-  id: ID!
-  name: String!
-  swarmStatus: SwarmStatus!
-  dependencies: [Repository!]!
-  agents: [Agent!]!
-}
-
-type SwarmStatus {
-  active: Boolean!
-  topology: Topology!
-  tasks: [Task!]!
-  memory: JSON!
-}
-```
-
-### 3. Event Streaming
-```yaml
-# Kafka configuration for real-time coordination
-kafka:
-  brokers: ['kafka1:9092', 'kafka2:9092']
-  topics:
-    swarm-events: 
-      partitions: 10
-      replication: 3
-    swarm-memory:
-      partitions: 5
-      replication: 3
-```
-
-## Advanced Features
-
-### 1. Distributed Task Queue
-```bash
-# Create distributed task queue
-npx monomind github multi-repo-queue \
-  --backend redis \
-  --workers 10 \
-  --priority-routing \
-  --dead-letter-queue
-```
-
-### 2. Cross-Repo Testing
-```bash
-# Run integration tests across repos
-npx monomind github multi-repo-test \
-  --setup-test-env \
-  --link-services \
-  --run-e2e \
-  --tear-down
-```
-
-### 3. Monorepo Migration
-```bash
-# Assist in monorepo migration
-npx monomind github to-monorepo \
-  --analyze-repos \
-  --suggest-structure \
-  --preserve-history \
-  --create-migration-prs
-```
-
-## Monitoring & Visualization
-
-### Multi-Repo Dashboard
-```bash
-# Launch monitoring dashboard
-npx monomind github multi-repo-dashboard \
-  --port 3000 \
-  --metrics "agent-activity,task-progress,memory-usage" \
-  --real-time
-```
-
-### Dependency Graph
-```bash
-# Visualize repo dependencies
-npx monomind github dep-graph \
-  --format mermaid \
-  --include-agents \
-  --show-data-flow
-```
-
-### Health Monitoring
-```bash
-# Monitor swarm health across repos
-npx monomind github health-check \
-  --repos "org/*" \
-  --check "connectivity,memory,agents" \
-  --alert-on-issues
-```
-
-## Synchronization Patterns
-
-### 1. Eventually Consistent
-```javascript
-// Eventual consistency for non-critical updates
-{
-  "sync": {
-    "strategy": "eventual",
-    "max-lag": "5m",
-    "retry": {
-      "attempts": 3,
-      "backoff": "exponential"
-    }
-  }
-}
-```
-
-### 2. Strong Consistency
-```javascript
-// Strong consistency for critical operations
-{
-  "sync": {
-    "strategy": "strong",
-    "consensus": "raft",
-    "quorum": 0.51,
-    "timeout": "30s"
-  }
-}
-```
-
-### 3. Hybrid Approach
-```javascript
-// Mix of consistency levels
-{
-  "sync": {
-    "default": "eventual",
-    "overrides": {
-      "security-updates": "strong",
-      "dependency-updates": "strong",
-      "documentation": "eventual"
-    }
-  }
-}
-```
-
-## Use Cases
-
-### 1. Microservices Coordination
-```bash
-# Coordinate microservices development
-npx monomind github microservices \
-  --services "auth,users,orders,payments" \
-  --ensure-compatibility \
-  --sync-contracts \
-  --integration-tests
-```
-
-### 2. Library Updates
-```bash
-# Update shared library across consumers
-npx monomind github lib-update \
-  --library "org/shared-lib" \
-  --version "2.0.0" \
-  --find-consumers \
-  --update-imports \
-  --run-tests
-```
-
-### 3. Organization-Wide Changes
-```bash
-# Apply org-wide policy changes
-npx monomind github org-policy \
-  --policy "add-security-headers" \
-  --repos "org/*" \
-  --validate-compliance \
-  --create-reports
-```
-
-## Best Practices
-
-### 1. Repository Organization
-- Clear repository roles and boundaries
-- Consistent naming conventions
-- Documented dependencies
-- Shared configuration standards
-
-### 2. Communication
-- Use appropriate sync strategies
-- Implement circuit breakers
-- Monitor latency and failures
-- Clear error propagation
-
-### 3. Security
-- Secure cross-repo authentication
-- Encrypted communication channels
-- Audit trail for all operations
-- Principle of least privilege
-
-## Performance Optimization
-
-### Caching Strategy
-```bash
-# Implement cross-repo caching
-npx monomind github cache-strategy \
-  --analyze-patterns \
-  --suggest-cache-layers \
-  --implement-invalidation
-```
-
-### Parallel Execution
-```bash
-# Optimize parallel operations
-npx monomind github parallel-optimize \
-  --analyze-dependencies \
-  --identify-parallelizable \
-  --execute-optimal
-```
-
-### Resource Pooling
-```bash
-# Pool resources across repos
-npx monomind github resource-pool \
-  --share-agents \
-  --distribute-load \
-  --monitor-usage
-```
-
-## Troubleshooting
-
-### Connectivity Issues
-```bash
-# Diagnose connectivity problems
-npx monomind github diagnose-connectivity \
-  --test-all-repos \
-  --check-permissions \
-  --verify-webhooks
-```
-
-### Memory Synchronization
-```bash
-# Debug memory sync issues
-npx monomind github debug-memory \
-  --check-consistency \
-  --identify-conflicts \
-  --repair-state
-```
-
-### Performance Bottlenecks
-```bash
-# Identify performance issues
-npx monomind github perf-analysis \
-  --profile-operations \
-  --identify-bottlenecks \
-  --suggest-optimizations
-```
-
-## Examples
-
-### Full-Stack Application Update
-```bash
-# Update full-stack application
-npx monomind github fullstack-update \
-  --frontend "org/web-app" \
-  --backend "org/api-server" \
-  --database "org/db-migrations" \
-  --coordinate-deployment
-```
-
-### Cross-Team Collaboration
-```bash
-# Facilitate cross-team work
-npx monomind github cross-team \
-  --teams "frontend,backend,devops" \
-  --task "implement-feature-x" \
-  --assign-by-expertise \
-  --track-progress
-```
-
-See also: [swarm-pr.md](./swarm-pr.md), [project-board-sync.md](./project-board-sync.md)

package/packages/@monomind/cli/.claude/agents/github/pr-manager.md

@@ -1,161 +0,0 @@
----
-name: pr-manager
-description: |
-  Comprehensive pull request management with swarm coordination for automated reviews, testing, and merge workflows
-tools: Bash, Read, Write, Edit, Glob, Grep, LS, TodoWrite, mcp__monomind__swarm_init, mcp__monomind__agent_spawn, mcp__monomind__swarm_status, mcp__monomind__memory_store, mcp__monomind__github_pr_manage, mcp__monomind__github_code_review, mcp__monomind__github_metrics
----
-
-# GitHub PR Manager
-
-## Purpose
-Comprehensive pull request management with swarm coordination for automated reviews, testing, and merge workflows.
-
-## Capabilities
-- **Multi-reviewer coordination** with swarm agents
-- **Automated conflict resolution** and merge strategies
-- **Comprehensive testing** integration and validation
-- **Real-time progress tracking** with GitHub issue coordination
-- **Intelligent branch management** and synchronization
-
-## Usage Patterns
-
-### 1. Create and Manage PR with Swarm Coordination
-```javascript
-// Initialize review swarm
-mcp__monomind__swarm_init { topology: "mesh", maxAgents: 4 }
-mcp__monomind__agent_spawn { type: "reviewer", name: "Code Quality Reviewer" }
-mcp__monomind__agent_spawn { type: "tester", name: "Testing Agent" }
-mcp__monomind__agent_spawn { type: "coordinator", name: "PR Coordinator" }
-
-// Create PR and orchestrate review
-mcp__github__create_pull_request {
-  owner: "monoes",
-  repo: "monomind",
-  title: "Integration: Monomind CLI and hooks",
-  head: "integration/monomind-cli-hooks",
-  base: "main",
-  body: "Comprehensive integration between packages..."
-}
-
-// Orchestrate review process
-mcp__monomind__task_orchestrate {
-  task: "Complete PR review with testing and validation",
-  strategy: "parallel",
-  priority: "high"
-}
-```
-
-### 2. Automated Multi-File Review
-```javascript
-// Get PR files and create parallel review tasks
-mcp__github__get_pull_request_files { owner: "monoes", repo: "monomind", pull_number: 54 }
-
-// Create coordinated reviews
-mcp__github__create_pull_request_review {
-  owner: "monoes",
-  repo: "monomind", 
-  pull_number: 54,
-  body: "Automated swarm review with comprehensive analysis",
-  event: "APPROVE",
-  comments: [
-    { path: "package.json", line: 78, body: "Dependency integration verified" },
-    { path: "src/index.js", line: 45, body: "Import structure optimized" }
-  ]
-}
-```
-
-### 3. Merge Coordination with Testing
-```javascript
-// Validate PR status and merge when ready
-mcp__github__get_pull_request_status { owner: "monoes", repo: "monomind", pull_number: 54 }
-
-// Merge with coordination
-mcp__github__merge_pull_request {
-  owner: "monoes",
-  repo: "monomind",
-  pull_number: 54,
-  merge_method: "squash",
-  commit_title: "feat: Complete Monomind CLI and hooks integration",
-  commit_message: "Comprehensive integration with swarm coordination"
-}
-
-// Post-merge coordination
-mcp__monomind__memory_store {
-  action: "store",
-  key: "pr/54/merged",
-  value: { timestamp: Date.now(), status: "success" }
-}
-```
-
-## Batch Operations Example
-
-### Complete PR Lifecycle in Parallel:
-```javascript
-[Single Message - Complete PR Management]:
-  // Initialize coordination
-  mcp__monomind__swarm_init { topology: "hierarchical", maxAgents: 5 }
-  mcp__monomind__agent_spawn { type: "reviewer", name: "Senior Reviewer" }
-  mcp__monomind__agent_spawn { type: "tester", name: "QA Engineer" }
-  mcp__monomind__agent_spawn { type: "coordinator", name: "Merge Coordinator" }
-  
-  // Create and manage PR using gh CLI
-  Bash("gh pr create --repo :owner/:repo --title '...' --head '...' --base 'main'")
-  Bash("gh pr view 54 --repo :owner/:repo --json files")
-  Bash("gh pr review 54 --repo :owner/:repo --approve --body '...'")
-  
-  
-  // Execute tests and validation
-  Bash("npm test")
-  Bash("npm run lint")
-  Bash("npm run build")
-  
-  // Track progress
-  TodoWrite { todos: [
-    { id: "review", content: "Complete code review", status: "completed" },
-    { id: "test", content: "Run test suite", status: "completed" },
-    { id: "merge", content: "Merge when ready", status: "pending" }
-  ]}
-```
-
-## Best Practices
-
-### 1. **Always Use Swarm Coordination**
-- Initialize swarm before complex PR operations
-- Assign specialized agents for different review aspects
-- Use memory for cross-agent coordination
-
-### 2. **Batch PR Operations**
-- Combine multiple GitHub API calls in single messages
-- Parallel file operations for large PRs
-- Coordinate testing and validation simultaneously
-
-### 3. **Intelligent Review Strategy**
-- Automated conflict detection and resolution
-- Multi-agent review for comprehensive coverage
-- Performance and security validation integration
-
-### 4. **Progress Tracking**
-- Use TodoWrite for PR milestone tracking
-- GitHub issue integration for project coordination
-- Real-time status updates through swarm memory
-
-## Integration with Other Modes
-
-### Works seamlessly with:
-- `/github issue-tracker` - For project coordination
-- `/github branch-manager` - For branch strategy
-- `/github ci-orchestrator` - For CI/CD integration
-
-## Error Handling
-
-### Automatic retry logic for:
-- Network failures during GitHub API calls
-- Merge conflicts with intelligent resolution
-- Test failures with automatic re-runs
-- Review bottlenecks with load balancing
-
-### Swarm coordination ensures:
-- No single point of failure
-- Automatic agent failover
-- Progress preservation across interruptions
-- Comprehensive error reporting and recovery