agent-multi-repo-swarm
Agent skill for multi-repo-swarm - invoke with $agent-multi-repo-swarm
- Installs
- 1.1K
- Last 24h
- —
- Trending rank
- —
- Security
- Not audited
Install
Works with every agent the skills CLI supports.
npx skills add https://github.com/ruvnet/ruflo --skill agent-multi-repo-swarm- 01
Install
Run the command in your project. The CLI asks which agents to install for.
- 02
Describe the task
Ask your agent for something this skill covers. It loads agent-multi-repo-swarm automatically when relevant.
- 03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.
SKILL.md
The instructions your agent reads when the skill is triggered.
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
FAQ
What does the agent-multi-repo-swarm skill do?
Agent skill for multi-repo-swarm - invoke with $agent-multi-repo-swarm
How do I install agent-multi-repo-swarm?
Run npx skills add https://github.com/ruvnet/ruflo --skill agent-multi-repo-swarm in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/agent-multi-repo-swarm/ (personal) or .claude/skills/agent-multi-repo-swarm/ (project).
Which AI agents can use agent-multi-repo-swarm?
Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.
Is agent-multi-repo-swarm safe to install?
No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.
Who maintains agent-multi-repo-swarm?
It is published by ruvnet in ruvnet/ruflo. It has 1,119 recorded installs.
More from ruvnet/ruflo
swarm-orchestration
ruvnet/ruflo
Multi-agent swarm coordination for complex tasks. Uses hierarchical topology with specialized agents to break down and execute complex work across multiple files and modules. Use when: 3+ files need changes, new feature implementation, cross-module refactoring, API changes with tests, security-related changes, performance optimization across codebase, database schema changes. Skip when: single file edits, simple bug fixes (1-2 lines), documentation updates, configuration changes, quick exploration.
agent-arch-system-design
ruvnet/ruflo
Agent skill for arch-system-design - invoke with $agent-arch-system-design
agent-workflow
ruvnet/ruflo
Agent skill for workflow - invoke with $agent-workflow
security-audit
ruvnet/ruflo
Comprehensive security scanning and vulnerability detection. Includes input validation, path traversal prevention, CVE detection, and secure coding pattern enforcement. Use when: authentication implementation, authorization logic, payment processing, user data handling, API endpoint creation, file upload handling, database queries, external API integration. Skip when: read-only operations on public data, internal development tooling, static documentation, styling changes.
github-project-management
ruvnet/ruflo
Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning
Popular other skills
hyperframes-cli
heygen-com/hyperframes
The HyperFrames CLI by job - scaffold, check, look at frames, edit the timeline, preview, render locally or in the cloud, publish, project history - plus reading its JSON and recovering from build or render failures.
triage
mattpocock/skills
Move issues and external PRs through a state machine of triage roles, categorise, verify, grill if needed, and write agent-ready briefs.
ask-matt
mattpocock/skills
Ask which skill or flow fits your situation. A router over the skills in this repo.
to-questionnaire
mattpocock/skills
Turn a decision you can't fully answer into a questionnaire for someone else to fill in.
loop-me
mattpocock/skills
Grill me about specs for the workflows I want to build, within this workspace.