关于 github-project-management
github-project-management 是通过 AI swarm 协调 GitHub Issue 与项目看板的技能，涵盖 Issue 分诊和拆解、看板同步、迭代跟踪，以及跨团队和仓库协作。
主要功能
- 01Issue 创建、分诊与拆解
- 02项目看板同步
- 03自动分配卡片与状态流转
- 04迭代及进度跟踪
- 05跨看板和跨仓库协作
适用场景
- 01将 Issue 转为协同 swarm 任务
- 02同步 swarm 工作与项目看板
- 03跟踪迭代进度和交付指标
- 04协调多个仓库中的关联工作
MCP 相关
该技能提供使用 claude-flow MCP 工具初始化 swarm、创建 Agent 和管理 GitHub Issue 的示例。
安装
复制下面的命令，在终端中运行。
$
npx skills add https:/安装后在 Claude Code 中输入/github-project-management确认已加载。
详细介绍
GitHub 项目管理
概述
一套全面的技能，利用 AI 群集协同管理 GitHub 项目。此技能结合了智能问题管理、自动化项目看板同步和基于群集的协同机制，可高效交付项目。
快速入门
使用群集协同创建基本问题
# 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"
快速设置项目看板
# 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"
核心能力
1. 问题管理与分流
自动创建问题<$strong><$summary>
使用群集协同创建单个问题
// 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"
}
批量创建问题
# 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>
将问题转换为群集任务<$strong><$summary>
将问题转换为群集任务
# 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
问题评论命令
通过问题评论执行群集操作：
$swarm analyze
$swarm decompose 5
$swarm assign @agent-coder
$swarm estimate
$swarm start
<$details>
自动问题分流<$strong><$summary>
根据内容自动添加标签
// .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"]
}
]
}
自动分流系统
# 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>
任务拆解与进度跟踪<$strong><$summary>
将问题拆解为子任务
# 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
自动更新进度
# 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>
过期问题管理<$strong><$summary>
通过群集分析自动关闭过期问题
# 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. 项目看板自动化
看板初始化与配置<$strong><$summary>
将群集连接到 GitHub 项目
# 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"
看板映射配置
# .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>
任务同步<$strong><$summary>
实时看板同步
# 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
将问题转换为项目卡片
# 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>
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
// 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"
}
# 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"
将问题转换为群集任务<$strong><$summary>
将问题转换为群集任务
# 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
问题评论命令
通过问题评论执行群集操作：
$swarm analyze
$swarm decompose 5
$swarm assign @agent-coder
$swarm estimate
$swarm start
<$details>
自动问题分流<$strong><$summary>
根据内容自动添加标签
// .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"]
}
]
}
自动分流系统
# 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>
任务拆解与进度跟踪<$strong><$summary>
将问题拆解为子任务
# 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
自动更新进度
# 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>
过期问题管理<$strong><$summary>
通过群集分析自动关闭过期问题
# 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. 项目看板自动化
看板初始化与配置<$strong><$summary>
将群集连接到 GitHub 项目
# 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"
看板映射配置
# .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>
任务同步<$strong><$summary>
实时看板同步
# 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
将问题转换为项目卡片
# 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>
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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
$swarm analyze
$swarm decompose 5
$swarm assign @agent-coder
$swarm estimate
$swarm start
自动问题分流<$strong><$summary>
根据内容自动添加标签
// .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"]
}
]
}
自动分流系统
# 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>
任务拆解与进度跟踪<$strong><$summary>
将问题拆解为子任务
# 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
自动更新进度
# 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>
过期问题管理<$strong><$summary>
通过群集分析自动关闭过期问题
# 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. 项目看板自动化
看板初始化与配置<$strong><$summary>
将群集连接到 GitHub 项目
# 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"
看板映射配置
# .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>
任务同步<$strong><$summary>
实时看板同步
# 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
将问题转换为项目卡片
# 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>
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
// .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"]
}
]
}
# 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
任务拆解与进度跟踪<$strong><$summary>
将问题拆解为子任务
# 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
自动更新进度
# 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>
过期问题管理<$strong><$summary>
通过群集分析自动关闭过期问题
# 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. 项目看板自动化
看板初始化与配置<$strong><$summary>
将群集连接到 GitHub 项目
# 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"
看板映射配置
# .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>
任务同步<$strong><$summary>
实时看板同步
# 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
将问题转换为项目卡片
# 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>
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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
# 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
过期问题管理<$strong><$summary>
通过群集分析自动关闭过期问题
# 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. 项目看板自动化
看板初始化与配置<$strong><$summary>
将群集连接到 GitHub 项目
# 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"
看板映射配置
# .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>
任务同步<$strong><$summary>
实时看板同步
# 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
将问题转换为项目卡片
# 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>
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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
看板初始化与配置<$strong><$summary>
将群集连接到 GitHub 项目
# 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"
看板映射配置
# .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>
任务同步<$strong><$summary>
实时看板同步
# 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
将问题转换为项目卡片
# 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>
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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"
# .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
任务同步<$strong><$summary>
实时看板同步
# 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
将问题转换为项目卡片
# 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>
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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
# 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
智能卡片管理<$strong><$summary>
自动分配
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
智能卡片状态转换
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
<$details>
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# Automatically assign cards to agents
npx ruv-swarm github board-auto-assign \
--strategy "load-balanced" \
--consider "expertise,workload,availability" \
--update-cards
# 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 card operations
npx ruv-swarm github board-bulk \
--filter "status:blocked" \
--action "add-label:needs-attention" \
--notify-assignees
自定义视图与仪表板<$strong><$summary>
视图配置
// 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 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 规划与跟踪
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
// 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 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"
}
]
}
}
Sprint 管理<$strong><$summary>
使用群集协同初始化 Sprint
# 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
敏捷开发看板设置
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
Kanban 流程看板设置
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
<$details>
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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
# Setup agile board
npx ruv-swarm github agile-board \
--methodology "scrum" \
--sprint-length "2w" \
--ceremonies "planning,review,retro" \
--metrics "velocity,burndown"
# Setup kanban board
npx ruv-swarm github kanban-board \
--wip-limits '{
"In Progress": 5,
"Review": 3
}' \
--cycle-time-tracking \
--continuous-flow
进度跟踪与分析<$strong><$summary>
看板分析
# 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"
性能报告
# 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 跟踪
# 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>
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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"
# 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"
# 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
发布规划<$strong><$summary>
发布协同
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
<$details>
4. 高级协同
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# Plan releases using board data
npx ruv-swarm github release-plan-board \
--analyze-velocity \
--estimate-completion \
--identify-risks \
--optimize-scope
多看板同步<$strong><$summary>
跨看板同步
# 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>
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# 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"
问题依赖与 Epic 管理<$strong><$summary>
依赖关系处理
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
Epic 协同
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
<$details>
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# Handle issue dependencies
npx ruv-swarm github issue-deps 456 \
--resolve-order \
--parallel-safe \
--update-blocking
# Coordinate epic-level swarms
npx ruv-swarm github epic-swarm \
--epic 123 \
--child-issues "456,457,458" \
--orchestrate
跨仓库协同<$strong><$summary>
多仓库问题管理
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
<$details>
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# Handle issues across repositories
npx ruv-swarm github cross-repo \
--issue "org$repo#456" \
--related "org$other-repo#123" \
--coordinate
团队协作<$strong><$summary>
工作分配
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
站会自动化
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
评审协同
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
<$details>
问题模板
集成问题模板
## 🔄 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 报告模板
## 🐛 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
### 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
群集任务模板
name: Swarm Task
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
工作流集成
用于问题管理的 GitHub Actions
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
看板集成工作流
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
专用问题处理策略
Bug 调查群集
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
功能实现群集
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
技术债务重构
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
最佳实践
1. 群组协同问题管理
- 处理复杂问题时，始终初始化群组
- 根据问题类型分配专用 Agent
- 使用记忆协调进度
- 定期自动更新进度
2. 看板组织
- 明确列定义并保持命名一致
- 在各个仓库中采用系统化的标签策略
- 定期整理和维护看板
- 制定明确的自动化规则
3. 数据完整性
- 验证双向同步
- 制定冲突解决策略
- 保留全面的审计跟踪记录
- 定期备份项目数据
4. 团队采用
- 提供全面的培训材料
- 制定清晰、有文档记录的工作流
- 定期开展团队评审和回顾
- 建立积极的反馈循环以持续改进
5. 智能标签和组织
- 在各个仓库中采用一致的标签策略
- 按优先级对问题进行排序和分配
- 集成里程碑以协调项目
- 建立 Agent 类型与标签的映射
6. 自动进度跟踪
- 通过群组协同定期自动更新
- 跟踪进度指标和完成情况
- 管理跨问题依赖关系
- 实时同步状态
故障排除
同步问题
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
性能优化
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
数据恢复
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
指标与分析
性能指标
自动跟踪：
- 问题创建和解决所需时间
- Agent 生产力指标
- 项目里程碑进度
- 跨仓库协同效率
- 冲刺速度和燃尽情况
- 周期时间和吞吐量
- 在制工作限制
报告功能
- 每周进度摘要
- Agent 性能分析
- 项目健康指标
- 集成成功率
- 团队协作指标
- 质量和缺陷跟踪
问题解决时间
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
群组效能
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
安全与权限
- 命令授权：执行命令前验证用户权限
- 速率限制：防止问题命令被滥用或用于发送垃圾信息
- 审计日志：跟踪所有针对问题和看板的群组操作
- 数据隐私：遵守私有仓库设置
- 访问控制：为看板操作设置适当的 GitHub 权限
- Webhook 安全：保护用于实时更新的 Webhook 端点
与其他技能集成
无缝集成：
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流
完整工作流示例
全栈功能开发
# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
快速参考命令
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
其他资源
最后更新：2025-10-19
版本：2.0.0
维护者：Claude Code
# Distribute work among team
npx ruv-swarm github board-distribute \
--strategy "skills-based" \
--balance-workload \
--respect-preferences \
--notify-assignments
# Generate standup reports
npx ruv-swarm github standup-report \
--team "frontend" \
--include "yesterday,today,blockers" \
--format "slack" \
--schedule "daily-9am"
# Coordinate reviews via board
npx ruv-swarm github review-coordinate \
--board "Code Review" \
--assign-reviewers \
--track-feedback \
--ensure-coverage
## 🔄 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
### 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
### 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
name: Swarm Task
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
# .github$workflows$issue-swarm.yml
name: Issue Swarm Handler
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
# Sync with project board
npx ruv-swarm github issue-board-sync \
--project "Development" \
--column-mapping '{
"To Do": "pending",
"In Progress": "active",
"Done": "completed"
}'
# Specialized bug handling
npx ruv-swarm github bug-swarm 456 \
--reproduce \
--isolate \
--fix \
--test
# Feature implementation swarm
npx ruv-swarm github feature-swarm 456 \
--design \
--implement \
--document \
--demo
# Refactoring swarm
npx ruv-swarm github debt-swarm 456 \
--analyze-impact \
--plan-migration \
--execute \
--validate
# Diagnose sync problems
npx ruv-swarm github board-diagnose \
--check "permissions,webhooks,rate-limits" \
--test-sync \
--show-conflicts
# Optimize board performance
npx ruv-swarm github board-optimize \
--analyze-size \
--archive-completed \
--index-fields \
--cache-views
# Recover board data
npx ruv-swarm github board-recover \
--backup-id "2024-01-15" \
--restore-cards \
--preserve-current \
--merge-conflicts
# Analyze swarm performance
npx ruv-swarm github issue-metrics \
--issue 456 \
--metrics "time-to-close,agent-efficiency,subtask-completion"
# Generate effectiveness report
npx ruv-swarm github effectiveness \
--issues "closed:>2024-01-01" \
--compare "with-swarm,without-swarm"
github-pr-workflow - 自动将问题关联到拉取请求github-release-management - 协调发布问题和里程碑sparc-orchestrator - 复杂的项目协调工作流sparc-tester - 针对问题的自动化测试工作流# 1. Create feature issue with swarm coordination
gh issue create \
--title "Feature: Real-time Collaboration" \
--body "$(cat <<EOF
## Feature: Real-time Collaboration
### Overview
Implement real-time collaboration features using WebSockets.
### Objectives
- [ ] WebSocket server setup
- [ ] Client-side integration
- [ ] Presence tracking
- [ ] Conflict resolution
- [ ] Testing and documentation
### Swarm Coordination
This feature will use mesh topology for parallel development.
EOF
)" \
--label "enhancement,swarm-ready,high-priority"
# 2. Initialize swarm and decompose tasks
ISSUE_NUM=$(gh issue list --label "swarm-ready" --limit 1 --json number --jq '.[0].number')
npx ruv-swarm github issue-init $ISSUE_NUM \
--topology mesh \
--auto-decompose \
--assign-agents "architect,coder,tester"
# 3. Add to project board
PROJECT_ID=$(gh project list --owner @me --format json | jq -r '.projects[0].id')
gh project item-add $PROJECT_ID --owner @me \
--url "https:/$github.com/$GITHUB_REPOSITORY$issues/$ISSUE_NUM"
# 4. Set up automated tracking
npx ruv-swarm github board-sync \
--auto-move-cards \
--update-metadata
# 5. Monitor progress
npx ruv-swarm github issue-progress $ISSUE_NUM \
--auto-update-comments \
--notify-on-completion
# Issue Management
gh issue create --title "..." --body "..." --label "..."
npx ruv-swarm github issue-init <number>
npx ruv-swarm github issue-decompose <number>
npx ruv-swarm github triage --unlabeled
# Project Boards
npx ruv-swarm github board-init --project-id <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 <number>
npx ruv-swarm github board-kpis
评论
支持 Markdown