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