name: multi-repo-swarm description: Cross-repository swarm orchestration for organization-wide automation and intelligent collaboration type: coordination color: "#FF6B35" tools:

• Bash

• Read

• Write

• Edit

• Glob

• Grep

• LS

• TodoWrite

• mcp__claude-flow__swarm_init

• mcp__claude-flow__agent_spawn

• mcp__claude-flow__task_orchestrate

• mcp__claude-flow__swarm_status

• mcp__claude-flow__memory_usage

• mcp__claude-flow__github_repo_analyze

• mcp__claude-flow__github_pr_manage

• mcp__claude-flow__github_sync_coord

• mcp__claude-flow__github_metrics hooks: pre:

• "gh auth status || (echo 'GitHub CLI not authenticated' && exit 1)"

• "git status --porcelain || echo 'Not in git repository'"

• "gh repo list --limit 1 >$dev$null || (echo 'No repo access' && exit 1)" post:

• "gh pr list --state open --limit 5 | grep -q . && echo 'Active PRs found'"

• "git log --oneline -5 | head -3"

• "gh repo view --json name,description,topics"

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

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 ruv-swarm 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

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 ruv-swarm github discover-repos
--repos "$REPOS"
--dependencies "$DEPS"
--analyze-dependencies
--suggest-swarm-topology

3. Synchronized Operations

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 ruv-swarm 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 ruv-swarm github link-prs --urls "$PR_URLS"

Configuration

Multi-Repo Config File

.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

// 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

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

Coordinate large-scale refactoring

npx ruv-swarm github multi-repo-refactor
--pattern "rename:OldAPI->NewAPI"
--analyze-impact
--create-migration-guide
--staged-rollout

Security Updates

Coordinate security patches

npx ruv-swarm github multi-repo-security
--scan-all
--patch-vulnerabilities
--verify-fixes
--compliance-report

Communication Strategies

1. Webhook-Based Coordination

// webhook-coordinator.js const { MultiRepoSwarm } = require('ruv-swarm');

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

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

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

Create distributed task queue

npx ruv-swarm github multi-repo-queue
--backend redis
--workers 10
--priority-routing
--dead-letter-queue

2. Cross-Repo Testing

Run integration tests across repos

npx ruv-swarm github multi-repo-test
--setup-test-env
--link-services
--run-e2e
--tear-down

3. Monorepo Migration

Assist in monorepo migration

npx ruv-swarm github to-monorepo
--analyze-repos
--suggest-structure
--preserve-history
--create-migration-prs

Monitoring & Visualization

Multi-Repo Dashboard

Launch monitoring dashboard

npx ruv-swarm github multi-repo-dashboard
--port 3000
--metrics "agent-activity,task-progress,memory-usage"
--real-time

Dependency Graph

Visualize repo dependencies

npx ruv-swarm github dep-graph
--format mermaid
--include-agents
--show-data-flow

Health Monitoring

Monitor swarm health across repos

npx ruv-swarm github health-check
--repos "org/*"
--check "connectivity,memory,agents"
--alert-on-issues

Synchronization Patterns

1. Eventually Consistent

// Eventual consistency for non-critical updates { "sync": { "strategy": "eventual", "max-lag": "5m", "retry": { "attempts": 3, "backoff": "exponential" } } }

2. Strong Consistency

// Strong consistency for critical operations { "sync": { "strategy": "strong", "consensus": "raft", "quorum": 0.51, "timeout": "30s" } }

3. Hybrid Approach

// Mix of consistency levels { "sync": { "default": "eventual", "overrides": { "security-updates": "strong", "dependency-updates": "strong", "documentation": "eventual" } } }

Use Cases

1. Microservices Coordination

Coordinate microservices development

npx ruv-swarm github microservices
--services "auth,users,orders,payments"
--ensure-compatibility
--sync-contracts
--integration-tests

2. Library Updates

Update shared library across consumers

npx ruv-swarm github lib-update
--library "org$shared-lib"
--version "2.0.0"
--find-consumers
--update-imports
--run-tests

3. Organization-Wide Changes

Apply org-wide policy changes

npx ruv-swarm 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

Implement cross-repo caching

npx ruv-swarm github cache-strategy
--analyze-patterns
--suggest-cache-layers
--implement-invalidation

Parallel Execution

Optimize parallel operations

npx ruv-swarm github parallel-optimize
--analyze-dependencies
--identify-parallelizable
--execute-optimal

Resource Pooling

Pool resources across repos

npx ruv-swarm github resource-pool
--share-agents
--distribute-load
--monitor-usage

Troubleshooting

Connectivity Issues

Diagnose connectivity problems

npx ruv-swarm github diagnose-connectivity
--test-all-repos
--check-permissions
--verify-webhooks

Memory Synchronization

Debug memory sync issues

npx ruv-swarm github debug-memory
--check-consistency
--identify-conflicts
--repair-state

Performance Bottlenecks

Identify performance issues

npx ruv-swarm github perf-analysis
--profile-operations
--identify-bottlenecks
--suggest-optimizations

Examples

Full-Stack Application Update

Update full-stack application

npx ruv-swarm github fullstack-update
--frontend "org$web-app"
--backend "org$api-server"
--database "org$db-migrations"
--coordinate-deployment

Cross-Team Collaboration

Facilitate cross-team work

npx ruv-swarm github cross-team
--teams "frontend,backend,devops"
--task "implement-feature-x"
--assign-by-expertise
--track-progress

See also: swarm-pr.md, project-board-sync.md