monomind 1.16.6 → 1.16.8

package/packages/@monomind/cli/.claude/commands/github/pr-manager.md

@@ -0,0 +1,173 @@
+---
+name: github:pr-manager
+---
+
+# GitHub PR Manager
+
+## Purpose
+Comprehensive pull request management with monomind swarm coordination for automated reviews, testing, and merge workflows.
+
+## Capabilities
+- **Multi-reviewer coordination** with swarm agents
+- **Automated conflict resolution** and merge strategies
+- **Comprehensive testing** integration and validation
+- **Real-time progress tracking** with GitHub issue coordination
+- **Intelligent branch management** and synchronization
+
+## Tools Available
+- `mcp__github__create_pull_request`
+- `mcp__github__get_pull_request`
+- `mcp__github__list_pull_requests`
+- `mcp__github__create_pull_request_review`
+- `mcp__github__merge_pull_request`
+- `mcp__github__get_pull_request_files`
+- `mcp__github__get_pull_request_status`
+- `mcp__github__update_pull_request_branch`
+- `mcp__github__get_pull_request_comments`
+- `mcp__github__get_pull_request_reviews`
+- `mcp__monomind__*` (all swarm coordination tools)
+- `TodoWrite`, `TodoRead`, `Task`, `Bash`, `Read`, `Write`
+
+## Usage Patterns
+
+### 1. Create and Manage PR with Swarm Coordination
+```javascript
+// Initialize review swarm
+mcp__monomind__swarm_init { topology: "mesh", maxAgents: 4 }
+mcp__monomind__agent_spawn { type: "reviewer", name: "Code Quality Reviewer" }
+mcp__monomind__agent_spawn { type: "tester", name: "Testing Agent" }
+mcp__monomind__agent_spawn { type: "coordinator", name: "PR Coordinator" }
+
+// Create PR and orchestrate review
+mcp__github__create_pull_request {
+  owner: ":owner",
+  repo: ":repo",
+  title: "feat: comprehensive package integration",
+  head: "feature/integration",
+  base: "main",
+  body: "Comprehensive integration between packages..."
+}
+
+// Orchestrate review process
+mcp__monomind__coordination_orchestrate {
+  task: "Complete PR review with testing and validation",
+  agents: ["reviewer", "tester", "coordinator"],
+  strategy: "parallel"
+}
+```
+
+### 2. Automated Multi-File Review
+```javascript
+// Get PR files and create parallel review tasks
+mcp__github__get_pull_request_files { owner: ":owner", repo: ":repo", pull_number: 54 }
+
+// Create coordinated reviews
+mcp__github__create_pull_request_review {
+  owner: ":owner",
+  repo: ":repo", 
+  pull_number: 54,
+  body: "Automated swarm review with comprehensive analysis",
+  event: "APPROVE",
+  comments: [
+    { path: "package.json", line: 78, body: "Dependency integration verified" },
+    { path: "src/index.js", line: 45, body: "Import structure optimized" }
+  ]
+}
+```
+
+### 3. Merge Coordination with Testing
+```javascript
+// Validate PR status and merge when ready
+mcp__github__get_pull_request_status { owner: ":owner", repo: ":repo", pull_number: 54 }
+
+// Merge with coordination
+mcp__github__merge_pull_request {
+  owner: ":owner",
+  repo: ":repo",
+  pull_number: 54,
+  merge_method: "squash",
+  commit_title: "feat: comprehensive package integration",
+  commit_message: "Comprehensive integration with swarm coordination"
+}
+
+// Post-merge coordination
+mcp__monomind__memory_store {
+  key: "pr/54/merged",
+  value: { timestamp: Date.now(), status: "success" }
+}
+```
+
+## Batch Operations Example
+
+### Complete PR Lifecycle in Parallel:
+```javascript
+[Single Message - Complete PR Management]:
+  // Initialize coordination
+  mcp__monomind__swarm_init { topology: "hierarchical", maxAgents: 5 }
+  mcp__monomind__agent_spawn { type: "reviewer", name: "Senior Reviewer" }
+  mcp__monomind__agent_spawn { type: "tester", name: "QA Engineer" }
+  mcp__monomind__agent_spawn { type: "coordinator", name: "Merge Coordinator" }
+  
+  // Create and manage PR using gh CLI
+  Bash("gh pr create --repo :owner/:repo --title '...' --head '...' --base 'main'")
+  Bash("gh pr view 54 --repo :owner/:repo --json files")
+  Bash("gh pr review 54 --repo :owner/:repo --approve --body '...'")
+  
+  
+  // Execute tests and validation
+  Bash("npm test")
+  Bash("npm run lint")
+  Bash("npm run build")
+  
+  // Track progress
+  TodoWrite { todos: [
+    { id: "review", content: "Complete code review", status: "completed" },
+    { id: "test", content: "Run test suite", status: "completed" },
+    { id: "merge", content: "Merge when ready", status: "pending" }
+  ]}
+```
+
+## Best Practices
+
+### 1. **Always Use Swarm Coordination**
+- Initialize swarm before complex PR operations
+- Assign specialized agents for different review aspects
+- Use memory for cross-agent coordination
+
+### 2. **Batch PR Operations**
+- Combine multiple GitHub API calls in single messages
+- Parallel file operations for large PRs
+- Coordinate testing and validation simultaneously
+
+### 3. **Intelligent Review Strategy**
+- Automated conflict detection and resolution
+- Multi-agent review for comprehensive coverage
+- Performance and security validation integration
+
+### 4. **Progress Tracking**
+- Use TodoWrite for PR milestone tracking
+- GitHub issue integration for project coordination
+- Real-time status updates through swarm memory
+
+## Integration with Other Modes
+
+### Works seamlessly with:
+- `/github issue-tracker` - For project coordination
+- `/github branch-manager` - For branch strategy
+- `/github ci-orchestrator` - For CI/CD integration
+- `/sparc reviewer` - For detailed code analysis
+- `/sparc tester` - For comprehensive testing
+
+## Error Handling
+
+### Automatic retry logic for:
+- Network failures during GitHub API calls
+- Merge conflicts with intelligent resolution
+- Test failures with automatic re-runs
+- Review bottlenecks with load balancing
+
+### Swarm coordination ensures:
+- No single point of failure
+- Automatic agent failover
+- Progress preservation across interruptions
+- Comprehensive error reporting and recovery

package/packages/@monomind/cli/.claude/commands/github/release-manager.md

@@ -0,0 +1,343 @@
+---
+name: github:release-manager
+---
+
+# GitHub Release Manager
+
+## Purpose
+
+Automated release coordination and deployment with Monomind swarm orchestration for seamless version management, testing, and deployment across multiple packages.
+
+## Capabilities
+
+- **Automated release pipelines** with comprehensive testing
+- **Version coordination** across multiple packages
+- **Deployment orchestration** with rollback capabilities
+- **Release documentation** generation and management
+- **Multi-stage validation** with swarm coordination
+
+## Tools Available
+
+- `mcp__github__create_pull_request`
+- `mcp__github__merge_pull_request`
+- `mcp__github__create_branch`
+- `mcp__github__push_files`
+- `mcp__github__create_issue`
+- `mcp__monomind__*` (all swarm coordination tools)
+- `TodoWrite`, `TodoRead`, `Task`, `Bash`, `Read`, `Write`, `Edit`
+
+## Usage Patterns
+
+### 1. Coordinated Release Preparation
+
+```javascript
+// Initialize release management swarm
+mcp__monomind__swarm_init { topology: "hierarchical", maxAgents: 6 }
+mcp__monomind__agent_spawn { type: "coordinator", name: "Release Coordinator" }
+mcp__monomind__agent_spawn { type: "tester", name: "QA Engineer" }
+mcp__monomind__agent_spawn { type: "reviewer", name: "Release Reviewer" }
+mcp__monomind__agent_spawn { type: "coder", name: "Version Manager" }
+mcp__monomind__agent_spawn { type: "analyst", name: "Deployment Analyst" }
+
+// Create release preparation branch
+mcp__github__create_branch {
+  owner: ":owner",
+  repo: ":repo",
+  branch: "release/v1.0.72",
+  from_branch: "main"
+}
+
+// Orchestrate release preparation
+mcp__monomind__coordination_orchestrate {
+  task: "Prepare release v1.0.72 with comprehensive testing and validation",
+  agents: ["coordinator", "tester", "reviewer"],
+  strategy: "sequential"
+}
+```
+
+### 2. Multi-Package Version Coordination
+
+```javascript
+// Update versions across packages
+mcp__github__push_files {
+  owner: ":owner",
+  repo: ":repo",
+  branch: "release/v1.0.72",
+  files: [
+    {
+      path: "packages/@monomind/cli/package.json",
+      content: JSON.stringify({
+        name: "@monomind/cli",
+        version: "1.0.72",
+        // ... rest of package.json
+      }, null, 2)
+    },
+    {
+      path: "package.json",
+      content: JSON.stringify({
+        name: "monomind",
+        version: "1.0.72",
+        // ... rest of package.json
+      }, null, 2)
+    },
+    {
+      path: "CHANGELOG.md",
+      content: `# Changelog
+
+## [1.0.72] - ${new Date().toISOString().split('T')[0]}
+
+### Added
+- Comprehensive GitHub workflow integration
+- Enhanced swarm coordination capabilities
+- Advanced MCP tools suite
+
+### Changed
+- Aligned Node.js version requirements
+- Improved package synchronization
+- Enhanced documentation structure
+
+### Fixed
+- Dependency resolution issues
+- Integration test reliability
+- Memory coordination optimization`
+    }
+  ],
+  message: "release: Prepare v1.0.72 with GitHub integration and swarm enhancements"
+}
+```
+
+### 3. Automated Release Validation
+
+```javascript
+// Comprehensive release testing
+Bash("npm install && npm run test && npm run lint && npm run build")
+
+// Create release PR with validation results
+mcp__github__create_pull_request {
+  owner: ":owner",
+  repo: ":repo",
+  title: "Release v1.0.72: GitHub Integration and Swarm Enhancements",
+  head: "release/v1.0.72",
+  base: "main",
+  body: `## Release v1.0.72
+
+### Release Highlights
+- **GitHub Workflow Integration**: Complete GitHub command suite with swarm coordination
+- **Package Synchronization**: Aligned versions and dependencies across packages
+- **Enhanced Documentation**: Synchronized CLAUDE.md with comprehensive integration guides
+- **Improved Testing**: Comprehensive integration test suite with 89% success rate
+
+### Package Updates
+- **@monomind/cli**: v1.0.71 → v1.0.72
+- **monomind**: v1.0.71 → v1.0.72
+
+### Changes
+#### Added
+- GitHub command modes: pr-manager, issue-tracker, sync-coordinator, release-manager
+- Swarm-coordinated GitHub workflows
+- Advanced MCP tools integration
+- Cross-package synchronization utilities
+
+#### Changed
+- Node.js requirement aligned to >=20.0.0 across packages
+- Enhanced swarm coordination protocols
+- Improved package dependency management
+- Updated integration documentation
+
+#### Fixed
+- Dependency resolution issues between packages
+- Integration test reliability improvements
+- Memory coordination optimization
+- Documentation synchronization
+
+### Validation Results
+- [x] Unit tests: All passing
+- [x] Integration tests: 89% success rate
+- [x] Lint checks: Clean
+- [x] Build verification: Successful
+- [x] Cross-package compatibility: Verified
+- [x] Documentation: Updated and synchronized
+
+### Swarm Coordination
+This release was coordinated using Monomind swarm agents:
+- **Release Coordinator**: Overall release management
+- **QA Engineer**: Comprehensive testing validation
+- **Release Reviewer**: Code quality and standards review
+- **Version Manager**: Package version coordination
+- **Deployment Analyst**: Release deployment validation
+
+### Ready for Deployment
+This release is production-ready with comprehensive validation and testing.
+
+---
+Generated with Claude Code using Monomind swarm coordination`
+}
+```
+
+## Batch Release Workflow
+
+### Complete Release Pipeline:
+
+```javascript
+[Single Message - Complete Release Management]:
+  // Initialize comprehensive release swarm
+  mcp__monomind__swarm_init { topology: "star", maxAgents: 8 }
+  mcp__monomind__agent_spawn { type: "coordinator", name: "Release Director" }
+  mcp__monomind__agent_spawn { type: "tester", name: "QA Lead" }
+  mcp__monomind__agent_spawn { type: "reviewer", name: "Senior Reviewer" }
+  mcp__monomind__agent_spawn { type: "coder", name: "Version Controller" }
+  mcp__monomind__agent_spawn { type: "analyst", name: "Performance Analyst" }
+  mcp__monomind__agent_spawn { type: "researcher", name: "Compatibility Checker" }
+
+  // Create release branch and prepare files using gh CLI
+  Bash("gh api repos/:owner/:repo/git/refs --method POST -f ref='refs/heads/release/v1.0.72' -f sha=$(gh api repos/:owner/:repo/git/refs/heads/main --jq '.object.sha')")
+
+  // Update all release-related files
+  Write("package.json", "[updated package.json]")
+  Write("CHANGELOG.md", "[release changelog]")
+  Write("RELEASE_NOTES.md", "[detailed release notes]")
+
+  Bash("git add -A && git commit -m 'release: Prepare v1.0.72 with comprehensive updates' && git push")
+
+  // Run comprehensive validation
+  Bash("npm install && npm test && npm run lint && npm run build")
+
+  // Create release PR using gh CLI
+  Bash(`gh pr create \
+    --repo :owner/:repo \
+    --title "Release v1.0.72: GitHub Integration and Swarm Enhancements" \
+    --head "release/v1.0.72" \
+    --base "main" \
+    --body "[comprehensive release description]"`)
+
+
+  // Track release progress
+  TodoWrite { todos: [
+    { id: "rel-prep", content: "Prepare release branch and files", status: "completed", priority: "critical" },
+    { id: "rel-test", content: "Run comprehensive test suite", status: "completed", priority: "critical" },
+    { id: "rel-pr", content: "Create release pull request", status: "completed", priority: "high" },
+    { id: "rel-review", content: "Code review and approval", status: "pending", priority: "high" },
+    { id: "rel-merge", content: "Merge and deploy release", status: "pending", priority: "critical" }
+  ]}
+
+  // Store release state
+  mcp__monomind__memory_store {
+    key: "release/v1.0.72/status",
+    value: {
+      timestamp: Date.now(),
+      version: "1.0.72",
+      stage: "validation_complete",
+      validation_passed: true,
+      ready_for_review: true
+    }
+  }
+```
+
+## Release Strategies
+
+### 1. **Semantic Versioning Strategy**
+
+```javascript
+const versionStrategy = {
+  major: "Breaking changes or architecture overhauls",
+  minor: "New features, GitHub integration, swarm enhancements",
+  patch: "Bug fixes, documentation updates, dependency updates",
+  coordination: "Cross-package version alignment",
+};
+```
+
+### 2. **Multi-Stage Validation**
+
+```javascript
+const validationStages = [
+  "unit_tests", // Individual package testing
+  "integration_tests", // Cross-package integration
+  "performance_tests", // Performance regression detection
+  "compatibility_tests", // Version compatibility validation
+  "documentation_tests", // Documentation accuracy verification
+  "deployment_tests", // Deployment simulation
+];
+```
+
+### 3. **Rollback Strategy**
+
+```javascript
+const rollbackPlan = {
+  triggers: ["test_failures", "deployment_issues", "critical_bugs"],
+  automatic: ["failed_tests", "build_failures"],
+  manual: ["user_reported_issues", "performance_degradation"],
+  recovery: "Previous stable version restoration",
+};
+```
+
+## Best Practices
+
+### 1. **Comprehensive Testing**
+
+- Multi-package test coordination
+- Integration test validation
+- Performance regression detection
+- Security vulnerability scanning
+
+### 2. **Documentation Management**
+
+- Automated changelog generation
+- Release notes with detailed changes
+- Migration guides for breaking changes
+- API documentation updates
+
+### 3. **Deployment Coordination**
+
+- Staged deployment with validation
+- Rollback mechanisms and procedures
+- Performance monitoring during deployment
+- User communication and notifications
+
+### 4. **Version Management**
+
+- Semantic versioning compliance
+- Cross-package version coordination
+- Dependency compatibility validation
+- Breaking change documentation
+
+## Integration with CI/CD
+
+### GitHub Actions Integration:
+
+```yaml
+name: Release Management
+on:
+  pull_request:
+    branches: [main]
+    paths: ["**/package.json", "CHANGELOG.md"]
+
+jobs:
+  release-validation:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Setup Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: "20"
+      - name: Install and Test
+        run: npm install && npm test
+      - name: Validate Release
+        run: npx monomind release validate
+```
+
+## Monitoring and Metrics
+
+### Release Quality Metrics:
+
+- Test coverage percentage
+- Integration success rate
+- Deployment time metrics
+- Rollback frequency
+
+### Automated Monitoring:
+
+- Performance regression detection
+- Error rate monitoring
+- User adoption metrics
+- Feedback collection and analysis