github-multi-repo

What this skill does

# GitHub Multi-Repository Coordination Skill

## Overview

Advanced multi-repository coordination system that combines swarm intelligence, package synchronization, and repository architecture optimization. This skill enables organization-wide automation, cross-project collaboration, and scalable repository management.

## Core Capabilities

### 🔄 Multi-Repository Swarm Coordination
Cross-repository AI swarm orchestration for distributed development workflows.

### 📦 Package Synchronization
Intelligent dependency resolution and version alignment across multiple packages.

### 🏗️ Repository Architecture
Structure optimization and template management for scalable projects.

### 🔗 Integration Management
Cross-package integration testing and deployment coordination.

## Quick Start

### Initialize Multi-Repo Coordination
```bash
# Basic swarm initialization
npx claude-flow skill run github-multi-repo init \
  --repos "org/frontend,org/backend,org/shared" \
  --topology hierarchical

# Advanced initialization with synchronization
npx claude-flow skill run github-multi-repo init \
  --repos "org/frontend,org/backend,org/shared" \
  --topology mesh \
  --shared-memory \
  --sync-strategy eventual
```

### Synchronize Packages
```bash
# Synchronize package versions and dependencies
npx claude-flow skill run github-multi-repo sync \
  --packages "claude-code-flow,ruv-swarm" \
  --align-versions \
  --update-docs
```

### Optimize Architecture
```bash
# Analyze and optimize repository structure
npx claude-flow skill run github-multi-repo optimize \
  --analyze-structure \
  --suggest-improvements \
  --create-templates
```

## Features

### 1. Cross-Repository Swarm Orchestration

#### Repository Discovery
```javascript
// Auto-discover related repositories with gh CLI
const REPOS = Bash(`gh repo list my-organization --limit 100 \
  --json name,description,languages,topics \
  --jq '.[] | select(.languages | keys | contains(["TypeScript"]))'`)

// Analyze repository dependencies
const DEPS = Bash(`gh repo list my-organization --json name | \
  jq -r '.[].name' | while read -r repo; do
    gh api repos/my-organization/$repo/contents/package.json \
      --jq '.content' 2>/dev/null | base64 -d | jq '{name, dependencies}'
  done | jq -s '.'`)

// Initialize swarm with discovered repositories
mcp__claude-flow__swarm_init({
  topology: "hierarchical",
  maxAgents: 8,
  metadata: { repos: REPOS, dependencies: DEPS }
})
```

#### Synchronized Operations
```javascript
// Execute synchronized changes across repositories
[Parallel Multi-Repo Operations]:
  // Spawn coordination agents
  Task("Repository Coordinator", "Coordinate changes across all repositories", "coordinator")
  Task("Dependency Analyzer", "Analyze cross-repo dependencies", "analyst")
  Task("Integration Tester", "Validate cross-repo changes", "tester")

  // Get matching repositories
  Bash(`gh repo list org --limit 100 --json name \
    --jq '.[] | select(.name | test("-service$")) | .name' > /tmp/repos.txt`)

  // Execute task across repositories
  Bash(`cat /tmp/repos.txt | while read -r repo; do
    gh repo clone org/$repo /tmp/$repo -- --depth=1
    cd /tmp/$repo

    # Apply changes
    npm update
    npm test

    # Create PR if successful
    if [ $? -eq 0 ]; then
      git checkout -b update-dependencies-$(date +%Y%m%d)
      git add -A
      git commit -m "chore: Update dependencies"
      git push origin HEAD
      gh pr create --title "Update dependencies" --body "Automated update" --label "dependencies"
    fi
  done`)

  // Track all operations
  TodoWrite { todos: [
    { id: "discover", content: "Discover all service repositories", status: "completed" },
    { id: "update", content: "Update dependencies", status: "completed" },
    { id: "test", content: "Run integration tests", status: "in_progress" },
    { id: "pr", content: "Create pull requests", status: "pending" }
  ]}
```

### 2. Package Synchronization

#### Version Alignment
```javascript
// Synchronize package dependencies and versions
[Complete Package Sync]:
  // Initialize sync swarm
  mcp__claude-flow__swarm_init({ topology: "mesh", maxAgents: 5 })

  // Spawn sync agents
  Task("Sync Coordinator", "Coordinate version alignment", "coordinator")
  Task("Dependency Analyzer", "Analyze dependencies", "analyst")
  Task("Integration Tester", "Validate synchronization", "tester")

  // Read package states
  Read("/workspaces/ruv-FANN/claude-code-flow/claude-code-flow/package.json")
  Read("/workspaces/ruv-FANN/ruv-swarm/npm/package.json")

  // Align versions using gh CLI
  Bash(`gh api repos/:owner/:repo/git/refs \
    -f ref='refs/heads/sync/package-alignment' \
    -f sha=$(gh api repos/:owner/:repo/git/refs/heads/main --jq '.object.sha')`)

  // Update package.json files
  Bash(`gh api repos/:owner/:repo/contents/package.json \
    --method PUT \
    -f message="feat: Align Node.js version requirements" \
    -f branch="sync/package-alignment" \
    -f content="$(cat aligned-package.json | base64)"`)

  // Store sync state
  mcp__claude-flow__memory_usage({
    action: "store",
    key: "sync/packages/status",
    value: {
      timestamp: Date.now(),
      packages_synced: ["claude-code-flow", "ruv-swarm"],
      status: "synchronized"
    }
  })
```

#### Documentation Synchronization
```javascript
// Synchronize CLAUDE.md files across packages
[Documentation Sync]:
  // Get source documentation
  Bash(`gh api repos/:owner/:repo/contents/ruv-swarm/docs/CLAUDE.md \
    --jq '.content' | base64 -d > /tmp/claude-source.md`)

  // Update target documentation
  Bash(`gh api repos/:owner/:repo/contents/claude-code-flow/CLAUDE.md \
    --method PUT \
    -f message="docs: Synchronize CLAUDE.md" \
    -f branch="sync/documentation" \
    -f content="$(cat /tmp/claude-source.md | base64)"`)

  // Track sync status
  mcp__claude-flow__memory_usage({
    action: "store",
    key: "sync/documentation/status",
    value: { status: "synchronized", files: ["CLAUDE.md"] }
  })
```

#### Cross-Package Integration
```javascript
// Coordinate feature implementation across packages
[Cross-Package Feature]:
  // Push changes to all packages
  mcp__github__push_files({
    branch: "feature/github-integration",
    files: [
      {
        path: "claude-code-flow/.claude/commands/github/github-modes.md",
        content: "[GitHub modes documentation]"
      },
      {
        path: "ruv-swarm/src/github-coordinator/hooks.js",
        content: "[GitHub coordination hooks]"
      }
    ],
    message: "feat: Add GitHub workflow integration"
  })

  // Create coordinated PR
  Bash(`gh pr create \
    --title "Feature: GitHub Workflow Integration" \
    --body "## 🚀 GitHub Integration

### Features
- ✅ Multi-repo coordination
- ✅ Package synchronization
- ✅ Architecture optimization

### Testing
- [x] Package dependency verification
- [x] Integration tests
- [x] Cross-package compatibility"`)
```

### 3. Repository Architecture

#### Structure Analysis
```javascript
// Analyze and optimize repository structure
[Architecture Analysis]:
  // Initialize architecture swarm
  mcp__claude-flow__swarm_init({ topology: "hierarchical", maxAgents: 6 })

  // Spawn architecture agents
  Task("Senior Architect", "Analyze repository structure", "architect")
  Task("Structure Analyst", "Identify optimization opportunities", "analyst")
  Task("Performance Optimizer", "Optimize structure for scalability", "optimizer")
  Task("Best Practices Researcher", "Research architecture patterns", "researcher")

  // Analyze current structures
  LS("/workspaces/ruv-FANN/claude-code-flow/claude-code-flow")
  LS("/workspaces/ruv-FANN/ruv-swarm/npm")

  // Search for best practices
  Bash(`gh search repos "language:javascript template architecture" \
    --limit 10 \
    --json fullName,description,stargazersCount \
    --sort stars \
    --order desc`)

  // Store analysis results
  mcp__claude-flow__memory_usage({
    action: "store",
    key: "architecture/analysis/re