---
name: repo-architect
description: |
  Repository structure optimization and multi-repo management with Monomind swarm coordination for scalable project architecture and development workflows
---

# GitHub Repository Architect

## Purpose

Repository structure optimization and multi-repo management with Monomind swarm coordination for scalable project architecture and development workflows.

## Capabilities

- **Repository structure optimization** with best practices
- **Multi-repository coordination** and synchronization
- **Template management** for consistent project setup
- **Architecture analysis** and improvement recommendations
- **Cross-repo workflow** coordination and management

## Usage Patterns

### 1. Repository Structure Analysis and Optimization

```javascript
// Initialize architecture analysis swarm
mcp__monomind__swarm_init { topology: "mesh", maxAgents: 4 }
mcp__monomind__agent_spawn { type: "analyst", name: "Structure Analyzer" }
mcp__monomind__agent_spawn { type: "architect", name: "Repository Architect" }
mcp__monomind__agent_spawn { type: "optimizer", name: "Structure Optimizer" }
mcp__monomind__agent_spawn { type: "coordinator", name: "Multi-Repo Coordinator" }

// Analyze current repository structure
LS("packages/@monomind/cli")
LS("packages/@monomind/hooks")

// Search for related repositories
mcp__github__search_repositories {
  query: "user:monoes monomind",
  sort: "updated",
  order: "desc"
}

// Orchestrate structure optimization
mcp__monomind__task_orchestrate {
  task: "Analyze and optimize repository structure for scalability and maintainability",
  strategy: "adaptive",
  priority: "medium"
}
```

### 2. Multi-Repository Template Creation

```javascript
// Create standardized repository template
mcp__github__create_repository {
  name: "monomind-project-template",
  description: "Standardized template for Monomind-enabled Claude Code projects",
  private: false,
  autoInit: true
}

// Push template structure
mcp__github__push_files {
  owner: "monoes",
  repo: "monomind-project-template",
  branch: "main",
  files: [
    {
      path: ".claude/commands/github/github-modes.md",
      content: "[GitHub modes template]"
    },
    {
      path: ".claude/commands/mastermind/help.md",
      content: "[Mastermind commands template]"
    },
    {
      path: ".claude/settings.json",
      content: JSON.stringify({
        mcpServers: {
          "monomind": {
            command: "npx",
            args: ["monomind@latest", "mcp", "start"],
            env: {}
          }
        }
      }, null, 2)
    },
    {
      path: "CLAUDE.md",
      content: "[Standardized CLAUDE.md template]"
    },
    {
      path: "package.json",
      content: JSON.stringify({
        name: "monomind-project-template",
        version: "1.0.0",
        description: "Claude Code project with Monomind integration",
        engines: { node: ">=20.0.0" },
        devDependencies: {
          "@monomind/cli": "latest"
        }
      }, null, 2)
    },
    {
      path: "README.md",
      content: `# Monomind Project Template

## Quick Start
\`\`\`bash
npx monomind@latest init
npm install
npx monomind@latest mcp start
\`\`\`

## Features
- Monomind swarm coordination
- GitHub workflow automation
- Knowledge graph integration

## Documentation
See CLAUDE.md for complete integration instructions.`
    }
  ],
  message: "feat: Create standardized Monomind project template"
}
```

### 3. Cross-Repository Synchronization

```javascript
// Synchronize structure across related repositories
const repositories = ["monomind", "monomind-docs", "monomind-examples"];

repositories.forEach((repo) => {
  mcp__github__create_or_update_file({
    owner: "monoes",
    repo,
    path: ".github/workflows/integration.yml",
    content: `name: Integration Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm install && npm test`,
    message: "ci: Standardize integration workflow across repositories",
    branch: "structure/standardization",
  });
});
```

## Batch Architecture Operations

### Complete Repository Architecture Optimization:

```javascript
[Single Message - Repository Architecture Review]:
  // Initialize comprehensive architecture swarm
  mcp__monomind__swarm_init { topology: "hierarchical", maxAgents: 6 }
  mcp__monomind__agent_spawn { type: "architect", name: "Senior Architect" }
  mcp__monomind__agent_spawn { type: "analyst", name: "Structure Analyst" }
  mcp__monomind__agent_spawn { type: "optimizer", name: "Performance Optimizer" }
  mcp__monomind__agent_spawn { type: "researcher", name: "Best Practices Researcher" }
  mcp__monomind__agent_spawn { type: "coordinator", name: "Multi-Repo Coordinator" }

  // Analyze current repository structures
  LS("packages/@monomind/cli")
  LS("packages/@monomind/hooks")
  Read("packages/@monomind/cli/package.json")
  Read("packages/@monomind/hooks/package.json")

  // Search for architectural patterns using gh CLI
  ARCH_PATTERNS=$(Bash(`gh search repos "language:typescript monorepo architecture" \
    --limit 10 \
    --json fullName,description,stargazersCount \
    --sort stars \
    --order desc`))

  // Create optimized structure files
  mcp__github__push_files {
    branch: "architecture/optimization",
    files: [
      {
        path: ".github/ISSUE_TEMPLATE/integration.yml",
        content: "[Integration issue template]"
      },
      {
        path: ".github/PULL_REQUEST_TEMPLATE.md",
        content: "[Standardized PR template]"
      },
      {
        path: "docs/ARCHITECTURE.md",
        content: "[Architecture documentation]"
      },
      {
        path: ".github/workflows/cross-package-test.yml",
        content: "[Cross-package testing workflow]"
      }
    ],
    message: "feat: Optimize repository architecture for scalability and maintainability"
  }

  // Track architecture improvements
  TodoWrite { todos: [
    { id: "arch-analysis", content: "Analyze current repository structure", status: "completed", priority: "high" },
    { id: "arch-research", content: "Research best practices and patterns", status: "completed", priority: "medium" },
    { id: "arch-templates", content: "Create standardized templates", status: "completed", priority: "high" },
    { id: "arch-workflows", content: "Implement improved workflows", status: "completed", priority: "medium" },
    { id: "arch-docs", content: "Document architecture decisions", status: "pending", priority: "medium" }
  ]}

  // Store architecture analysis
  mcp__monomind__memory_pattern-store {
    action: "store",
    key: "architecture/analysis/results",
    value: {
      timestamp: Date.now(),
      repositories_analyzed: ["@monomind/cli", "@monoes/hooks"],
      optimization_areas: ["structure", "workflows", "templates", "documentation"],
      recommendations: ["standardize_structure", "improve_workflows", "enhance_templates"],
      implementation_status: "in_progress"
    }
  }
```

## Architecture Patterns

### 1. **Monorepo Structure Pattern**

```
monomind/
├── packages/
│   ├── @monomind/
│   │   ├── cli/
│   │   │   ├── src/
│   │   │   ├── dist/
│   │   │   └── package.json
│   │   ├── hooks/
│   │   │   ├── src/
│   │   │   └── package.json
│   │   ├── memory/
│   │   │   ├── src/
│   │   │   └── package.json
│   │   └── security/
│   │       ├── src/
│   │       └── package.json
├── docs/
│   ├── architecture/
│   ├── integration/
│   └── examples/
└── .github/
    ├── workflows/
    ├── ISSUE_TEMPLATE/
    └── PULL_REQUEST_TEMPLATE.md
```

### 2. **Command Structure Pattern**

```
.claude/
├── commands/
│   ├── github/
│   │   ├── github-modes.md
│   │   ├── pr-manager.md
│   │   ├── issue-tracker.md
│   │   └── sync-coordinator.md
│   └── swarm/
│       ├── coordination.md
│       └── orchestration.md
├── agents/
│   └── github/
└── settings.json
```

### 3. **Integration Pattern**

```javascript
const integrationPattern = {
  packages: {
    "@monomind/cli": {
      role: "orchestration_layer",
      dependencies: ["@monoes/hooks", "@monomind/memory"],
      provides: ["CLI", "workflows", "commands"],
    },
    "@monoes/hooks": {
      role: "intelligence_engine",
      dependencies: ["@monomind/memory"],
      provides: ["hooks", "workers", "learning"],
    },
    "@monomind/memory": {
      role: "persistence_layer",
      dependencies: [],
      provides: ["LanceDB", "HNSW_search", "sessions"],
    },
  },
  communication: "MCP_protocol",
  coordination: "swarm_based",
  state_management: "persistent_memory",
};
```

## Best Practices

### 1. **Structure Optimization**

- Consistent directory organization across repositories
- Standardized configuration files and formats
- Clear separation of concerns and responsibilities
- Scalable architecture for future growth

### 2. **Template Management**

- Reusable project templates for consistency
- Standardized issue and PR templates
- Workflow templates for common operations
- Documentation templates for clarity

### 3. **Multi-Repository Coordination**

- Cross-repository dependency management
- Synchronized version and release management
- Consistent coding standards and practices
- Automated cross-repo validation

### 4. **Documentation Architecture**

- Comprehensive architecture documentation
- Clear integration guides and examples
- Maintainable and up-to-date documentation
- User-friendly onboarding materials

## Monitoring and Analysis

### Architecture Health Metrics:

- Repository structure consistency score
- Documentation coverage percentage
- Cross-repository integration success rate
- Template adoption and usage statistics

## Integration with Development Workflow

### Seamless integration with:

- `/github sync-coordinator` - For cross-repo synchronization
- `/github release-manager` - For coordinated releases