Ccw

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

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

// 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)

// 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

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：

2. 多模型视角 (Multi-Model Perspectives)

不同模型有不同优势，CCW 根据任务类型自动选择：

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 调用（无需用户显式请求）：

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)

// 用户可以通过自然语言指定工具偏好
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 进行特定任务：

Index Files (Dynamic Coordination)

CCW 使用索引文件实现智能命令协调：

能力分类

capabilities:
├── explore    - 代码探索、上下文收集
├── brainstorm - 多角色分析、方案探索
├── plan       - 任务规划、分解
├── verify     - 计划验证、质量检查
├── execute    - 任务执行、代码实现
├── bugfix     - Bug诊断、修复
├── test       - 测试生成、执行
├── review     - 代码审查、质量分析
├── issue      - 批量问题管理
├── ui-design  - UI设计、原型
├── memory     - 文档、知识管理
├── session    - 会话管理
└── debug      - 调试、问题排查

TODO Tracking Integration

CCW 自动使用 TodoWrite 跟踪工作流执行进度：

// 工作流启动时自动创建 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

控制命令:

Reference Documents

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)