1// Initialize issue management swarm
 2mcp__claude-flow__swarm_init { topology: "star", maxAgents: 3 }
 3mcp__claude-flow__agent_spawn { type: "coordinator", name: "Issue Coordinator" }
 4mcp__claude-flow__agent_spawn { type: "researcher", name: "Requirements Analyst" }
 5mcp__claude-flow__agent_spawn { type: "coder", name: "Implementation Planner" }
 6
 7// Create comprehensive issue
 8mcp__github__create_issue {
 9  owner: "org",
10  repo: "repository",
11  title: "Integration Review: Complete system integration",
12  body: `## 🔄 Integration Review
13
14  ### Overview
15  Comprehensive review and integration between components.
16
17  ### Objectives
18  - [ ] Verify dependencies and imports
19  - [ ] Ensure API integration
20  - [ ] Check hook system integration
21  - [ ] Validate data systems alignment
22
23  ### Swarm Coordination
24  This issue will be managed by coordinated swarm agents for optimal progress tracking.`,
25  labels: ["integration", "review", "enhancement"],
26  assignees: ["username"]
27}
28
29// Set up automated tracking
30mcp__claude-flow__task_orchestrate {
31  task: "Monitor and coordinate issue progress with automated updates",
32  strategy: "adaptive",
33  priority: "medium"
34}

 1# Create multiple related issues using gh CLI
 2gh issue create \
 3  --title "Feature: Advanced GitHub Integration" \
 4  --body "Implement comprehensive GitHub workflow automation..." \
 5  --label "feature,github,high-priority"
 6
 7gh issue create \
 8  --title "Bug: Merge conflicts in integration branch" \
 9  --body "Resolve merge conflicts..." \
10  --label "bug,integration,urgent"
11
12gh issue create \
13  --title "Documentation: Update integration guides" \
14  --body "Update all documentation..." \
15  --label "documentation,integration"

 1# Get issue details
 2ISSUE_DATA=$(gh issue view 456 --json title,body,labels,assignees,comments)
 3
 4# Create swarm from issue
 5npx ruv-swarm github issue-to-swarm 456 \
 6  --issue-data "$ISSUE_DATA" \
 7  --auto-decompose \
 8  --assign-agents
 9
10# Batch process multiple issues
11ISSUES=$(gh issue list --label "swarm-ready" --json number,title,body,labels)
12npx ruv-swarm github issues-batch \
13  --issues "$ISSUES" \
14  --parallel
15
16# Update issues with swarm status
17echo "$ISSUES" | jq -r '.[].number' | while read -r num; do
18  gh issue edit $num --add-label "swarm-processing"
19done

1<!-- In issue comment -->
2/swarm analyze
3/swarm decompose 5
4/swarm assign @agent-coder
5/swarm estimate
6/swarm start

 1// .github/swarm-labels.json
 2{
 3  "rules": [
 4    {
 5      "keywords": ["bug", "error", "broken"],
 6      "labels": ["bug", "swarm-debugger"],
 7      "agents": ["debugger", "tester"]
 8    },
 9    {
10      "keywords": ["feature", "implement", "add"],
11      "labels": ["enhancement", "swarm-feature"],
12      "agents": ["architect", "coder", "tester"]
13    },
14    {
15      "keywords": ["slow", "performance", "optimize"],
16      "labels": ["performance", "swarm-optimizer"],
17      "agents": ["analyst", "optimizer"]
18    }
19  ]
20}

 1# Analyze and triage unlabeled issues
 2npx ruv-swarm github triage \
 3  --unlabeled \
 4  --analyze-content \
 5  --suggest-labels \
 6  --assign-priority
 7
 8# Find and link duplicate issues
 9npx ruv-swarm github find-duplicates \
10  --threshold 0.8 \
11  --link-related \
12  --close-duplicates

 1# Get issue body
 2ISSUE_BODY=$(gh issue view 456 --json body --jq '.body')
 3
 4# Decompose into subtasks
 5SUBTASKS=$(npx ruv-swarm github issue-decompose 456 \
 6  --body "$ISSUE_BODY" \
 7  --max-subtasks 10 \
 8  --assign-priorities)
 9
10# Update issue with checklist
11CHECKLIST=$(echo "$SUBTASKS" | jq -r '.tasks[] | "- [ ] " + .description')
12UPDATED_BODY="$ISSUE_BODY
13
14## Subtasks
15$CHECKLIST"
16
17gh issue edit 456 --body "$UPDATED_BODY"
18
19# Create linked issues for major subtasks
20echo "$SUBTASKS" | jq -r '.tasks[] | select(.priority == "high")' | while read -r task; do
21  TITLE=$(echo "$task" | jq -r '.title')
22  BODY=$(echo "$task" | jq -r '.description')
23
24  gh issue create \
25    --title "$TITLE" \
26    --body "$BODY
27
28Parent issue: #456" \
29    --label "subtask"
30done

 1# Get current issue state
 2CURRENT=$(gh issue view 456 --json body,labels)
 3
 4# Get swarm progress
 5PROGRESS=$(npx ruv-swarm github issue-progress 456)
 6
 7# Update checklist in issue body
 8UPDATED_BODY=$(echo "$CURRENT" | jq -r '.body' | \
 9  npx ruv-swarm github update-checklist --progress "$PROGRESS")
10
11# Edit issue with updated body
12gh issue edit 456 --body "$UPDATED_BODY"
13
14# Post progress summary as comment
15SUMMARY=$(echo "$PROGRESS" | jq -r '
16"## 📊 Progress Update
17
18**Completion**: \(.completion)%
19**ETA**: \(.eta)
20
21### Completed Tasks
22\(.completed | map("- ✅ " + .) | join("\n"))
23
24### In Progress
25\(.in_progress | map("- 🔄 " + .) | join("\n"))
26
27### Remaining
28\(.remaining | map("- ⏳ " + .) | join("\n"))
29
30---
31🤖 Automated update by swarm agent"')
32
33gh issue comment 456 --body "$SUMMARY"
34
35# Update labels based on progress
36if [[ $(echo "$PROGRESS" | jq -r '.completion') -eq 100 ]]; then
37  gh issue edit 456 --add-label "ready-for-review" --remove-label "in-progress"
38fi

 1# Find stale issues
 2STALE_DATE=$(date -d '30 days ago' --iso-8601)
 3STALE_ISSUES=$(gh issue list --state open --json number,title,updatedAt,labels \
 4  --jq ".[] | select(.updatedAt < \"$STALE_DATE\")")
 5
 6# Analyze each stale issue
 7echo "$STALE_ISSUES" | jq -r '.number' | while read -r num; do
 8  # Get full issue context
 9  ISSUE=$(gh issue view $num --json title,body,comments,labels)
10
11  # Analyze with swarm
12  ACTION=$(npx ruv-swarm github analyze-stale \
13    --issue "$ISSUE" \
14    --suggest-action)
15
16  case "$ACTION" in
17    "close")
18      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."
19      gh issue edit $num --add-label "stale"
20      ;;
21    "keep")
22      gh issue edit $num --remove-label "stale" 2>/dev/null || true
23      ;;
24    "needs-info")
25      gh issue comment $num --body "This issue needs more information. Please provide additional context or it may be closed as stale."
26      gh issue edit $num --add-label "needs-info"
27      ;;
28  esac
29done
30
31# Close issues that have been stale for 37+ days
32gh issue list --label stale --state open --json number,updatedAt \
33  --jq ".[] | select(.updatedAt < \"$(date -d '37 days ago' --iso-8601)\") | .number" | \
34  while read -r num; do
35    gh issue close $num --comment "Closing due to inactivity. Feel free to reopen if this is still relevant."
36  done

 1# Get project details
 2PROJECT_ID=$(gh project list --owner @me --format json | \
 3  jq -r '.projects[] | select(.title == "Development Board") | .id')
 4
 5# Initialize swarm with project
 6npx ruv-swarm github board-init \
 7  --project-id "$PROJECT_ID" \
 8  --sync-mode "bidirectional" \
 9  --create-views "swarm-status,agent-workload,priority"
10
11# Create project fields for swarm tracking
12gh project field-create $PROJECT_ID --owner @me \
13  --name "Swarm Status" \
14  --data-type "SINGLE_SELECT" \
15  --single-select-options "pending,in_progress,completed"

 1# .github/board-sync.yml
 2version: 1
 3project:
 4  name: "AI Development Board"
 5  number: 1
 6
 7mapping:
 8  # Map swarm task status to board columns
 9  status:
10    pending: "Backlog"
11    assigned: "Ready"
12    in_progress: "In Progress"
13    review: "Review"
14    completed: "Done"
15    blocked: "Blocked"
16
17  # Map agent types to labels
18  agents:
19    coder: "🔧 Development"
20    tester: "🧪 Testing"
21    analyst: "📊 Analysis"
22    designer: "🎨 Design"
23    architect: "🏗️ Architecture"
24
25  # Map priority to project fields
26  priority:
27    critical: "🔴 Critical"
28    high: "🟡 High"
29    medium: "🟢 Medium"
30    low: "⚪ Low"
31
32  # Custom fields
33  fields:
34    - name: "Agent Count"
35      type: number
36      source: task.agents.length
37    - name: "Complexity"
38      type: select
39      source: task.complexity
40    - name: "ETA"
41      type: date
42      source: task.estimatedCompletion

 1# Sync swarm tasks with project cards
 2npx ruv-swarm github board-sync \
 3  --map-status '{
 4    "todo": "To Do",
 5    "in_progress": "In Progress",
 6    "review": "Review",
 7    "done": "Done"
 8  }' \
 9  --auto-move-cards \
10  --update-metadata
11
12# Enable real-time board updates
13npx ruv-swarm github board-realtime \
14  --webhook-endpoint "https://api.example.com/github-sync" \
15  --update-frequency "immediate" \
16  --batch-updates false

 1# List issues with label
 2ISSUES=$(gh issue list --label "enhancement" --json number,title,body)
 3
 4# Add issues to project
 5echo "$ISSUES" | jq -r '.[].number' | while read -r issue; do
 6  gh project item-add $PROJECT_ID --owner @me --url "https://github.com/$GITHUB_REPOSITORY/issues/$issue"
 7done
 8
 9# Process with swarm
10npx ruv-swarm github board-import-issues \
11  --issues "$ISSUES" \
12  --add-to-column "Backlog" \
13  --parse-checklist \
14  --assign-agents

1# Automatically assign cards to agents
2npx ruv-swarm github board-auto-assign \
3  --strategy "load-balanced" \
4  --consider "expertise,workload,availability" \
5  --update-cards

1# Smart card movement based on rules
2npx ruv-swarm github board-smart-move \
3  --rules '{
4    "auto-progress": "when:all-subtasks-done",
5    "auto-review": "when:tests-pass",
6    "auto-done": "when:pr-merged"
7  }'

1# Bulk card operations
2npx ruv-swarm github board-bulk \
3  --filter "status:blocked" \
4  --action "add-label:needs-attention" \
5  --notify-assignees

 1// Custom board views
 2{
 3  "views": [
 4    {
 5      "name": "Swarm Overview",
 6      "type": "board",
 7      "groupBy": "status",
 8      "filters": ["is:open"],
 9      "sort": "priority:desc"
10    },
11    {
12      "name": "Agent Workload",
13      "type": "table",
14      "groupBy": "assignedAgent",
15      "columns": ["title", "status", "priority", "eta"],
16      "sort": "eta:asc"
17    },
18    {
19      "name": "Sprint Progress",
20      "type": "roadmap",
21      "dateField": "eta",
22      "groupBy": "milestone"
23    }
24  ]
25}

 1// Dashboard with performance widgets
 2{
 3  "dashboard": {
 4    "widgets": [
 5      {
 6        "type": "chart",
 7        "title": "Task Completion Rate",
 8        "data": "completed-per-day",
 9        "visualization": "line"
10      },
11      {
12        "type": "gauge",
13        "title": "Sprint Progress",
14        "data": "sprint-completion",
15        "target": 100
16      },
17      {
18        "type": "heatmap",
19        "title": "Agent Activity",
20        "data": "agent-tasks-per-day"
21      }
22    ]
23  }
24}

 1# Manage sprints with swarms
 2npx ruv-swarm github sprint-manage \
 3  --sprint "Sprint 23" \
 4  --auto-populate \
 5  --capacity-planning \
 6  --track-velocity
 7
 8# Track milestone progress
 9npx ruv-swarm github milestone-track \
10  --milestone "v2.0 Release" \
11  --update-board \
12  --show-dependencies \
13  --predict-completion

1# Setup agile board
2npx ruv-swarm github agile-board \
3  --methodology "scrum" \
4  --sprint-length "2w" \
5  --ceremonies "planning,review,retro" \
6  --metrics "velocity,burndown"

1# Setup kanban board
2npx ruv-swarm github kanban-board \
3  --wip-limits '{
4    "In Progress": 5,
5    "Review": 3
6  }' \
7  --cycle-time-tracking \
8  --continuous-flow

 1# Fetch project data
 2PROJECT_DATA=$(gh project item-list $PROJECT_ID --owner @me --format json)
 3
 4# Get issue metrics
 5ISSUE_METRICS=$(echo "$PROJECT_DATA" | jq -r '.items[] | select(.content.type == "Issue")' | \
 6  while read -r item; do
 7    ISSUE_NUM=$(echo "$item" | jq -r '.content.number')
 8    gh issue view $ISSUE_NUM --json createdAt,closedAt,labels,assignees
 9  done)
10
11# Generate analytics with swarm
12npx ruv-swarm github board-analytics \
13  --project-data "$PROJECT_DATA" \
14  --issue-metrics "$ISSUE_METRICS" \
15  --metrics "throughput,cycle-time,wip" \
16  --group-by "agent,priority,type" \
17  --time-range "30d" \
18  --export "dashboard"

 1# Track and visualize progress
 2npx ruv-swarm github board-progress \
 3  --show "burndown,velocity,cycle-time" \
 4  --time-period "sprint" \
 5  --export-metrics
 6
 7# Generate reports
 8npx ruv-swarm github board-report \
 9  --type "sprint-summary" \
10  --format "markdown" \
11  --include "velocity,burndown,blockers" \
12  --distribute "slack,email"

 1# Track board performance
 2npx ruv-swarm github board-kpis \
 3  --metrics '[
 4    "average-cycle-time",
 5    "throughput-per-sprint",
 6    "blocked-time-percentage",
 7    "first-time-pass-rate"
 8  ]' \
 9  --dashboard-url
10
11# Track team performance
12npx ruv-swarm github team-metrics \
13  --board "Development" \
14  --per-member \
15  --include "velocity,quality,collaboration" \
16  --anonymous-option

1# Plan releases using board data
2npx ruv-swarm github release-plan-board \
3  --analyze-velocity \
4  --estimate-completion \
5  --identify-risks \
6  --optimize-scope

 1# Sync across multiple boards
 2npx ruv-swarm github multi-board-sync \
 3  --boards "Development,QA,Release" \
 4  --sync-rules '{
 5    "Development->QA": "when:ready-for-test",
 6    "QA->Release": "when:tests-pass"
 7  }'
 8
 9# Cross-organization sync
10npx ruv-swarm github cross-org-sync \
11  --source "org1/Project-A" \
12  --target "org2/Project-B" \
13  --field-mapping "custom" \
14  --conflict-resolution "source-wins"

1# Handle issue dependencies
2npx ruv-swarm github issue-deps 456 \
3  --resolve-order \
4  --parallel-safe \
5  --update-blocking

1# Coordinate epic-level swarms
2npx ruv-swarm github epic-swarm \
3  --epic 123 \
4  --child-issues "456,457,458" \
5  --orchestrate

1# Handle issues across repositories
2npx ruv-swarm github cross-repo \
3  --issue "org/repo#456" \
4  --related "org/other-repo#123" \
5  --coordinate

1# Distribute work among team
2npx ruv-swarm github board-distribute \
3  --strategy "skills-based" \
4  --balance-workload \
5  --respect-preferences \
6  --notify-assignments

1# Generate standup reports
2npx ruv-swarm github standup-report \
3  --team "frontend" \
4  --include "yesterday,today,blockers" \
5  --format "slack" \
6  --schedule "daily-9am"

1# Coordinate reviews via board
2npx ruv-swarm github review-coordinate \
3  --board "Code Review" \
4  --assign-reviewers \
5  --track-feedback \
6  --ensure-coverage