--- name: github_project_automation router_kit: FullStackKit title: GitHub Project Management version: 2.0.0 category: github description: Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning author: Claude Code tags: [architecture, automation, best practices, clean code, coding, collaboration, compliance, debugging, design patterns, development, documentation, efficiency, git, github project automation, optimization, productivity, programming, project management, quality assurance, refactoring, software engineering, standards, testing, utilities, version control, workflow] - github_project_automation --- # GitHub Project Management ## Overview A comprehensive skill for managing GitHub projects using AI swarm coordination. This skill combines intelligent issue management, automated project board synchronization, and swarm-based coordination for efficient project delivery. *GitHub Project Automation v2.1 - Enhanced* ## 🔄 Workflow > **Kaynak:** [GitHub Issues & Projects Guide](https:\/\/docs.github.com\/en\/issues) ### Aşama 1: Project Board Setup - [ ] **Fields**: 'Status', 'Priority', 'Size' (T-Shirt sizing) alanlarını tanımla. - [ ] **Views**: Developer için "My Tasks", Manager için "Roadmap" görünümleri oluştur. - [ ] **Automation**: "Move to Done when PR merged" kuralını aç. ### Aşama 2: Issue Lifecycle - [ ] **Template**: Bug ve Feature Request için zorunlu alanlı şablonlar (YAML form) kullan. - [ ] **Triage**: Gelen issue'ları swarm veya bot ile etiketle (`bug`, `triage-needed`). - [ ] **Link**: Her PR'ı bir issue'ya bağla (`Closes #123`). ### Aşama 3: Sprint Planning - [ ] **Milestone**: Issue'ları Milestone'lara (Sprint 1, v1.0) ata. - [ ] **Burn-up**: İlerlemeyi GitHub Insights\/Charts ile takip et. ### Kontrol Noktaları | Aşama | Doğrulama | |-------|-----------| | 1 | Board'daki bir kartın kime ait olduğu 3 saniyede anlaşılıyor mu? | | 2 | "Stale" (eski) issue'lar otomatik kapatılıyor mu? | | 3 | Roadmap görünümü gerçek durumu yansıtıyor mu? | ### Basic Issue Creation with Swarm Coordination ```bash # Create a coordinated issue gh issue create \ --title "Feature: Advanced Authentication" \ --body "Implement OAuth2 with social login..." \ --label "enhancement,swarm-ready" # Initialize swarm for issue npx claude-flow@alpha hooks pre-task --description "Feature implementation" ``` ### Project Board Quick Setup ```bash # Get project ID PROJECT_ID=$(gh project list --owner @me --format json | \ jq -r '.projects[0].id') # Initialize board sync npx ruv-swarm github board-init \ --project-id "$PROJECT_ID" \ --sync-mode "bidirectional" ``` --- ## Core Capabilities ### 1. Issue Management & Triage

Automated Issue Creation<\/strong><\/summary> #### Single Issue with Swarm Coordination ```javascript \/\/ Initialize issue management swarm mcp__claude-flow__swarm_init { topology: "star", maxAgents: 3 } mcp__claude-flow__agent_spawn { type: "coordinator", name: "Issue Coordinator" } mcp__claude-flow__agent_spawn { type: "researcher", name: "Requirements Analyst" } mcp__claude-flow__agent_spawn { type: "coder", name: "Implementation Planner" } \/\/ Create comprehensive issue mcp__github__create_issue { owner: "org", repo: "repository", title: "Integration Review: Complete system integration", body: `## 🔄 Integration Review ### Overview Comprehensive review and integration between components. ### Objectives - [ ] Verify dependencies and imports - [ ] Ensure API integration - [ ] Check hook system integration - [ ] Validate data systems alignment ### Swarm Coordination This issue will be managed by coordinated swarm agents for optimal progress tracking.`, labels: ["integration", "review", "enhancement"], assignees: ["username"] } \/\/ Set up automated tracking mcp__claude-flow__task_orchestrate { task: "Monitor and coordinate issue progress with automated updates", strategy: "adaptive", priority: "medium" } ``` #### Batch Issue Creation ```bash # Create multiple related issues using gh CLI gh issue create \ --title "Feature: Advanced GitHub Integration" \ --body "Implement comprehensive GitHub workflow automation..." \ --label "feature,github,high-priority" gh issue create \ --title "Bug: Merge conflicts in integration branch" \ --body "Resolve merge conflicts..." \ --label "bug,integration,urgent" gh issue create \ --title "Documentation: Update integration guides" \ --body "Update all documentation..." \ --label "documentation,integration" ``` <\/details>

Issue-to-Swarm Conversion<\/strong><\/summary> #### Transform Issues into Swarm Tasks ```bash # Get issue details ISSUE_DATA=$(gh issue view 456 --json title,body,labels,assignees,comments) # Create swarm from issue npx ruv-swarm github issue-to-swarm 456 \ --issue-data "$ISSUE_DATA" \ --auto-decompose \ --assign-agents # Batch process multiple issues ISSUES=$(gh issue list --label "swarm-ready" --json number,title,body,labels) npx ruv-swarm github issues-batch \ --issues "$ISSUES" \ --parallel # Update issues with swarm status echo "$ISSUES" | jq -r '.[].number' | while read -r num; do gh issue edit $num --add-label "swarm-processing" done ``` #### Issue Comment Commands Execute swarm operations via issue comments: ```markdown \/swarm analyze \/swarm decompose 5 \/swarm assign @agent-coder \/swarm estimate \/swarm start ``` <\/details>

Automated Issue Triage<\/strong><\/summary> #### Auto-Label Based on Content ```javascript \/\/ .github\/swarm-labels.json { "rules": [ { "keywords": ["bug", "error", "broken"], "labels": ["bug", "swarm-debugger"], "agents": ["debugger", "tester"] }, { "keywords": ["feature", "implement", "add"], "labels": ["enhancement", "swarm-feature"], "agents": ["architect", "coder", "tester"] }, { "keywords": ["slow", "performance", "optimize"], "labels": ["performance", "swarm-optimizer"], "agents": ["analyst", "optimizer"] } ] } ``` #### Automated Triage System ```bash # Analyze and triage unlabeled issues npx ruv-swarm github triage \ --unlabeled \ --analyze-content \ --suggest-labels \ --assign-priority # Find and link duplicate issues npx ruv-swarm github find-duplicates \ --threshold 0.8 \ --link-related \ --close-duplicates ``` <\/details>

Task Decomposition & Progress Tracking<\/strong><\/summary> #### Break Down Issues into Subtasks ```bash # Get issue body ISSUE_BODY=$(gh issue view 456 --json body --jq '.body') # Decompose into subtasks SUBTASKS=$(npx ruv-swarm github issue-decompose 456 \ --body "$ISSUE_BODY" \ --max-subtasks 10 \ --assign-priorities) # Update issue with checklist CHECKLIST=$(echo "$SUBTASKS" | jq -r '.tasks[] | "- [ ] " + .description') UPDATED_BODY="$ISSUE_BODY ## Subtasks $CHECKLIST" gh issue edit 456 --body "$UPDATED_BODY" # Create linked issues for major subtasks echo "$SUBTASKS" | jq -r '.tasks[] | select(.priority == "high")' | while read -r task; do TITLE=$(echo "$task" | jq -r '.title') BODY=$(echo "$task" | jq -r '.description') gh issue create \ --title "$TITLE" \ --body "$BODY Parent issue: #456" \ --label "subtask" done ``` #### Automated Progress Updates ```bash # Get current issue state CURRENT=$(gh issue view 456 --json body,labels) # Get swarm progress PROGRESS=$(npx ruv-swarm github issue-progress 456) # Update checklist in issue body UPDATED_BODY=$(echo "$CURRENT" | jq -r '.body' | \ npx ruv-swarm github update-checklist --progress "$PROGRESS") # Edit issue with updated body gh issue edit 456 --body "$UPDATED_BODY" # Post progress summary as comment SUMMARY=$(echo "$PROGRESS" | jq -r ' "## 📊 Progress Update **Completion**: \(.completion)% **ETA**: \(.eta) ### Completed Tasks \(.completed | map("- ✅ " + .) | join("\n")) ### In Progress \(.in_progress | map("- 🔄 " + .) | join("\n")) ### Remaining \(.remaining | map("- ⏳ " + .) | join("\n")) --- 🤖 Automated update by swarm agent"') gh issue comment 456 --body "$SUMMARY" # Update labels based on progress if [[ $(echo "$PROGRESS" | jq -r '.completion') -eq 100 ]]; then gh issue edit 456 --add-label "ready-for-review" --remove-label "in-progress" fi ``` <\/details>

Stale Issue Management<\/strong><\/summary> #### Auto-Close Stale Issues with Swarm Analysis ```bash # Find stale issues STALE_DATE=$(date -d '30 days ago' --iso-8601) STALE_ISSUES=$(gh issue list --state open --json number,title,updatedAt,labels \ --jq ".[] | select(.updatedAt < \"$STALE_DATE\")") # Analyze each stale issue echo "$STALE_ISSUES" | jq -r '.number' | while read -r num; do # Get full issue context ISSUE=$(gh issue view $num --json title,body,comments,labels) # Analyze with swarm ACTION=$(npx ruv-swarm github analyze-stale \ --issue "$ISSUE" \ --suggest-action) case "$ACTION" in "close") gh issue comment $num --body "This issue has been inactive for 30 days and will be closed in 7 days if there's no further activity." gh issue edit $num --add-label "stale" ;; "keep") gh issue edit $num --remove-label "stale" 2>\/dev\/null || true ;; "needs-info") gh issue comment $num --body "This issue needs more information. Please provide additional context or it may be closed as stale." gh issue edit $num --add-label "needs-info" ;; esac done # Close issues that have been stale for 37+ days gh issue list --label stale --state open --json number,updatedAt \ --jq ".[] | select(.updatedAt < \"$(date -d '37 days ago' --iso-8601)\") | .number" | \ while read -r num; do gh issue close $num --comment "Closing due to inactivity. Feel free to reopen if this is still relevant." done ``` <\/details> ### 2. Project Board Automation

Board Initialization & Configuration<\/strong><\/summary> #### Connect Swarm to GitHub Project ```bash # Get project details PROJECT_ID=$(gh project list --owner @me --format json | \ jq -r '.projects[] | select(.title == "Development Board") | .id') # Initialize swarm with project npx ruv-swarm github board-init \ --project-id "$PROJECT_ID" \ --sync-mode "bidirectional" \ --create-views "swarm-status,agent-workload,priority" # Create project fields for swarm tracking gh project field-create $PROJECT_ID --owner @me \ --name "Swarm Status" \ --data-type "SINGLE_SELECT" \ --single-select-options "pending,in_progress,completed" ``` #### Board Mapping Configuration ```yaml # .github\/board-sync.yml version: 1 project: name: "AI Development Board" number: 1 mapping: # Map swarm task status to board columns status: pending: "Backlog" assigned: "Ready" in_progress: "In Progress" review: "Review" completed: "Done" blocked: "Blocked" # Map agent types to labels agents: coder: "🔧 Development" tester: "🧪 Testing" analyst: "📊 Analysis" designer: "🎨 Design" architect: "🏗️ Architecture" # Map priority to project fields priority: critical: "🔴 Critical" high: "🟡 High" medium: "🟢 Medium" low: "⚪ Low" # Custom fields fields: - name: "Agent Count" type: number source: task.agents.length - name: "Complexity" type: select source: task.complexity - name: "ETA" type: date source: task.estimatedCompletion ``` <\/details>

Task Synchronization<\/strong><\/summary> #### Real-time Board Sync ```bash # Sync swarm tasks with project cards npx ruv-swarm github board-sync \ --map-status '{ "todo": "To Do", "in_progress": "In Progress", "review": "Review", "done": "Done" }' \ --auto-move-cards \ --update-metadata # Enable real-time board updates npx ruv-swarm github board-realtime \ --webhook-endpoint "https:\/\/api.example.com\/github-sync" \ --update-frequency "immediate" \ --batch-updates false ``` #### Convert Issues to Project Cards ```bash # List issues with label ISSUES=$(gh issue list --label "enhancement" --json number,title,body) # Add issues to project echo "$ISSUES" | jq -r '.[].number' | while read -r issue; do gh project item-add $PROJECT_ID --owner @me --url "https:\/\/github.com\/$GITHUB_REPOSITORY\/issues\/$issue" done # Process with swarm npx ruv-swarm github board-import-issues \ --issues "$ISSUES" \ --add-to-column "Backlog" \ --parse-checklist \ --assign-agents ``` <\/details>

Smart Card Management<\/strong><\/summary> #### Auto-Assignment ```bash # Automatically assign cards to agents npx ruv-swarm github board-auto-assign \ --strategy "load-balanced" \ --consider "expertise,workload,availability" \ --update-cards ``` #### Intelligent Card State Transitions ```bash # Smart card movement based on rules npx ruv-swarm github board-smart-move \ --rules '{ "auto-progress": "when:all-subtasks-done", "auto-review": "when:tests-pass", "auto-done": "when:pr-merged" }' ``` #### Bulk Operations ```bash # Bulk card operations npx ruv-swarm github board-bulk \ --filter "status:blocked" \ --action "add-label:needs-attention" \ --notify-assignees ``` <\/details>

Custom Views & Dashboards<\/strong><\/summary> #### View Configuration ```javascript \/\/ Custom board views { "views": [ { "name": "Swarm Overview", "type": "board", "groupBy": "status", "filters": ["is:open"], "sort": "priority:desc" }, { "name": "Agent Workload", "type": "table", "groupBy": "assignedAgent", "columns": ["title", "status", "priority", "eta"], "sort": "eta:asc" }, { "name": "Sprint Progress", "type": "roadmap", "dateField": "eta", "groupBy": "milestone" } ] } ``` #### Dashboard Configuration ```javascript \/\/ Dashboard with performance widgets { "dashboard": { "widgets": [ { "type": "chart", "title": "Task Completion Rate", "data": "completed-per-day", "visualization": "line" }, { "type": "gauge", "title": "Sprint Progress", "data": "sprint-completion", "target": 100 }, { "type": "heatmap", "title": "Agent Activity", "data": "agent-tasks-per-day" } ] } } ``` <\/details> ### 3. Sprint Planning & Tracking

Sprint Management<\/strong><\/summary> #### Initialize Sprint with Swarm Coordination ```bash # Manage sprints with swarms npx ruv-swarm github sprint-manage \ --sprint "Sprint 23" \ --auto-populate \ --capacity-planning \ --track-velocity # Track milestone progress npx ruv-swarm github milestone-track \ --milestone "v2.0 Release" \ --update-board \ --show-dependencies \ --predict-completion ``` #### Agile Development Board Setup ```bash # Setup agile board npx ruv-swarm github agile-board \ --methodology "scrum" \ --sprint-length "2w" \ --ceremonies "planning,review,retro" \ --metrics "velocity,burndown" ``` #### Kanban Flow Board Setup ```bash # Setup kanban board npx ruv-swarm github kanban-board \ --wip-limits '{ "In Progress": 5, "Review": 3 }' \ --cycle-time-tracking \ --continuous-flow ``` <\/details>

Progress Tracking & Analytics<\/strong><\/summary> #### Board Analytics ```bash # Fetch project data PROJECT_DATA=$(gh project item-list $PROJECT_ID --owner @me --format json) # Get issue metrics ISSUE_METRICS=$(echo "$PROJECT_DATA" | jq -r '.items[] | select(.content.type == "Issue")' | \ while read -r item; do ISSUE_NUM=$(echo "$item" | jq -r '.content.number') gh issue view $ISSUE_NUM --json createdAt,closedAt,labels,assignees done) # Generate analytics with swarm npx ruv-swarm github board-analytics \ --project-data "$PROJECT_DATA" \ --issue-metrics "$ISSUE_METRICS" \ --metrics "throughput,cycle-time,wip" \ --group-by "agent,priority,type" \ --time-range "30d" \ --export "dashboard" ``` #### Performance Reports ```bash # Track and visualize progress npx ruv-swarm github board-progress \ --show "burndown,velocity,cycle-time" \ --time-period "sprint" \ --export-metrics # Generate reports npx ruv-swarm github board-report \ --type "sprint-summary" \ --format "markdown" \ --include "velocity,burndown,blockers" \ --distribute "slack,email" ``` #### KPI Tracking ```bash # Track board performance npx ruv-swarm github board-kpis \ --metrics '[ "average-cycle-time", "throughput-per-sprint", "blocked-time-percentage", "first-time-pass-rate" ]' \ --dashboard-url # Track team performance npx ruv-swarm github team-metrics \ --board "Development" \ --per-member \ --include "velocity,quality,collaboration" \ --anonymous-option ``` <\/details>

Release Planning<\/strong><\/summary> #### Release Coordination ```bash # Plan releases using board data npx ruv-swarm github release-plan-board \ --analyze-velocity \ --estimate-completion \ --identify-risks \ --optimize-scope ``` <\/details> ### 4. Advanced Coordination

Multi-Board Synchronization<\/strong><\/summary> #### Cross-Board Sync ```bash # Sync across multiple boards npx ruv-swarm github multi-board-sync \ --boards "Development,QA,Release" \ --sync-rules '{ "Development->QA": "when:ready-for-test", "QA->Release": "when:tests-pass" }' # Cross-organization sync npx ruv-swarm github cross-org-sync \ --source "org1\/Project-A" \ --target "org2\/Project-B" \ --field-mapping "custom" \ --conflict-resolution "source-wins" ``` <\/details>

Issue Dependencies & Epic Management<\/strong><\/summary> #### Dependency Resolution ```bash # Handle issue dependencies npx ruv-swarm github issue-deps 456 \ --resolve-order \ --parallel-safe \ --update-blocking ``` #### Epic Coordination ```bash # Coordinate epic-level swarms npx ruv-swarm github epic-swarm \ --epic 123 \ --child-issues "456,457,458" \ --orchestrate ``` <\/details>

Cross-Repository Coordination<\/strong><\/summary> #### Multi-Repo Issue Management ```bash # Handle issues across repositories npx ruv-swarm github cross-repo \ --issue "org\/repo#456" \ --related "org\/other-repo#123" \ --coordinate ``` <\/details>

Team Collaboration<\/strong><\/summary> #### Work Distribution ```bash # Distribute work among team npx ruv-swarm github board-distribute \ --strategy "skills-based" \ --balance-workload \ --respect-preferences \ --notify-assignments ``` #### Standup Automation ```bash # Generate standup reports npx ruv-swarm github standup-report \ --team "frontend" \ --include "yesterday,today,blockers" \ --format "slack" \ --schedule "daily-9am" ``` #### Review Coordination ```bash # Coordinate reviews via board npx ruv-swarm github review-coordinate \ --board "Code Review" \ --assign-reviewers \ --track-feedback \ --ensure-coverage ``` <\/details> --- ## Issue Templates ### Integration Issue Template ```markdown ## 🔄 Integration Task ### Overview [Brief description of integration requirements] ### Objectives - [ ] Component A integration - [ ] Component B validation - [ ] Testing and verification - [ ] Documentation updates ### Integration Areas #### Dependencies - [ ] Package.json updates - [ ] Version compatibility - [ ] Import statements #### Functionality - [ ] Core feature integration - [ ] API compatibility - [ ] Performance validation #### Testing - [ ] Unit tests - [ ] Integration tests - [ ] End-to-end validation ### Swarm Coordination - **Coordinator**: Overall progress tracking - **Analyst**: Technical validation - **Tester**: Quality assurance - **Documenter**: Documentation updates ### Progress Tracking Updates will be posted automatically by swarm agents during implementation. --- 🤖 Generated with Claude Code ``` ### Bug Report Template ```markdown ## 🐛 Bug Report ### Problem Description [Clear description of the issue] ### Expected Behavior [What should happen] ### Actual Behavior [What actually happens] ### Reproduction Steps 1. [Step 1] 2. [Step 2] 3. [Step 3] ### Environment - Package: [package name and version] - Node.js: [version] - OS: [operating system] ### Investigation Plan - [ ] Root cause analysis - [ ] Fix implementation - [ ] Testing and validation - [ ] Regression testing ### Swarm Assignment - **Debugger**: Issue investigation - **Coder**: Fix implementation - **Tester**: Validation and testing --- 🤖 Generated with Claude Code ``` ### Feature Request Template ```markdown ## ✨ Feature Request ### Feature Description [Clear description of the proposed feature] ### Use Cases 1. [Use case 1] 2. [Use case 2] 3. [Use case 3] ### Acceptance Criteria - [ ] Criterion 1 - [ ] Criterion 2 - [ ] Criterion 3 ### Implementation Approach #### Design - [ ] Architecture design - [ ] API design - [ ] UI\/UX mockups #### Development - [ ] Core implementation - [ ] Integration with existing features - [ ] Performance optimization #### Testing - [ ] Unit tests - [ ] Integration tests - [ ] User acceptance testing ### Swarm Coordination - **Architect**: Design and planning - **Coder**: Implementation - **Tester**: Quality assurance - **Documenter**: Documentation --- 🤖 Generated with Claude Code ``` ### Swarm Task Template ```markdown name: github_project_automation description: Create a task for AI swarm processing body: - type: dropdown id: topology attributes: label: Swarm Topology options: - mesh - hierarchical - ring - star - type: input id: agents attributes: label: Required Agents placeholder: "coder, tester, analyst" - type: textarea id: tasks attributes: label: Task Breakdown placeholder: | 1. Task one description 2. Task two description ``` --- ## Workflow Integration ### GitHub Actions for Issue Management ```yaml # .github\/workflows\/issue-swarm.yml name: github_project_automation on: issues: types: [opened, labeled, commented] jobs: swarm-process: runs-on: ubuntu-latest steps: - name: Process Issue uses: ruvnet\/swarm-action@v1 with: command: | if [[ "${{ github.event.label.name }}" == "swarm-ready" ]]; then npx ruv-swarm github issue-init ${{ github.event.issue.number }} fi ``` ### Board Integration Workflow ```bash # Sync with project board npx ruv-swarm github issue-board-sync \ --project "Development" \ --column-mapping '{ "To Do": "pending", "In Progress": "active", "Done": "completed" }' ``` --- ## Specialized Issue Strategies ### Bug Investigation Swarm ```bash # Specialized bug handling npx ruv-swarm github bug-swarm 456 \ --reproduce \ --isolate \ --fix \ --test ``` ### Feature Implementation Swarm ```bash # Feature implementation swarm npx ruv-swarm github feature-swarm 456 \ --design \ --implement \ --document \ --demo ``` ### Technical Debt Refactoring ```bash # Refactoring swarm npx ruv-swarm github debt-swarm 456 \ --analyze-impact \ --plan-migration \ --execute \ --validate ``` --- ## Best Practices ### 1. Swarm-Coordinated Issue Management - Always initialize swarm for complex issues - Assign specialized agents based on issue type - Use memory for progress coordination - Regular automated progress updates ### 2. Board Organization - Clear column definitions with consistent naming - Systematic labeling strategy across repositories - Regular board grooming and maintenance - Well-defined automation rules ### 3. Data Integrity - Bidirectional sync validation - Conflict resolution strategies - Comprehensive audit trails - Regular backups of project data ### 4. Team Adoption - Comprehensive training materials - Clear, documented workflows - Regular team reviews and retrospectives - Active feedback loops for improvement ### 5. Smart Labeling and Organization - Consistent labeling strategy across repositories - Priority-based issue sorting and assignment - Milestone integration for project coordination - Agent-type to label mapping ### 6. Automated Progress Tracking - Regular automated updates with swarm coordination - Progress metrics and completion tracking - Cross-issue dependency management - Real-time status synchronization --- ## Troubleshooting ### Sync Issues ```bash # Diagnose sync problems npx ruv-swarm github board-diagnose \ --check "permissions,webhooks,rate-limits" \ --test-sync \ --show-conflicts ``` ### Performance Optimization ```bash # Optimize board performance npx ruv-swarm github board-optimize \ --analyze-size \ --archive-completed \ --index-fields \ --cache-views ``` ### Data Recovery ```bash # Recover board data npx ruv-swarm github board-recover \ --backup-id "2024-01-15" \ --restore-cards \ --preserve-current \ --merge-conflicts ``` --- ## Metrics & Analytics ### Performance Metrics Automatic tracking of: - Issue creation and resolution times - Agent productivity metrics - Project milestone progress - Cross-repository coordination efficiency - Sprint velocity and burndown - Cycle time and throughput - Work-in-progress limits ### Reporting Features - Weekly progress summaries - Agent performance analytics - Project health metrics - Integration success rates - Team collaboration metrics - Quality and defect tracking ### Issue Resolution Time ```bash # Analyze swarm performance npx ruv-swarm github issue-metrics \ --issue 456 \ --metrics "time-to-close,agent-efficiency,subtask-completion" ``` ### Swarm Effectiveness ```bash # Generate effectiveness report npx ruv-swarm github effectiveness \ --issues "closed:>2024-01-01" \ --compare "with-swarm,without-swarm" ``` --- ## Security & Permissions 1. **Command Authorization**: Validate user permissions before executing commands 2. **Rate Limiting**: Prevent spam and abuse of issue commands 3. **Audit Logging**: Track all swarm operations on issues and boards 4. **Data Privacy**: Respect private repository settings 5. **Access Control**: Proper GitHub permissions for board operations 6. **Webhook Security**: Secure webhook endpoints for real-time updates --- ## Integration with Other Skills ### Seamless Integration With: - `github-pr-workflow` - Link issues to pull requests automatically - `github-release-management` - Coordinate release issues and milestones - `sparc-orchestrator` - Complex project coordination workflows - `sparc-tester` - Automated testing workflows for issues --- ## Complete Workflow Example ### Full-Stack Feature Development ```bash # 1. Create feature issue with swarm coordination gh issue create \ --title "Feature: Real-time Collaboration" \ --body "$(cat < npx ruv-swarm github issue-decompose npx ruv-swarm github triage --unlabeled # Project Boards npx ruv-swarm github board-init --project-id npx ruv-swarm github board-sync npx ruv-swarm github board-analytics # Sprint Management npx ruv-swarm github sprint-manage --sprint "Sprint X" npx ruv-swarm github milestone-track --milestone "vX.X" # Analytics npx ruv-swarm github issue-metrics --issue npx ruv-swarm github board-kpis ``` --- ## Additional Resources - [GitHub CLI Documentation](https:\/\/cli.github.com\/manual\/) - [GitHub Projects Documentation](https:\/\/docs.github.com\/en\/issues\/planning-and-tracking-with-projects) - [Swarm Coordination Guide](https:\/\/github.com\/ruvnet\/ruv-swarm) - [Claude Flow Documentation](https:\/\/github.com\/ruvnet\/claude-flow) --- **Last Updated**: 2025-10-19 **Version**: 2.0.0 **Maintainer**: Claude Code