feat(skills): add CCW orchestrator and refactor command-guide to ccw-help

CCW Skill (new):
- Stateless workflow orchestrator with intent classification
- 6 workflow combinations: rapid, full, coupled, bugfix, issue, ui
- External configuration: intent-rules.json, workflow-chains.json
- Implicit CLI tool injection (Gemini/Qwen/Codex)
- TODO tracking integration for workflow progress

CCW-Help Skill (refactored from command-guide):
- Renamed command-guide → ccw-help
- Removed reference folder duplication
- Source paths now relative from index/ (../../../commands/...)
- Added all-agents.json index
- Simplified SKILL.md following CCW pattern
This commit is contained in:
catlog22
2026-01-03 18:46:59 +08:00
parent ad6c18f615
commit e3dba87e08
122 changed files with 4293 additions and 42193 deletions

462
.claude/skills/ccw/SKILL.md Normal file
View File

@@ -0,0 +1,462 @@
---
name: ccw
description: Stateless workflow orchestrator that automatically selects and executes the optimal workflow combination based on task intent. Supports rapid (lite-plan+execute), full (brainstorm+plan+execute), coupled (plan+execute), bugfix (lite-fix), and issue (multi-point fixes) workflows. Triggers on "ccw", "workflow", "自动工作流", "智能调度".
allowed-tools: Task(*), SlashCommand(*), AskUserQuestion(*), Read(*), Bash(*), Grep(*)
---
# CCW - Claude Code Workflow Orchestrator
无状态工作流协调器,根据任务意图自动选择并执行最优工作流组合。
## Architecture Overview
```
┌─────────────────────────────────────────────────────────────────┐
│ CCW Orchestrator (Stateless) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Input Analysis │
│ ├─ Intent Classification (bugfix/feature/refactor/issue/...) │
│ ├─ Complexity Assessment (low/medium/high) │
│ ├─ Context Detection (codebase familiarity needed?) │
│ └─ Constraint Extraction (time/scope/quality) │
│ │
│ Workflow Selection (Decision Tree) │
│ ├─ 🐛 Bug? → lite-fix / lite-fix --hotfix │
│ ├─ ❓ Unclear? → brainstorm → plan → execute │
│ ├─ ⚡ Simple? → lite-plan → lite-execute │
│ ├─ 🔧 Complex? → plan → execute │
│ ├─ 📋 Issue? → issue:plan → issue:queue → issue:execute │
│ └─ 🎨 UI? → ui-design → plan → execute │
│ │
│ Execution Dispatch │
│ └─ SlashCommand("/workflow:xxx") or Task(agent) │
│ │
└─────────────────────────────────────────────────────────────────┘
```
## Workflow Combinations (组合技)
### 1. Rapid (快速迭代) ⚡
**Pattern**: 多模型协作分析 + 直接执行
**Commands**: `/workflow:lite-plan``/workflow:lite-execute`
**When to use**:
- 明确知道做什么和怎么做
- 单一功能或小型改动
- 快速原型验证
### 2. Full (完整流程) 📋
**Pattern**: 分析 + 头脑风暴 + 规划 + 执行
**Commands**: `/workflow:brainstorm:auto-parallel``/workflow:plan``/workflow:execute`
**When to use**:
- 不确定产品方向或技术方案
- 需要多角色视角分析
- 复杂新功能开发
### 3. Coupled (复杂耦合) 🔗
**Pattern**: 完整规划 + 验证 + 执行
**Commands**: `/workflow:plan``/workflow:action-plan-verify``/workflow:execute`
**When to use**:
- 跨模块依赖
- 架构级变更
- 团队协作项目
### 4. Bugfix (缺陷修复) 🐛
**Pattern**: 智能诊断 + 修复
**Commands**: `/workflow:lite-fix` or `/workflow:lite-fix --hotfix`
**When to use**:
- 任何有明确症状的Bug
- 生产事故紧急修复
- 根因不清楚需要诊断
### 5. Issue (长时间多点修复) 📌
**Pattern**: Issue规划 + 队列 + 批量执行
**Commands**: `/issue:plan``/issue:queue``/issue:execute`
**When to use**:
- 多个相关问题需要批量处理
- 长时间跨度的修复任务
- 需要优先级排序和冲突解决
### 6. UI-First (设计驱动) 🎨
**Pattern**: UI设计 + 规划 + 执行
**Commands**: `/workflow:ui-design:*``/workflow:plan``/workflow:execute`
**When to use**:
- 前端功能开发
- 需要视觉参考
- 设计系统集成
## Intent Classification
```javascript
function classifyIntent(input) {
const text = input.toLowerCase()
// Priority 1: Bug keywords
if (/\b(fix|bug|error|issue|crash|broken|fail|wrong|incorrect)\b/.test(text)) {
if (/\b(hotfix|urgent|production|critical|emergency)\b/.test(text)) {
return { type: 'bugfix', mode: 'hotfix', workflow: 'lite-fix --hotfix' }
}
return { type: 'bugfix', mode: 'standard', workflow: 'lite-fix' }
}
// Priority 2: Issue batch keywords
if (/\b(issues?|batch|queue|多个|批量)\b/.test(text) && /\b(fix|resolve|处理)\b/.test(text)) {
return { type: 'issue', workflow: 'issue:plan → issue:queue → issue:execute' }
}
// Priority 3: Uncertainty keywords → Full workflow
if (/\b(不确定|不知道|explore|研究|分析一下|怎么做|what if|should i|探索)\b/.test(text)) {
return { type: 'exploration', workflow: 'brainstorm → plan → execute' }
}
// Priority 4: UI/Design keywords
if (/\b(ui|界面|design|设计|component|组件|style|样式|layout|布局)\b/.test(text)) {
return { type: 'ui', workflow: 'ui-design → plan → execute' }
}
// Priority 5: Complexity assessment for remaining
const complexity = assessComplexity(text)
if (complexity === 'high') {
return { type: 'feature', complexity: 'high', workflow: 'plan → verify → execute' }
}
if (complexity === 'medium') {
return { type: 'feature', complexity: 'medium', workflow: 'lite-plan → lite-execute' }
}
return { type: 'feature', complexity: 'low', workflow: 'lite-plan → lite-execute' }
}
function assessComplexity(text) {
let score = 0
// Architecture keywords
if (/\b(refactor|重构|migrate|迁移|architect|架构|system|系统)\b/.test(text)) score += 2
// Multi-module keywords
if (/\b(multiple|多个|across|跨|all|所有|entire|整个)\b/.test(text)) score += 2
// Integration keywords
if (/\b(integrate|集成|connect|连接|api|database|数据库)\b/.test(text)) score += 1
// Security/Performance keywords
if (/\b(security|安全|performance|性能|scale|扩展)\b/.test(text)) score += 1
if (score >= 4) return 'high'
if (score >= 2) return 'medium'
return 'low'
}
```
## Execution Flow
### Phase 1: Input Analysis
```javascript
// Parse user input
const input = userInput.trim()
// Check for explicit workflow request
if (input.startsWith('/workflow:') || input.startsWith('/issue:')) {
// User explicitly requested a workflow, pass through
SlashCommand(input)
return
}
// Classify intent
const intent = classifyIntent(input)
console.log(`
## Intent Analysis
**Input**: ${input.substring(0, 100)}...
**Classification**: ${intent.type}
**Complexity**: ${intent.complexity || 'N/A'}
**Recommended Workflow**: ${intent.workflow}
`)
```
### Phase 2: User Confirmation (Optional)
```javascript
// For high-complexity or ambiguous intents, confirm with user
if (intent.complexity === 'high' || intent.type === 'exploration') {
const confirmation = AskUserQuestion({
questions: [{
question: `Recommended: ${intent.workflow}. Proceed?`,
header: "Workflow",
multiSelect: false,
options: [
{ label: `${intent.workflow} (Recommended)`, description: "Use recommended workflow" },
{ label: "Rapid (lite-plan)", description: "Quick iteration" },
{ label: "Full (brainstorm+plan)", description: "Complete exploration" },
{ label: "Manual", description: "I'll specify the commands" }
]
}]
})
// Adjust workflow based on user selection
intent.workflow = mapSelectionToWorkflow(confirmation)
}
```
### Phase 3: Workflow Dispatch
```javascript
switch (intent.workflow) {
case 'lite-fix':
SlashCommand('/workflow:lite-fix', args: input)
break
case 'lite-fix --hotfix':
SlashCommand('/workflow:lite-fix --hotfix', args: input)
break
case 'lite-plan → lite-execute':
SlashCommand('/workflow:lite-plan', args: input)
// lite-plan will automatically dispatch to lite-execute
break
case 'plan → verify → execute':
SlashCommand('/workflow:plan', args: input)
// After plan, prompt for verify and execute
break
case 'brainstorm → plan → execute':
SlashCommand('/workflow:brainstorm:auto-parallel', args: input)
// After brainstorm, continue with plan
break
case 'issue:plan → issue:queue → issue:execute':
SlashCommand('/issue:plan', args: input)
// Issue workflow handles queue and execute
break
case 'ui-design → plan → execute':
// Determine UI design subcommand
if (hasReference(input)) {
SlashCommand('/workflow:ui-design:imitate-auto', args: input)
} else {
SlashCommand('/workflow:ui-design:explore-auto', args: input)
}
break
}
```
## CLI Tool Integration
CCW **隐式调用** CLI 工具以获得三大优势:
### 1. Token 效率 (Context Efficiency)
CLI 工具在单独进程中运行,可以处理大量代码上下文而不消耗主会话 token
| 场景 | 触发条件 | 自动注入 |
|------|----------|----------|
| 大量代码上下文 | 文件读取 ≥ 50k 字符 | `gemini --mode analysis` |
| 多模块分析 | 涉及 ≥ 5 个模块 | `gemini --mode analysis` |
| 代码审查 | review 步骤 | `gemini --mode analysis` |
### 2. 多模型视角 (Multi-Model Perspectives)
不同模型有不同优势CCW 根据任务类型自动选择:
| Tool | 核心优势 | 最佳场景 | 触发关键词 |
|------|----------|----------|------------|
| Gemini | 超长上下文、深度分析、架构理解、执行流追踪 | 代码库理解、架构评估、根因分析 | "分析", "理解", "设计", "架构", "诊断" |
| Qwen | 代码模式识别、多维度分析 | Gemini备选、第二视角验证 | "评估", "对比", "验证" |
| Codex | 精确代码生成、自主执行、数学推理 | 功能实现、重构、测试 | "实现", "重构", "修复", "生成", "测试" |
### 3. 增强能力 (Enhanced Capabilities)
#### Debug 能力增强
```
触发条件: intent === 'bugfix' AND root_cause_unclear
自动注入: gemini --mode analysis (执行流追踪)
用途: 假设驱动调试、状态机错误诊断、并发问题排查
```
#### 规划能力增强
```
触发条件: complexity === 'high' OR intent === 'exploration'
自动注入: gemini --mode analysis (架构分析)
用途: 复杂任务先用CLI分析获取多模型视角
```
### 隐式注入规则 (Implicit Injection Rules)
CCW 在以下条件自动注入 CLI 调用(无需用户显式请求):
```javascript
const implicitRules = {
// 上下文收集大量代码使用CLI可节省主会话token
context_gathering: {
trigger: 'file_read >= 50k chars OR module_count >= 5',
inject: 'gemini --mode analysis'
},
// 规划前分析复杂任务先用CLI分析
pre_planning_analysis: {
trigger: 'complexity === "high" OR intent === "exploration"',
inject: 'gemini --mode analysis'
},
// 调试诊断利用Gemini的执行流追踪能力
debug_diagnosis: {
trigger: 'intent === "bugfix" AND root_cause_unclear',
inject: 'gemini --mode analysis'
},
// 代码审查用CLI减少token占用
code_review: {
trigger: 'step === "review"',
inject: 'gemini --mode analysis'
},
// 多任务执行用Codex自主完成
implementation: {
trigger: 'step === "execute" AND task_count >= 3',
inject: 'codex --mode write'
}
}
```
### 用户语义触发 (Semantic Tool Assignment)
```javascript
// 用户可以通过自然语言指定工具偏好
const toolHints = {
gemini: /用\s*gemini|gemini\s*分析|让\s*gemini|深度分析|架构理解/i,
qwen: /用\s*qwen|qwen\s*评估|让\s*qwen|第二视角/i,
codex: /用\s*codex|codex\s*实现|让\s*codex|自主完成|批量修改/i
}
function detectToolPreference(input) {
for (const [tool, pattern] of Object.entries(toolHints)) {
if (pattern.test(input)) return tool
}
return null // Auto-select based on task type
}
```
### 独立 CLI 工作流 (Standalone CLI Workflows)
直接调用 CLI 进行特定任务:
| Workflow | 命令 | 用途 |
|----------|------|------|
| CLI Analysis | `ccw cli --tool gemini` | 大型代码库快速理解、架构评估 |
| CLI Implement | `ccw cli --tool codex` | 明确需求的自主实现 |
| CLI Debug | `ccw cli --tool gemini` | 复杂bug根因分析、执行流追踪 |
## Index Files (Dynamic Coordination)
CCW 使用索引文件实现智能命令协调:
| Index | Purpose |
|-------|---------|
| [index/command-capabilities.json](index/command-capabilities.json) | 命令能力分类explore, plan, execute, test, review... |
| [index/workflow-chains.json](index/workflow-chains.json) | 预定义工作流链rapid, full, coupled, bugfix, issue, tdd, ui... |
### 能力分类
```
capabilities:
├── explore - 代码探索、上下文收集
├── brainstorm - 多角色分析、方案探索
├── plan - 任务规划、分解
├── verify - 计划验证、质量检查
├── execute - 任务执行、代码实现
├── bugfix - Bug诊断、修复
├── test - 测试生成、执行
├── review - 代码审查、质量分析
├── issue - 批量问题管理
├── ui-design - UI设计、原型
├── memory - 文档、知识管理
├── session - 会话管理
└── debug - 调试、问题排查
```
## TODO Tracking Integration
CCW 自动使用 TodoWrite 跟踪工作流执行进度:
```javascript
// 工作流启动时自动创建 TODO 列表
TodoWrite({
todos: [
{ content: "CCW: Rapid Iteration (2 steps)", status: "in_progress", activeForm: "Running workflow" },
{ content: "[1/2] /workflow:lite-plan", status: "in_progress", activeForm: "Executing lite-plan" },
{ content: "[2/2] /workflow:lite-execute", status: "pending", activeForm: "Executing lite-execute" }
]
})
// 每个步骤完成后自动更新状态
// 支持暂停、继续、跳过操作
```
**进度可视化**:
```
✓ CCW: Rapid Iteration (2 steps)
✓ [1/2] /workflow:lite-plan
→ [2/2] /workflow:lite-execute
```
**控制命令**:
| Input | Action |
|-------|--------|
| `continue` | 执行下一步 |
| `skip` | 跳过当前步骤 |
| `abort` | 停止工作流 |
| `/workflow:*` | 执行指定命令 |
## Reference Documents
| Document | Purpose |
|----------|---------|
| [phases/orchestrator.md](phases/orchestrator.md) | 编排器决策逻辑 + TODO 跟踪 |
| [phases/actions/rapid.md](phases/actions/rapid.md) | 快速迭代组合 |
| [phases/actions/full.md](phases/actions/full.md) | 完整流程组合 |
| [phases/actions/coupled.md](phases/actions/coupled.md) | 复杂耦合组合 |
| [phases/actions/bugfix.md](phases/actions/bugfix.md) | 缺陷修复组合 |
| [phases/actions/issue.md](phases/actions/issue.md) | Issue工作流组合 |
| [specs/intent-classification.md](specs/intent-classification.md) | 意图分类规范 |
| [WORKFLOW_DECISION_GUIDE.md](/WORKFLOW_DECISION_GUIDE.md) | 工作流决策指南 |
## Examples
### Example 1: Bug Fix
```
User: 用户登录失败,返回 401 错误
CCW: Intent=bugfix, Workflow=lite-fix
→ /workflow:lite-fix "用户登录失败,返回 401 错误"
```
### Example 2: New Feature (Simple)
```
User: 添加用户头像上传功能
CCW: Intent=feature, Complexity=low, Workflow=lite-plan→lite-execute
→ /workflow:lite-plan "添加用户头像上传功能"
```
### Example 3: Complex Refactoring
```
User: 重构整个认证模块,迁移到 OAuth2
CCW: Intent=feature, Complexity=high, Workflow=plan→verify→execute
→ /workflow:plan "重构整个认证模块,迁移到 OAuth2"
```
### Example 4: Exploration
```
User: 我想优化系统性能,但不知道从哪入手
CCW: Intent=exploration, Workflow=brainstorm→plan→execute
→ /workflow:brainstorm:auto-parallel "探索系统性能优化方向"
```
### Example 5: Multi-Model Collaboration
```
User: 用 gemini 分析现有架构,然后让 codex 实现优化
CCW: Detects tool preferences, executes in sequence
→ Gemini CLI (analysis) → Codex CLI (implementation)
```