feat: add CLI Viewer Page with multi-pane layout and state management

- Implemented the CliViewerPage component for displaying CLI outputs in a configurable multi-pane layout.
- Integrated Zustand for state management, allowing for dynamic layout changes and tab management.
- Added layout options: single, split horizontal, split vertical, and 2x2 grid.
- Created viewerStore for managing layout, panes, and tabs, including actions for adding/removing panes and tabs.
- Added CoordinatorPage barrel export for easier imports.
This commit is contained in:
catlog22
2026-02-03 17:28:26 +08:00
parent b63e254f36
commit 37ba849e75
101 changed files with 10422 additions and 1145 deletions

View File

@@ -0,0 +1,375 @@
---
title: 工作流常见问题
description: 工作流使用中的常见问题和解答
sidebar_position: 7
---
import Mermaid from '@theme/Mermaid';
# 工作流常见问题
CCW 工作流的常见问题和解答。
## 通用问题
### Main Workflow 和 Issue Workflow 有什么区别?
**Main Workflow** 用于主要开发Level 1-5而 **Issue Workflow** 用于开发后期的维护工作。
| 方面 | Main Workflow | Issue Workflow |
|--------|---------------|----------------|
| **用途** | 功能开发 | 开发后修复 |
| **时机** | 开发阶段 | 主工作流完成后 |
| **并行处理** | 依赖分析 | Worktree 隔离(可选) |
### 如何选择合适的工作流级别?
<Mermaid
chart={`
flowchart TD
Start([开始]) --> Q1{开发后期?}
Q1 -->|是| Issue["Issue Workflow"]
Q1 -->|否| Q2{命令不确定?}
Q2 -->|是| L5["Level 5: ccw-coordinator"]
Q2 -->|否| Q3{需求清晰?}
Q3 -->|否| L4["Level 4: brainstorm"]
Q3 -->|是| Q4{需要持久化会话?}
Q4 -->|是| Q5{开发类型?}
Q4 -->|否| Q6{多视角分析?}
Q5 -->|标准开发| L3Std["Level 3: plan"]
Q5 -->|TDD| L3TDD["Level 3: tdd-plan"]
Q5 -->|测试修复| L3Test["Level 3: test-fix-gen"]
Q6 -->|是| L2Multi["Level 2: multi-cli-plan"]
Q6 -->|否| Q7{Bug 修复?}
Q7 -->|是| L2Fix["Level 2: lite-fix"]
Q7 -->|否| Q8{需要规划?}
Q8 -->|是| L2Plan["Level 2: lite-plan"]
Q8 -->|否| L1["Level 1: lite-lite-lite"]
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef decision fill:#fff9c4,stroke:#f57c00
classDef level fill:#e3f2fd,stroke:#1976d2
class Start startend,Q1,Q2,Q3,Q4,Q6,Q7,Q8 decision,Issue,L1,L2Plan,L2Fix,L2Multi,L3Std,L3TDD,L3Test,L4,L5 level
`}
/>
### 什么是最小执行单元?
**最小执行单元**是指必须作为原子组一起执行的命令集合。拆分这些命令会破坏逻辑流程并产生不完整的状态。
**示例**:单元 `lite-plan -> lite-execute` 必须一起完成。在 `lite-plan` 之后停止会留下计划但没有实现。
## Level 1 问题
### 何时使用 Level 1
在以下情况下使用 Level 1 (`lite-lite-lite`)
- 快速修复(拼写错误、小幅调整)
- 简单功能(单个函数、小型工具)
- 配置更改(环境变量、超时值)
- 文档更新readme、注释
**不要使用**在:
- 多模块更改
- 需要持久化记录
- 复杂重构
- 测试驱动开发
## Level 2 问题
### lite-plan、lite-fix 和 multi-cli-plan 有什么区别?
| 工作流 | 用途 | 使用场景 |
|----------|---------|-------------|
| `lite-plan` | 需求清晰 | 单模块功能 |
| `lite-fix` | Bug 诊断 | Bug 修复、生产问题 |
| `multi-cli-plan` | 多视角分析 | 技术选型、方案比较 |
### 什么是热修复模式?
```bash
/workflow:lite-fix --hotfix "Production database connection failing"
```
**热修复模式**
- 跳过大部分诊断阶段
- 最小化规划(直接执行)
- 自动生成后续任务用于完整修复 + 复盘
- **仅用于生产紧急情况**
### 何时使用 multi-cli-plan vs lite-plan
在以下情况下使用 `multi-cli-plan`
- 需要多个视角Gemini、Codex、Claude
- 技术选型决策
- 方案比较
- 架构权衡
在以下情况下使用 `lite-plan`
- 需求清晰
- 单视角足够
- 需要更快迭代
## Level 3 问题
### plan、tdd-plan 和 test-fix-gen 有什么区别?
| 工作流 | 用途 | 关键特性 |
|----------|---------|-------------|
| `plan` | 标准开发 | 5 阶段规划与验证 |
| `tdd-plan` | 测试驱动开发 | 红-绿-重构循环 |
| `test-fix-gen` | 测试修复 | 渐进式测试层级L0-L3|
### 什么是 TDD测试驱动开发
**TDD** 遵循红-绿-重构循环:
1. **红Red**:编写失败的测试
2. **绿Green**:编写最小代码使测试通过
3. **重构Refactor**:在保持测试通过的同时改进代码
**铁律**
```
没有失败的测试就不写生产代码
```
### 为什么 TDD 要求先写测试?
| 方面 | 测试优先 | 测试随后 |
|--------|-----------|------------|
| **证明** | 测试在实现前失败 | 测试立即通过(无证明)|
| **发现** | 编码前发现边界情况 | 编码后发现边界情况 |
| **验证** | 验证需求 | 验证实现 |
### test-fix-gen 中有哪些测试层级?
| 层级 | 类型 | 描述 |
|-------|------|-------------|
| **L0** | 静态 | 类型检查、linting |
| **L1** | 单元 | 函数级别测试 |
| **L2** | 集成 | 组件交互 |
| **L3** | E2E | 完整系统测试 |
## Level 4 问题
### 何时使用 brainstorm:auto-parallel
在以下情况下使用 Level 4 (`brainstorm:auto-parallel`)
- 新功能设计
- 系统架构重构
- 探索性需求
- 不确定的实现方法
- 需要多维度权衡
### brainstorm 中有哪些可用角色?
| 角色 | 描述 |
|------|-------------|
| `system-architect` | 系统设计 |
| `ui-designer` | UI 设计 |
| `ux-expert` | 用户体验 |
| `product-manager` | 产品需求 |
| `product-owner` | 业务价值 |
| `data-architect` | 数据结构 |
| `scrum-master` | 流程和团队 |
| `subject-matter-expert` | 领域专业知识 |
| `test-strategist` | 测试策略 |
### 什么是 With-File 工作流?
**With-File 工作流**提供多 CLI 协作的文档化探索:
| 工作流 | 用途 | 级别 |
|----------|---------|-------|
| `brainstorm-with-file` | 多视角构思 | 4 |
| `debug-with-file` | 假设驱动调试 | 3 |
| `analyze-with-file` | 协作分析 | 3 |
## Level 5 问题
### 何时使用 ccw-coordinator
在以下情况下使用 Level 5 (`ccw-coordinator`)
- 复杂的多步骤工作流
- 不确定使用哪些命令
- 需要端到端自动化
- 需要完整的状态跟踪和可恢复性
- 团队协作统一执行流程
### ccw-coordinator 与其他级别有何不同?
| 方面 | Level 1-4 | Level 5 |
|--------|----------|--------|
| **命令选择** | 手动 | 自动 |
| **编排** | 手动 | 智能 |
| **状态跟踪** | 各异 | 完整持久化 |
## 执行问题
### 什么是 lite-execute
`lite-execute` 是 Level 2 工作流的统一执行命令:
```bash
/workflow:lite-execute --in-memory
```
**特性**
- 独立任务并行执行
- 依赖任务顺序执行
- 通过 TodoWrite 跟踪进度
- 可选代码审查
### 什么是 execute
`execute` 是 Level 3 工作流的统一执行命令:
```bash
/workflow:execute --session WFS-{session-id}
```
**特性**
- 依赖分析
- 并行/顺序任务执行
- 基于会话的进度跟踪
- 任务完成摘要
## 会话问题
### 如何恢复暂停的会话?
```bash
/workflow:session:resume # 恢复最近的会话
/workflow:session:resume WFS-{session-id} # 恢复特定会话
```
### 如何完成会话?
```bash
/workflow:session:complete --session WFS-{session-id}
```
这将使用经验教训归档会话并更新清单。
### 如何列出所有会话?
```bash
/workflow:session:list
```
## 产物问题
### 工作流产物存储在哪里?
| 级别 | 产物位置 |
|-------|-------------------|
| Level 1 | 无(无状态)|
| Level 2 | `memory://plan` 或 `.workflow/.lite-fix/`、`.workflow/.multi-cli-plan/` |
| Level 3 | `.workflow/active/WFS-{session}/` |
| Level 4 | `.workflow/active/WFS-{session}/.brainstorming/` |
| Level 5 | `.workflow/.ccw-coordinator/{session}/` |
### 会话中包含哪些文件?
```
.workflow/active/WFS-{session}/
├── workflow-session.json # 会话元数据
├── IMPL_PLAN.md # 实现计划
├── TODO_LIST.md # 进度跟踪
├── .task/
│ ├── IMPL-001.json # 任务定义
│ ├── IMPL-002.json
│ └── ...
└── .process/
├── context-package.json # 项目上下文
└── planning-notes.md
```
## 测试问题
### 如何为现有代码添加测试?
```bash
# 会话模式(从现有会话)
/workflow:test-fix-gen WFS-user-auth-v2
# 提示模式(直接描述)
/workflow:test-fix-gen "Add unit tests for the auth API"
```
### 如何修复失败的测试?
```bash
/workflow:test-fix-gen "Tests failing for user registration"
/workflow:test-cycle-execute
```
工作流将:
1. 分析测试失败
2. 识别根本原因
3. 迭代修复问题
4. 验证 >= 95% 通过率
## 故障排除
### 我的工作流失败了,该怎么办?
1. **检查错误消息** - 识别根本原因
2. **查看 state.json** - 检查 `.workflow/.ccw-coordinator/{session}/state.json`
3. **恢复会话** - 使用 `/workflow:session:resume` 继续
4. **调整并重试** - 根据错误修改方法
### 如何跳过失败的任务?
编辑任务 JSON 将状态设置为 "completed"
```bash
jq '.status = "completed"' .workflow/active/WFS-{session}/.task/IMPL-001.json
```
### 如何清理旧会话?
```bash
# 列出会话
/workflow:session:list
# 删除特定会话
rm -rf .workflow/active/WFS-{session-id}
# 清理所有已完成的会话
/workflow:clean
```
## 最佳实践
### 工作流最佳实践有哪些?
1. **从简单开始** - 使用满足需求的最低级别
2. **执行前规划** - 尽可能使用验证步骤
3. **持续测试** - 将测试集成到工作流中
4. **代码审查** - 使用内置审查工作流
5. **记录决策** - 对复杂决策使用头脑风暴工作流
### 何时使用 worktree 隔离?
**Worktree 隔离**主要用于 **Issue Workflow**
- 主开发完成后
- 已合并到 `main` 分支
- 发现需要修复的问题
- 需要在不影响当前开发的情况下修复
**Main Workflow** 不需要 worktree因为
- 依赖分析解决了并行问题
- 代理并行执行独立任务
- 不需要文件系统隔离
## 相关文档
- [简介](./introduction.mdx) - 工作流概述
- [Level 1](./level-1-ultra-lightweight.mdx) - 超轻量级工作流
- [Level 2](./level-2-rapid.mdx) - 快速工作流
- [Level 3](./level-3-standard.mdx) - 标准工作流
- [Level 4](./level-4-brainstorm.mdx) - 头脑风暴工作流
- [Level 5](./level-5-intelligent.mdx) - 智能工作流
- [命令](../commands/general/ccw.mdx) - 命令参考

View File

@@ -0,0 +1,313 @@
---
title: 工作流介绍
description: CCW 工作流全面概述 - 从急速执行到智能编排
sidebar_position: 1
---
import Mermaid from '@theme/Mermaid';
# 工作流介绍
CCW 提供两类工作流体系:**主干工作流** (Main Workflow) 和 **Issue 工作流** (Issue Workflow),它们协同覆盖软件开发的完整生命周期。
## 工作流架构概览
<Mermaid
chart={`
graph TB
subgraph Main["主干工作流 (5 个层级)"]
L1["层级 1: 急速执行<br/>lite-lite-lite"]
L2["层级 2: 轻量规划<br/>lite-plan, lite-fix, multi-cli-plan"]
L3["层级 3: 标准规划<br/>plan, tdd-plan, test-fix-gen"]
L4["层级 4: 头脑风暴<br/>brainstorm:auto-parallel"]
L5["层级 5: 智能编排<br/>ccw-coordinator"]
L1 --> L2 --> L3 --> L4 --> L5
end
subgraph Issue["Issue 工作流 (开发后维护)"]
I1["阶段 1: 积累<br/>discover, new"]
I2["阶段 2: 解决<br/>plan, queue, execute"]
I1 --> I2
end
Main -.->|开发完成后| Issue
classDef level1 fill:#e3f2fd,stroke:#1976d2
classDef level2 fill:#bbdefb,stroke:#1976d2
classDef level3 fill:#90caf9,stroke:#1976d2
classDef level4 fill:#64b5f6,stroke:#1976d2
classDef level5 fill:#42a5f5,stroke:#1976d2
classDef issue fill:#fff3e0,stroke:#f57c00
class L1 level1,L2 level2,L3 level3,L4 level4,L5 level5,I1,I2 issue
`}
/>
## 主干工作流 vs Issue 工作流
| 维度 | 主干工作流 | Issue 工作流 |
|------|-------------------|----------------|
| **定位** | 主要开发周期 | 开发后的维护补充 |
| **时机** | 功能开发阶段 | 主干开发完成后 |
| **范围** | 完整功能实现 | 针对性修复/增强 |
| **并行策略** | 依赖分析 + Agent 并行 | Worktree 隔离 (可选) |
| **分支模型** | 在当前分支工作 | 可使用独立 worktree |
### 为什么主干工作流不自动使用 Worktree
**依赖分析已解决并行问题**
1. 规划阶段 (`/workflow:plan`) 执行依赖分析
2. 自动识别任务依赖和关键路径
3. 划分**并行组** (独立任务) 和**串行链** (依赖任务)
4. Agent 并行执行独立任务,无需文件系统隔离
<Mermaid
chart={`
graph TD
subgraph Dependency["依赖分析"]
A["任务 A"]
B["任务 B"]
C["任务 C"]
D["任务 D"]
A & B --> PG["并行组 1<br/>Agent 1"]
C --> SC["串行链<br/>Agent 2"]
D --> SC
PG --> R["结果"]
SC --> R
end
classDef pg fill:#c8e6c9,stroke:#388e3c
classDef sc fill:#fff9c4,stroke:#f57c00
class PG pg,SC sc
`}
/>
### 为什么 Issue 工作流支持 Worktree
Issue 工作流作为**补充机制**,场景不同:
1. 主干开发完成,已合并到 `main`
2. 发现需要修复的问题
3. 需要在不影响当前开发的情况下修复
4. Worktree 隔离让主分支保持稳定
<Mermaid
chart={`
graph LR
Dev["开发"] --> Rel["发布"]
Rel --> Issue["发现问题"]
Issue --> Fix["Worktree 修复"]
Fix --> Merge["合并回主干"]
Merge --> NewDev["继续新功能"]
NewDev -.-> Dev
`}
/>
## 15 个工作流层级详解
### 层级 1: 急速执行
**复杂度**: 低 | **产物**: 无 | **状态**: 无状态
| 工作流 | 描述 |
|----------|-------------|
| `lite-lite-lite` | 超轻量直接执行,零开销 |
**适用于**: 快速修复、简单功能、配置调整
---
### 层级 2: 轻量规划
**复杂度**: 低-中 | **产物**: 内存/轻量文件 | **状态**: 会话内
| 工作流 | 描述 |
|----------|-------------|
| `lite-plan` | 内存规划,适用于明确需求 |
| `lite-fix` | 智能漏洞诊断和修复 |
| `multi-cli-plan` | 多 CLI 协作分析 |
**适用于**: 单模块功能、漏洞修复、技术选型
---
### 层级 2.5: 桥接工作流
**复杂度**: 低-中 | **用途**: 轻量到 Issue 工作流的过渡
| 工作流 | 描述 |
|----------|-------------|
| `rapid-to-issue` | 从快速规划桥接到 Issue 工作流 |
**适用于**: 将轻量规划转换为 Issue 跟踪
---
### 层级 3: 标准规划
**复杂度**: 中-高 | **产物**: 持久化会话文件 | **状态**: 完整会话管理
| 工作流 | 描述 |
|----------|-------------|
| `plan` | 复杂功能开发5 个阶段 |
| `tdd-plan` | 测试驱动开发Red-Green-Refactor |
| `test-fix-gen` | 测试修复生成,渐进式层级 |
**适用于**: 多模块改动、重构、TDD 开发
---
### With-File 工作流 (层级 3-4)
**复杂度**: 中-高 | **产物**: 文档化探索 | **多 CLI**: 支持
| 工作流 | 描述 | 层级 |
|----------|-------------|-------|
| `brainstorm-with-file` | 多视角创意构思 | 4 |
| `debug-with-file` | 假设驱动调试 | 3 |
| `analyze-with-file` | 协作分析 | 3 |
**适用于**: 需要多 CLI 协作的文档化探索
---
### 层级 4: 头脑风暴
**复杂度**: 高 | **产物**: 多角色分析文档 | **角色数**: 3-9
| 工作流 | 描述 |
|----------|-------------|
| `brainstorm:auto-parallel` | 多角色头脑风暴与综合 |
**适用于**: 新功能设计、架构重构、探索性需求
---
### 层级 5: 智能编排
**复杂度**: 所有层级 | **产物**: 完整状态持久化 | **自动化**: 完全自动
| 工作流 | 描述 |
|----------|-------------|
| `ccw-coordinator` | 自动分析并推荐命令链 |
**适用于**: 复杂多步骤工作流、不确定命令、端到端自动化
---
### Issue 工作流
**复杂度**: 可变 | **产物**: Issue 记录 | **隔离**: Worktree 可选
| 阶段 | 命令 |
|-------|----------|
| **积累** | `discover`, `discover-by-prompt`, `new` |
| **解决** | `plan --all-pending`, `queue`, `execute` |
**适用于**: 开发后 Issue 修复、维护主分支稳定性
## 选择合适的工作流
### 快速选择表
| 场景 | 推荐工作流 | 层级 |
|----------|---------------------|-------|
| 快速修复、配置调整 | `lite-lite-lite` | 1 |
| 明确的单模块功能 | `lite-plan -> lite-execute` | 2 |
| 漏洞诊断和修复 | `lite-fix` | 2 |
| 生产环境紧急修复 | `lite-fix --hotfix` | 2 |
| 技术选型、方案对比 | `multi-cli-plan -> lite-execute` | 2 |
| 多模块改动、重构 | `plan -> verify -> execute` | 3 |
| 测试驱动开发 | `tdd-plan -> execute -> tdd-verify` | 3 |
| 测试失败修复 | `test-fix-gen -> test-cycle-execute` | 3 |
| 新功能、架构设计 | `brainstorm:auto-parallel -> plan -> execute` | 4 |
| 复杂多步骤工作流、不确定命令 | `ccw-coordinator` | 5 |
| 开发后 Issue 修复 | Issue 工作流 | - |
### 决策流程图
<Mermaid
chart={`
flowchart TD
Start([开始新任务]) --> Q0{开发后<br/>维护?}
Q0 -->|是| IssueW["Issue 工作流<br/>discover -> plan -> queue -> execute"]
Q0 -->|否| Q1{不确定使用<br/>哪些命令?}
Q1 -->|是| L5["层级 5: ccw-coordinator<br/>自动分析并推荐"]
Q1 -->|否| Q2{需求<br/>明确?}
Q2 -->|不确定| L4["层级 4: brainstorm:auto-parallel<br/>多角色探索"]
Q2 -->|明确| Q3{需要持久化<br/>会话?}
Q3 -->|是| Q4{开发类型?}
Q3 -->|否| Q5{需要多<br/>视角?}
Q4 -->|标准| L3Std["层级 3: plan -> verify -> execute"]
Q4 -->|TDD| L3TDD["层级 3: tdd-plan -> execute -> verify"]
Q4 -->|测试修复| L3Test["层级 3: test-fix-gen -> test-cycle"]
Q5 -->|是| L2Multi["层级 2: multi-cli-plan"]
Q5 -->|否| Q6{漏洞修复?}
Q6 -->|是| L2Fix["层级 2: lite-fix"]
Q6 -->|否| Q7{需要规划?}
Q7 -->|是| L2Plan["层级 2: lite-plan -> lite-execute"]
Q7 -->|否| L1["层级 1: lite-lite-lite"]
IssueW --> End([完成])
L5 --> End
L4 --> End
L3Std --> End
L3TDD --> End
L3Test --> End
L2Multi --> End
L2Fix --> End
L2Plan --> End
L1 --> End
classDef level1 fill:#e3f2fd,stroke:#1976d2
classDef level2 fill:#bbdefb,stroke:#1976d2
classDef level3 fill:#90caf9,stroke:#1976d2
classDef level4 fill:#64b5f6,stroke:#1976d2
classDef level5 fill:#42a5f5,stroke:#1976d2
classDef issue fill:#fff3e0,stroke:#f57c00
class L1 level1,L2Plan,L2Fix,L2Multi level2,L3Std,L3TDD,L3Test level3,L4 level4,L5 level5,IssueW issue
`}
/>
### 复杂度指标
系统基于关键词自动评估复杂度:
| 权重 | 关键词 |
|--------|----------|
| +2 | refactor(重构), migrate(迁移), architect(架构), system(系统) |
| +2 | multiple(多个), across(跨), all(所有), entire(整个) |
| +1 | integrate(集成), api, database(数据库) |
| +1 | security(安全), performance(性能), scale(扩展) |
- **高复杂度** (&gt;=4): 自动选择层级 3-4
- **中等复杂度** (2-3): 自动选择层级 2
- **低复杂度** (&lt;2): 自动选择层级 1
## 最小执行单元
**定义**: 必须作为原子组一起执行以实现有意义的工作流里程碑的一组命令。
| 单元名称 | 命令 | 用途 |
|-----------|----------|---------|
| **快速实现** | lite-plan -> lite-execute | 轻量规划和执行 |
| **多 CLI 规划** | multi-cli-plan -> lite-execute | 多视角分析和执行 |
| **漏洞修复** | lite-fix -> lite-execute | 漏洞诊断和修复执行 |
| **验证式规划** | plan -> plan-verify -> execute | 带验证的规划和执行 |
| **TDD 规划** | tdd-plan -> execute | 测试驱动开发规划和执行 |
| **测试验证** | test-fix-gen -> test-cycle-execute | 生成测试任务并执行测试修复循环 |
| **代码审查** | review-session-cycle -> review-cycle-fix | 完整审查循环并应用修复 |
## 下一步
- [层级 1: 超轻量工作流](./level-1-ultra-lightweight.mdx) - 了解急速执行
- [层级 2: 快速工作流](./level-2-rapid.mdx) - 轻量规划和漏洞修复
- [层级 3: 标准工作流](./level-3-standard.mdx) - 完整规划和 TDD
- [层级 4: 头脑风暴工作流](./level-4-brainstorm.mdx) - 多角色探索
- [层级 5: 智能工作流](./level-5-intelligent.mdx) - 自动化编排
- [常见问题](./faq.mdx) - 常见问题和解答

View File

@@ -0,0 +1,250 @@
---
title: 层级 1: 超轻量工作流
description: 急速执行工作流 - 零开销直接执行
sidebar_position: 2
---
import Mermaid from '@theme/Mermaid';
# Level 1: 超轻量工作流
**复杂度**: 低 | **产物**: 无 | **状态**: 无状态 | **迭代**: 通过 AskUser 交互
最简单的工作流,用于立即处理简单任务 - 最小开销,直接执行。
## 概述
Level 1 工作流专为快速、直接的任务设计,不需要规划、文档或持久化状态。它们从输入直接执行到完成。
<Mermaid
chart={`
flowchart LR
Input([User Input]) --> Clarify[Clarification<br/>Optional]
Clarify --> Select{Auto-select<br/>CLI}
Select --> Analysis[Parallel Analysis<br/>Multi-tool exploration]
Analysis --> Results[Show Results]
Results --> Execute[Direct Execute]
Execute --> Done([Complete])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
class Input,Done startend,Clarify,Select,Analysis,Results,Execute action,Select decision
`}
/>
## 包含的工作流: lite-lite-lite
### 命令
```bash
/workflow:lite-lite-lite
# 或者 CCW 为简单任务自动选择
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([User Input]) --> B{Clarification<br/>Needed?}
B -->|Yes| C[AskUserQuestion<br/>Goal/Scope/Constraints]
B -->|No| D[Task Analysis]
C --> D
D --> E{CLI Selection}
E --> F[Gemini<br/>Analysis]
E --> G[Codex<br/>Implementation]
E --> H[Claude<br/>Reasoning]
F --> I[Aggregate Results]
G --> I
H --> I
I --> J{Direct<br/>Execute?}
J -->|Yes| K[Execute Directly]
J -->|Iterate| L[Refine via AskUser]
L --> K
K --> M([Complete])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
class A,M startend,B,E,J decision,C,D,F,G,H,I,K action
`}
/>
### 特性
| 属性 | 值 |
|----------|-------|
| **复杂度** | 低 |
| **产物** | 无(无中间文件) |
| **状态** | 无状态 |
| **CLI 选择** | 自动分析任务类型 |
| **迭代** | 通过 AskUser 交互 |
### 流程阶段
1. **输入分析**
- 解析用户输入的任务意图
- 检测复杂度级别
- 识别所需的 CLI 工具
2. **可选澄清**(如果 clarity_score < 2
- 目标: 创建/修复/优化/分析
- 范围: 单文件/模块/跨模块
- 约束: 向后兼容/跳过测试/紧急热修复
3. **CLI 自动选择**
- 任务类型 -> CLI 工具映射
- 跨多个工具并行分析
- 聚合结果展示
4. **直接执行**
- 立即执行更改
- 无中间产物
- 可通过 AskUser 进行迭代
### CLI 选择逻辑
```javascript
function selectCLI(task) {
const patterns = {
'gemini': /analyze|review|understand|explore/,
'codex': /implement|generate|create|write code/,
'claude': /debug|fix|optimize|refactor/,
'qwen': /consult|discuss|compare/
};
for (const [cli, pattern] of Object.entries(patterns)) {
if (pattern.test(task)) return cli;
}
return 'gemini'; // 默认
}
```
## 使用场景
### 适用场景
- 快速修复(简单拼写错误、小幅调整)
- 简单功能添加(单个函数、小型工具)
- 配置调整(环境变量、配置文件)
- 小范围重命名(变量名、函数名)
- 文档更新readme、注释
### 不适用场景
- 多模块更改(使用 Level 2+
- 需要持久化记录(使用 Level 3+
- 复杂重构(使用 Level 3-4
- 测试驱动开发(使用 Level 3 TDD
- 架构设计(使用 Level 4-5
## 示例
### 示例 1: 快速修复
```bash
/workflow:lite-lite-lite "Fix typo in function name: getUserData"
```
**流程**:
1. 检测: 简单拼写错误修复
2. 选择: Codex 用于重构
3. 执行: 跨文件直接重命名
4. 完成: 不生成产物
### 示例 2: 简单功能
```bash
/workflow:lite-lite-lite "Add logging to user login function"
```
**流程**:
1. 检测: 单模块功能
2. 选择: Claude 用于实现
3. 澄清: 日志级别?输出目标?
4. 执行: 添加日志语句
5. 完成: 工作代码
### 示例 3: 配置调整
```bash
/workflow:lite-lite-lite "Update API timeout to 30 seconds"
```
**流程**:
1. 检测: 配置更改
2. 选择: Gemini 用于分析
3. 分析: 查找所有超时配置
4. 执行: 更新值
5. 完成: 配置已更新
## 优缺点
### 优点
| 优势 | 描述 |
|---------|-------------|
| **速度** | 最快的工作流,零开销 |
| **简单性** | 无需规划或文档 |
| **直接性** | 输入 -> 执行 -> 完成 |
| **无产物** | 清洁的工作区,无文件混乱 |
| **低认知负担** | 简单、直接的执行 |
### 缺点
| 限制 | 描述 |
|------------|-------------|
| **无追踪** | 没有更改记录 |
| **无规划** | 无法处理复杂任务 |
| **无审查** | 没有内置代码审查 |
| **范围有限** | 仅限单模块 |
| **无回滚** | 更改立即生效 |
## 与其他层级的比较
| 方面 | Level 1 | Level 2 | Level 3 |
|--------|---------|---------|---------|
| **规划** | 无 | 内存中 | 持久化 |
| **产物** | 无 | 内存文件 | 会话文件 |
| **复杂度** | 低 | 低-中 | 中-高 |
| **可追踪性** | 无 | 部分 | 完整 |
| **审查** | 无 | 可选 | 内置 |
## 何时升级到更高级别
**需要 Level 2+ 的信号**:
- 任务涉及多个模块
- 需要跟踪进度
- 需求需要澄清
- 需要代码审查
- 需要测试生成
**升级路径**:
<Mermaid
chart={`
graph LR
L1["Level 1:<br/>lite-lite-lite"] --> L2["Level 2:<br/>lite-plan"]
L2 --> L3["Level 3:<br/>plan"]
L3 --> L4["Level 4:<br/>brainstorm"]
L4 --> L5["Level 5:<br/>ccw-coordinator"]
classDef node fill:#e3f2fd,stroke:#1976d2
class L1,L2,L3,L4,L5 node
`}
/>
## 相关工作流
- [层级 2: 快速工作流](./level-2-rapid.mdx) - 带规划的下一层级
- [层级 3: 标准工作流](./level-3-standard.mdx) - 完整会话管理
- [FAQ](./faq.mdx) - 常见问题

View File

@@ -0,0 +1,453 @@
---
title: 层级 2: 快速工作流
description: 轻量规划和漏洞诊断工作流 - 适用于单模块功能
sidebar_position: 3
---
import Mermaid from '@theme/Mermaid';
# 层级 2: 快速工作流
**复杂度**: 低-中等 | **产物**: 内存/轻量文件 | **状态**: 会话作用域
Level 2 工作流提供轻量级规划或单次分析,支持快速迭代。它们专为需求相对明确、不需要完整会话持久化的任务而设计。
## 概述
<Mermaid
chart={`
flowchart TD
Start([用户输入]) --> Select{选择工作流}
Select -->|需求<br/>明确| LP[lite-plan]
Select -->|漏洞修复| LF[lite-fix]
Select -->|需要<br/>多CLI| MCP[multi-cli-plan]
LP --> LE[lite-execute]
LF --> LE
MCP --> LE
LE --> Test{需要<br/>测试?}
Test -->|是| TFG[test-fix-gen]
Test -->|否| Done([完成])
TFG --> TCE[test-cycle-execute]
TCE --> Done
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef workflow fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef execute fill:#c5e1a5,stroke:#388e3c
class Start,Done startend,Select,Test decision,LP,LF,MCP workflow,LE execute,TFG,TCE execute
`}
/>
## 包含的工作流
| 工作流 | 用途 | 产物 | 执行方式 |
|----------|---------|-----------|-----------|
| `lite-plan` | 需求明确的开发 | memory://plan | -> `lite-execute` |
| `lite-fix` | 漏洞诊断与修复 | `.workflow/.lite-fix/` | -> `lite-execute` |
| `multi-cli-plan` | 多视角任务 | `.workflow/.multi-cli-plan/` | -> `lite-execute` |
### 共同特征
| 属性 | 值 |
|----------|-------|
| **复杂度** | 低-中等 |
| **状态** | 会话作用域 / 轻量持久化 |
| **执行** | 统一通过 `lite-execute` |
| **使用场景** | 需求相对明确 |
---
## 工作流 1: lite-plan -> lite-execute
**内存规划 + 直接执行**
### 命令
```bash
/workflow:lite-plan "Add user authentication API"
/workflow:lite-execute
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[阶段 1: 代码探索]
B --> C{需要<br/>代码探索?}
C -->|是| D[cli-explore-agent<br/>多角度分析]
C -->|否| E[跳过探索]
D --> F[阶段 2: 复杂度评估]
E --> F
F --> G{复杂度}
G -->|低| H[直接 Claude<br/>规划]
G -->|中| H
G -->|高| I[cli-lite-planning<br/>-agent]
H --> J[阶段 3: 规划]
I --> J
J --> K[阶段 4: 确认]
K --> L{确认?}
L -->|修改| M[调整计划]
M --> K
L -->|允许| N[阶段 5: 执行]
L -->|取消| O([中止])
N --> P[构建执行上下文]
P --> Q[/workflow:lite-execute]
Q --> R([完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef agent fill:#ffecb3,stroke:#ffa000
class A,R,O startend,B,D,E,J,M,P,Q action,C,G,L decision,F,H,I agent
`}
/>
### 流程阶段
**阶段 1: 代码探索** (可选)
```bash
# 如果指定了 -e 参数
/workflow:lite-plan -e "Add user authentication API"
```
- 通过 cli-explore-agent 进行多角度代码分析
- 识别模式、依赖关系、集成点
**阶段 2: 复杂度评估**
- 低: 无需代理,直接规划
- 中/高: 使用 cli-lite-planning-agent
**阶段 3: 规划**
- 加载计划 schema: `~/.claude/workflows/cli-templates/schemas/plan-json-schema.json`
- 按照生成计划 schema 生成 plan.json
**阶段 4: 确认与选择**
- 显示计划摘要(任务、复杂度、预估时间)
- 询问用户选择:
- 确认: 允许 / 修改 / 取消
- 执行: Agent / Codex / Auto
- 审核: Gemini / Agent / 跳过
**阶段 5: 执行**
- 构建执行上下文(计划 + 探索 + 澄清 + 选择)
- 通过 `/workflow:lite-execute --in-memory` 执行
### 产物
- **内存**: `memory://plan` (不持久化)
- **可选**: `.workflow/.lite-exploration/` (如果使用了代码探索)
### 使用场景
需求明确的单模块功能
**示例**:
```bash
/workflow:lite-plan "Add email validation to user registration form"
/workflow:lite-execute
```
---
## 工作流 2: lite-fix
**智能诊断 + 修复 (5 阶段)**
### 命令
```bash
/workflow:lite-fix "Login timeout after 30 seconds"
/workflow:lite-execute --in-memory --mode bugfix
# 紧急热修复模式
/workflow:lite-fix --hotfix "Production database connection failing"
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[阶段 1: 漏洞分析<br/>& 诊断]
B --> C[严重程度预评估<br/>低/中/高/严重]
C --> D[并行 cli-explore<br/>-agent 诊断<br/>1-4 角度]
D --> E[阶段 2: 澄清]
E --> F{需要<br/>更多信息?}
F -->|是| G[AskUserQuestion<br/>聚合澄清]
F -->|否| H[阶段 3: 修复规划]
G --> H
H --> I{严重程度}
I -->|低/中| J[直接 Claude<br/>规划]
I -->|高/严重| K[cli-lite-planning<br/>-agent]
J --> L[阶段 4: 确认]
K --> L
L --> M[用户确认<br/>执行方法]
M --> N[阶段 5: 执行]
N --> O[/workflow:lite-execute<br/>--in-memory --mode bugfix/]
O --> P([完成])
Q[热修复模式] --> R[跳过诊断<br/>最小规划]
R --> N
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef agent fill:#ffecb3,stroke:#ffa000
classDef hotfix fill:#ffccbc,stroke:#bf360c
class A,P startend,B,E,G,H,L,M,N,O action,F,I decision,C,D,J,K agent,Q,R hotfix
`}
/>
### 流程阶段
**阶段 1: 漏洞分析与诊断**
- 智能严重程度预评估(低/中/高/严重)
- 并行 cli-explore-agent 诊断1-4 角度)
**阶段 2: 澄清** (可选)
- 聚合澄清需求
- AskUserQuestion 获取缺失信息
**阶段 3: 修复规划**
- 低/中严重程度 -> 直接 Claude 规划
- 高/严重程度 -> cli-lite-planning-agent
**阶段 4: 确认与选择**
- 显示修复计划摘要
- 用户确认执行方法
**阶段 5: 执行**
- 通过 `/workflow:lite-execute --in-memory --mode bugfix` 执行
### 产物
**位置**: `.workflow/.lite-fix/{bug-slug}-{YYYY-MM-DD}/`
```
.workflow/.lite-fix/
└── login-timeout-fix-2025-02-03/
├── diagnosis-root-cause.json
├── diagnosis-impact.json
├── diagnosis-code-flow.json
├── diagnosis-similar.json
├── diagnoses-manifest.json
├── fix-plan.json
└── README.md
```
### 严重程度级别
| 严重程度 | 描述 | 规划方法 |
|----------|-------------|-----------------|
| **低** | 简单修复,根因明确 | 直接 Claude可选理由 |
| **中** | 中等复杂度,需调查 | 直接 Claude含理由 |
| **高** | 复杂,影响多个组件 | cli-lite-planning-agent完整 schema |
| **严重** | 生产事故,紧急 | cli-lite-planning-agent + 热修复模式 |
### 热修复模式
```bash
/workflow:lite-fix --hotfix "Production API returning 500 errors"
```
**特点**:
- 跳过大部分诊断阶段
- 最小规划(直接执行)
- 自动生成后续任务用于完整修复 + 事后分析
### 使用场景
- 漏洞诊断
- 生产环境紧急情况
- 根因分析
---
## 工作流 3: multi-cli-plan -> lite-execute
**多CLI 协作分析 + 共识收敛**
### 命令
```bash
/workflow:multi-cli-plan "Compare Redis vs Memcached for caching"
/workflow:lite-execute
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[阶段 1: 上下文收集]
B --> C[ACE 语义搜索<br/>构建上下文包]
C --> D[阶段 2: 多CLI 讨论<br/>迭代]
D --> E[cli-discuss-agent]
E --> F[Gemini + Codex + Claude]
F --> G{已收敛?}
G -->|否| H[交叉验证<br/>综合解决方案]
H --> D
G -->|是| I[阶段 3: 展示选项]
I --> J[展示解决方案<br/>及权衡]
J --> K[阶段 4: 用户决策]
K --> L[用户选择解决方案]
L --> M[阶段 5: 计划生成]
M --> N[cli-lite-planning<br/>-agent]
N --> O[-> lite-execute]
O --> P([完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef agent fill:#ffecb3,stroke:#ffa000
class A,P startend,B,C,E,H,J,L,M,O action,G,K decision,F,N agent
`}
/>
### 流程阶段
**阶段 1: 上下文收集**
- ACE 语义搜索
- 构建上下文包
**阶段 2: 多CLI 讨论** (迭代)
- cli-discuss-agent 执行 Gemini + Codex + Claude
- 交叉验证,综合解决方案
- 循环直至收敛或达到最大轮次
**阶段 3: 展示选项**
- 展示解决方案及权衡
**阶段 4: 用户决策**
- 用户选择解决方案
**阶段 5: 计划生成**
- cli-lite-planning-agent 生成计划
- -> lite-execute
### 产物
**位置**: `.workflow/.multi-cli-plan/{MCP-task-slug-date}/`
```
.workflow/.multi-cli-plan/
└── redis-vs-memcached-2025-02-03/
├── context-package.json
├── rounds/
│ ├── round-1/
│ │ ├── gemini-analysis.md
│ │ ├── codex-analysis.md
│ │ ├── claude-analysis.md
│ │ └── synthesis.json
│ ├── round-2/
│ └── ...
├── selected-solution.json
├── IMPL_PLAN.md
└── plan.json
```
### 与 lite-plan 对比
| 方面 | multi-cli-plan | lite-plan |
|--------|---------------|-----------|
| **上下文** | ACE 语义搜索 | 手动文件模式 |
| **分析** | 多CLI 交叉验证 | 单次规划 |
| **迭代** | 多轮至收敛 | 单轮 |
| **可信度** | 高(共识驱动) | 中(单视角) |
| **时间** | 较长(多轮) | 更快 |
### 使用场景
- 多视角分析
- 技术选型
- 方案对比
- 架构决策
---
## Level 2 对比表
| 方面 | lite-plan | lite-fix | multi-cli-plan |
|--------|-----------|----------|----------------|
| **用途** | 需求明确 | 漏洞诊断 | 多视角 |
| **规划** | 内存中 | 基于严重程度 | 共识驱动 |
| **产物** | memory://plan | .lite-fix/ | .multi-cli-plan/ |
| **代码探索** | 可选 (-e 参数) | 内置诊断 | ACE 搜索 |
| **多CLI** | 否 | 否 | 是 (Gemini/Codex/Claude) |
| **最适合** | 单模块功能 | 漏洞修复 | 技术决策 |
## 执行: lite-execute
所有 Level 2 工作流通过 `lite-execute` 执行:
```bash
/workflow:lite-execute --in-memory
```
### 执行流程
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[初始化追踪<br/>previousExecutionResults]
B --> C[任务分组<br/>& 批量创建]
C --> D[提取显式<br/>depends_on]
D --> E[分组: 独立<br/>任务 -> 并行批次]
E --> F[分组: 依赖<br/>任务 -> 顺序阶段]
F --> G[创建 TodoWrite<br/>批次列表]
G --> H[启动执行]
H --> I[阶段 1: 所有独立<br/>任务 - 单批次]
I --> J[阶段 2+: 依赖任务<br/>按依赖顺序]
J --> K[追踪进度<br/>TodoWrite 更新]
K --> L{需要<br/>代码审核?}
L -->|是| M[审核流程]
L -->|否| N([完成])
M --> N
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
class A,N startend,B,D,E,F,G,I,J,K,M action,C,L decision
`}
/>
### 特性
- **并行执行** 独立任务
- **顺序阶段** 依赖任务
- **进度追踪** 通过 TodoWrite
- **可选代码审核**
## 相关工作流
- [Level 1: 超轻量级](./level-1-ultra-lightweight.mdx) - 更简单的工作流
- [Level 3: 标准级](./level-3-standard.mdx) - 完整会话管理
- [Level 4: 头脑风暴](./level-4-brainstorm.mdx) - 多角色探索
- [常见问题](./faq.mdx) - 常见问题解答

View File

@@ -0,0 +1,507 @@
---
title: 层级 3: 标准工作流
description: 标准规划工作流 - 完整规划和 TDD 开发
sidebar_position: 4
---
import Mermaid from '@theme/Mermaid';
# 层级 3: 标准工作流
**复杂度**: 中-高 | **产物**: 持久化会话文件 | **状态**: 完全会话管理
层级 3 工作流提供完整规划并支持持久化会话管理。专为需要可追溯性、验证和结构化执行的多模块变更而设计。
## 概述
<Mermaid
chart={`
flowchart TD
Start([用户输入]) --> Select{选择工作流}
Select -->|标准<br/>开发| Plan[plan]
Select -->|测试驱动| TDD[tdd-plan]
Select -->|测试修复| TestFix[test-fix-gen]
Plan --> Verify[plan-verify<br/>可选]
TDD --> Verify
Verify --> Execute[execute]
TestFix --> TestCycle[test-cycle-execute]
Execute --> Review{需要审查?}
TestCycle --> Review
Review -->|是| RevCycle[review-session-cycle]
Review -->|否| TestQ{有测试?}
RevCycle --> RevFix[review-cycle-fix]
RevFix --> TestQ
TestQ -->|是| TFG[test-fix-gen]
TestQ -->|否| Complete([session:complete])
TFG --> TCE[test-cycle-execute]
TCE --> Complete
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef workflow fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef execute fill:#c5e1a5,stroke:#388e3c
class Start,Complete startend,Select,Review,TestQ decision,Plan,TDD,TestFix workflow,Verify,Execute,TestCycle,RevCycle,RevFix,TFG,TCE execute
`}
/>
## 包含的工作流
| 工作流 | 用途 | 阶段数 | 产物位置 |
|----------|---------|--------|-------------------|
| `plan` | 复杂功能开发 | 5 阶段 | `.workflow/active/{session}/` |
| `tdd-plan` | 测试驱动开发 | 6 阶段 | `.workflow/active/{session}/` |
| `test-fix-gen` | 测试修复生成 | 5 阶段 | `.workflow/active/WFS-test-{session}/` |
### 共同特性
| 属性 | 值 |
|----------|-------|
| **复杂度** | 中-高 |
| **产物** | 持久化文件 (`.workflow/active/{session}/`) |
| **状态** | 完全会话管理 |
| **验证** | 内置验证步骤 |
| **执行** | `/workflow:execute` |
| **适用场景** | 多模块、可追溯任务 |
---
## 工作流 1: plan -> verify -> execute
**5 阶段完整规划工作流**
### 命令
```bash
/workflow:plan "实现 OAuth2 认证系统"
/workflow:plan-verify # 验证计划(推荐)
/workflow:execute
/workflow:review # (可选) 代码审查
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[阶段 1: 会话发现]
B --> C[/workflow:session:start<br/>--auto/]
C --> D[返回: sessionId]
D --> E[阶段 2: 上下文收集]
E --> F[/workflow:tools:context-gather/]
F --> G[返回: context-package.json<br/>+ conflict_risk]
G --> H{conflict_risk<br/>>= medium?}
H -->|是| I[阶段 3: 冲突解决]
H -->|否| J[阶段 4: 任务生成]
I --> K[/workflow:tools:conflict<br/>-resolution/]
K --> J
J --> L[/workflow:tools:task-generate<br/>-agent/]
L --> M[返回: IMPL_PLAN.md<br/>+ IMPL-*.json<br/>+ TODO_LIST.md]
M --> N[返回摘要<br/>+ 下一步]
N --> O([规划完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef tool fill:#ffecb3,stroke:#ffa000
class A,O startend,H decision,B,E,G,J,M,N action,C,F,K,L tool
`}
/>
### 流程阶段
**阶段 1: 会话发现**
```bash
/workflow:session:start --auto "实现 OAuth2 认证系统"
```
- 创建或发现工作流会话
- 返回: `sessionId`
**阶段 2: 上下文收集**
```bash
/workflow:tools:context-gather
```
- 分析代码库结构
- 识别技术栈和模式
- 返回: `context-package.json` + `conflict_risk`
**阶段 3: 冲突解决**(条件触发)
```bash
# 仅当 conflict_risk >= medium 时
/workflow:tools:conflict-resolution
```
- 检测潜在冲突
- 解决依赖问题
- 确保清晰的执行路径
**阶段 4: 任务生成**
```bash
/workflow:tools:task-generate-agent
```
- 生成结构化任务
- 创建依赖图
- 返回: `IMPL_PLAN.md` + `IMPL-*.json` + `TODO_LIST.md`
### 产物
**位置**: `.workflow/active/{WFS-session}/`
```
.workflow/active/WFS-oauth2-auth-2025-02-03/
├── workflow-session.json # 会话元数据
├── IMPL_PLAN.md # 实现计划
├── TODO_LIST.md # 进度跟踪
├── .task/
│ ├── IMPL-001.json # 主任务
│ ├── IMPL-002.json
│ └── ...
└── .process/
├── context-package.json # 项目上下文
├── conflict-resolution.json # 冲突分析
└── planning-notes.md
```
### 适用场景
- 多模块变更
- 代码重构
- 需要依赖分析
---
## 工作流 2: tdd-plan -> execute -> tdd-verify
**6 阶段测试驱动开发工作流**
### 命令
```bash
/workflow:tdd-plan "使用 TDD 实现用户注册"
/workflow:execute # 遵循 Red-Green-Refactor
/workflow:tdd-verify # 验证 TDD 合规性
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[阶段 1: 会话发现]
B --> C[/workflow:session:start<br/>--type tdd --auto/]
C --> D[解析: sessionId]
D --> E[阶段 2: 上下文收集]
E --> F[/workflow:tools:context-gather/]
F --> G[返回: context-package.json]
G --> H[阶段 3: 测试覆盖率分析]
H --> I[/workflow:tools:test-context<br/>-gather/]
I --> J[检测测试框架<br/>分析覆盖率]
J --> K{conflict_risk<br/>>= medium?}
K -->|是| L[阶段 4: 冲突解决]
K -->|否| M[阶段 5: TDD 任务生成]
L --> N[/workflow:tools:conflict<br/>-resolution/]
N --> M
M --> O[/workflow:tools:task-generate<br/>-tdd/]
O --> P[生成包含 Red-Green-<br/>Refactor 循环的 IMPL 任务]
P --> Q[阶段 6: TDD 结构验证]
Q --> R[验证 TDD 合规性]
R --> S([TDD 规划完成])
T[执行] --> U[/workflow:execute/]
U --> V[遵循每个任务中的<br/>Red-Green-Refactor 循环]
V --> W[验证]
W --> X[/workflow:tdd-verify/]
X --> Y([完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef tool fill:#ffecb3,stroke:#ffa000
class A,S,Y startend,K decision,B,E,G,H,J,M,P,Q,R,T,U,V,X action,C,F,I,N,O,W tool
`}
/>
### 流程阶段
**阶段 1: 会话发现**
```bash
/workflow:session:start --type tdd --auto "TDD: 用户注册"
```
**TDD 结构化格式**:
```
TDD: [功能名称]
GOAL: [目标]
SCOPE: [包含/排除的范围]
CONTEXT: [背景]
TEST_FOCUS: [测试场景]
```
**阶段 2: 上下文收集**
```bash
/workflow:tools:context-gather
```
**阶段 3: 测试覆盖率分析**
```bash
/workflow:tools:test-context-gather
```
- 检测测试框架
- 分析现有测试覆盖率
- 识别覆盖率缺口
**阶段 4: 冲突解决**(条件触发)
```bash
# 仅当 conflict_risk >= medium 时
/workflow:tools:conflict-resolution
```
**阶段 5: TDD 任务生成**
```bash
/workflow:tools:task-generate-tdd
```
- 生成包含内置 Red-Green-Refactor 循环的 IMPL 任务
- `meta.tdd_workflow: true`
- `flow_control.implementation_approach` 包含 3 个步骤red/green/refactor
**阶段 6: TDD 结构验证**
- 验证 TDD 结构合规性
### TDD 任务结构
```json
{
"id": "IMPL-001",
"title": "实现用户注册",
"meta": {
"tdd_workflow": true
},
"flow_control": {
"implementation_approach": [
{
"step": 1,
"title": "Red: 编写失败的测试",
"description": "编写一个失败的测试"
},
{
"step": 2,
"title": "Green: 使测试通过",
"description": "实现最小代码使测试通过",
"test_fix_cycle": {
"max_iterations": 3,
"pass_threshold": 0.95
}
},
{
"step": 3,
"title": "Refactor: 改进代码",
"description": "在保持测试通过的同时重构"
}
]
}
}
```
### 铁律
```
没有失败的测试,就没有生产代码
```
**执行方法**:
- 阶段 5: `implementation_approach` 包含测试优先步骤Red -> Green -> Refactor
- Green 阶段: 包含 test-fix-cycle 配置(最多 3 次迭代)
- 自动回滚: 达到最大迭代次数且测试未通过时触发
**顺序为何重要**:
- 后写的测试会立即通过 -> 证明不了什么
- 测试优先强制在实现前发现边界情况
- 后写测试验证的是已构建的内容,而非所需内容
### 适用场景
- 测试驱动开发
- 高质量功能需求
- 关键系统组件
---
## 工作流 3: test-fix-gen -> test-cycle-execute
**5 阶段测试修复生成工作流**
### 命令
```bash
# 会话模式
/workflow:test-fix-gen WFS-user-auth-v2
/workflow:test-cycle-execute
# 提示词模式
/workflow:test-fix-gen "测试认证 API"
/workflow:test-cycle-execute
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([开始]) --> B{输入模式?}
B -->|会话<br/>模式| C[阶段 1: 使用源<br/>会话]
B -->|提示词<br/>模式| D[阶段 1: 创建<br/>测试会话]
C --> E[/workflow:session:start<br/>--type test --resume/]
D --> F[/workflow:session:start<br/>--type test --new/]
E --> G[阶段 2: 收集测试上下文]
F --> H[阶段 2: 收集测试上下文]
G --> I[/workflow:tools:test-context<br/>-gather/]
H --> I
I --> J[阶段 3: 测试生成分析]
J --> K[/workflow:tools:test-concept<br/>-enhanced/]
K --> L[多层测试需求<br/>L0: 静态, L1: 单元<br/>L2: 集成, L3: E2E]
L --> M[阶段 4: 生成测试任务]
M --> N[/workflow:tools:test-task-generate/]
N --> O[IMPL-001: 生成<br/>+ IMPL-001.5: 质量门<br/>+ IMPL-002: 执行修复]
O --> P[阶段 5: 返回摘要]
P --> Q[-> test-cycle-execute]
Q --> R([测试修复完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef tool fill:#ffecb3,stroke:#ffa000
class A,R startend,B decision,C,D,E,F,G,H,J,M,P,Q action,I,K,N tool
`}
/>
### 流程阶段
**阶段 1: 创建/使用测试会话**
**会话模式**(使用现有会话):
```bash
/workflow:session:start --type test --resume WFS-user-auth-v2
```
**提示词模式**(创建新会话):
```bash
/workflow:session:start --type test --new
```
**阶段 2: 收集测试上下文**
```bash
/workflow:tools:test-context-gather
```
**阶段 3: 测试生成分析**
```bash
/workflow:tools:test-concept-enhanced
```
- 多层测试需求:
- **L0: 静态** - 类型检查、代码检查
- **L1: 单元** - 函数级测试
- **L2: 集成** - 组件交互测试
- **L3: E2E** - 完整系统测试
**阶段 4: 生成测试任务**
```bash
/workflow:tools:test-task-generate
```
- `IMPL-001.json`: 测试理解与生成
- `IMPL-001.5-review.json`: 质量门
- `IMPL-002.json`: 测试执行与修复循环
**阶段 5: 返回摘要**
- -> `/workflow:test-cycle-execute`
### 双模式支持
| 模式 | 输入模式 | 上下文来源 |
|------|---------------|----------------|
| **会话模式** | `WFS-xxx` | 源会话摘要 |
| **提示词模式** | 文本/文件路径 | 直接代码库分析 |
### 产物
**位置**: `.workflow/active/WFS-test-{session}/`
```
.workflow/active/WFS-test-user-auth-2025-02-03/
├── workflow-session.json
├── .task/
│ ├── IMPL-001.json # 测试理解与生成
│ ├── IMPL-001.5-review.json # 质量门
│ └── IMPL-002.json # 测试执行与修复循环
└── .process/
├── TEST_ANALYSIS_RESULTS.md
└── test-context-package.json
```
### 适用场景
- 测试失败修复
- 覆盖率提升
- 测试套件生成
---
## 层级 3 对比表
| 方面 | plan | tdd-plan | test-fix-gen |
|--------|------|----------|--------------|
| **用途** | 复杂功能 | 测试驱动开发 | 测试修复 |
| **阶段** | 5 | 6 | 5 |
| **TDD** | 否 | 是 (Red-Green-Refactor) | 可选 |
| **产物** | `.workflow/active/` | `.workflow/active/` | `.workflow/active/WFS-test-*/` |
| **验证** | plan-verify | tdd-verify | 内置质量门 |
| **最适合** | 多模块变更 | 高质量功能 | 测试改进 |
## 执行: execute
所有层级 3 工作流通过 `execute` 执行:
```bash
/workflow:execute --session WFS-{session-id}
```
### 关键特性
- **依赖分析** - 自动任务依赖解析
- **并行执行** - 独立任务并行运行
- **进度跟踪** - 基于会话的 TODO 更新
- **摘要** - 为依赖任务生成任务完成摘要
## 相关工作流
- [层级 2: 快速](./level-2-rapid.mdx) - 更简单的工作流
- [层级 4: 头脑风暴](./level-4-brainstorm.mdx) - 多角色探索
- [层级 5: 智能](./level-5-intelligent.mdx) - 自动化编排
- [常见问题](./faq.mdx) - 常见问题解答

View File

@@ -0,0 +1,336 @@
---
title: 层级 4: 头脑风暴工作流
description: 多角色头脑风暴工作流 - 协作探索和创意生成
sidebar_position: 5
---
import Mermaid from '@theme/Mermaid';
# 层级 4: 头脑风暴工作流
**复杂度**: 高 | **产物**: 多角色分析文档 | **角色数**: 3-9 | **执行**: 阶段 1/3 串行,阶段 2 并行
层级 4 工作流提供完整的多角色头脑风暴,包含完整的规划和执行能力。专为探索性需求、不确定的实现方案以及多维度的权衡分析而设计。
## 概述
<Mermaid
chart={`
flowchart TD
Start([用户输入]) --> BS[brainstorm:auto-parallel]
BS --> P1[阶段 1: 交互式<br/>框架生成]
P1 --> P2[阶段 2: 并行<br/>角色分析]
P2 --> P3[阶段 3: 综合<br/>整合]
P3 --> Plan{需要详细<br/>规划?}
Plan -->|是| Verify[plan-verify]
Plan -->|否| Execute[execute]
Verify --> Execute
Execute --> Review{需要评审?}
Review -->|是| Rev[review-session-cycle]
Review -->|否| Test{需要测试?}
Rev --> RevFix[review-cycle-fix]
RevFix --> Test
Test -->|是| TFG[test-fix-gen]
Test -->|否| Complete([session:complete])
TFG --> TCE[test-cycle-execute]
TCE --> Complete
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef workflow fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef execute fill:#c5e1a5,stroke:#388e3c
class Start,Complete startend,Plan,Review,Test decision,BS,Verify,Rev,RevFix,TFG,TCE workflow,P1,P2,P3,Execute execute
`}
/>
## 包含的工作流: brainstorm:auto-parallel
**多角色头脑风暴 + 完整规划 + 执行**
### 命令
```bash
/workflow:brainstorm:auto-parallel "实时通知系统架构设计" [--count N] [--style-skill package]
/workflow:plan --session {sessionId}
/workflow:plan-verify
/workflow:execute
```
### 流程图
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[阶段 1: 交互式<br/>框架生成]
B --> C[/workflow:brainstorm:artifacts/]
C --> D[主题分析<br/>生成问题]
D --> E[角色选择<br/>用户确认]
E --> F[角色问题收集]
F --> G[冲突检测<br/>与解决]
G --> H[生成 guidance-<br/>specification.md]
H --> I[阶段 2: 并行角色分析]
I --> J1[N 个 Task<br/>conceptual-planning-<br/>agent]
J1 --> K1{角色 1}
J1 --> K2{角色 2}
J1 --> K3{角色 3}
J1 --> K4{角色 N}
K1 --> L1[独立分析]
K2 --> L2[独立分析]
K3 --> L3[独立分析]
K4 --> L4[独立分析]
L1 --> M[并行生成<br/>{role}/analysis.md]
L2 --> M
L3 --> M
L4 --> M
M --> N[阶段 3: 综合整合]
N --> O[/workflow:brainstorm:<br/>synthesis/]
O --> P[整合所有角色<br/>分析]
P --> Q[综合为<br/>synthesis-specification.md]
Q --> R([头脑风暴完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef action fill:#e3f2fd,stroke:#1976d2
classDef phase fill:#fff9c4,stroke:#f57c00
classDef parallel fill:#ffecb3,stroke:#ffa000
class A,R startend,B,C,H,N,O,P,Q action,D,E,F,G,J1,K1,K2,K3,K4,L1,L2,L3,L4,M phase
`}
/>
### 特性
| 属性 | 值 |
|----------|-------|
| **复杂度** | 高 |
| **产物** | 多角色分析文档 + `IMPL_PLAN.md` |
| **角色数量** | 3-9 (默认 3) |
| **执行模式** | 阶段 1/3 串行,阶段 2 并行 |
### 流程阶段
#### 阶段 1: 交互式框架生成
```bash
/workflow:brainstorm:artifacts "实时通知系统架构设计"
```
**步骤**:
1. **主题分析** - 分析主题,生成关键问题
2. **角色选择** - 用户确认角色选择
3. **角色问题分配** - 为角色分配问题
4. **冲突检测** - 检测并解决角色冲突
5. **生成框架** - 创建 `guidance-specification.md`
#### 阶段 2: 并行角色分析
```bash
# 并行执行 N 个 conceptual-planning-agent 任务
Task(subagent_type: "conceptual-planning-agent", prompt: "Role: {role}, Topic: {topic}, Questions: {questions}")
```
**每个角色**:
- 接收特定角色的指导
- 独立分析主题
- 生成 `{role}/analysis.md`
- 可选: 子文档 (最多 5 个)
#### 阶段 3: 综合整合
```bash
/workflow:brainstorm:synthesis --session {sessionId}
```
**步骤**:
1. **收集** 所有角色分析
2. **整合** 视角到综合文档
3. **生成** `synthesis-specification.md`
4. **识别** 关键决策和权衡点
### 可用角色
| 角色 | 描述 |
|------|-------------|
| `system-architect` | 系统架构师 - 整体系统设计 |
| `ui-designer` | UI 设计师 - 用户界面设计 |
| `ux-expert` | UX 专家 - 用户体验优化 |
| `product-manager` | 产品经理 - 产品需求 |
| `product-owner` | 产品负责人 - 业务价值 |
| `data-architect` | 数据架构师 - 数据结构设计 |
| `scrum-master` | Scrum 主管 - 流程和团队 |
| `subject-matter-expert` | 领域专家 - 专业领域知识 |
| `test-strategist` | 测试策略师 - 测试策略 |
### 产物结构
```
.workflow/active/WFS-realtime-notifications/
├── workflow-session.json
└── .brainstorming/
├── guidance-specification.md # 框架 (阶段 1)
├── system-architect/
│ ├── analysis.md # 主文档
│ └── analysis-scale-{}.md # 子文档 (可选,最多 5 个)
├── ux-expert/
│ ├── analysis.md
│ └── analysis-accessibility.md
├── data-architect/
│ ├── analysis.md
│ └── analysis-storage.md
└── synthesis-specification.md # 整合 (阶段 3)
```
### 使用场景
#### 何时使用
- 新功能设计
- 系统架构重构
- 探索性需求
- 不确定的实现方案
- 需要多维度权衡分析
#### 何时不使用
- 需求明确 (使用层级 2-3)
- 时间敏感任务 (使用层级 2)
- 单一视角足够 (使用层级 2-3)
### 示例
#### 示例 1: 架构设计
```bash
/workflow:brainstorm:auto-parallel "电商平台微服务架构" --count 5
```
**角色**: system-architect, data-architect, ux-expert, product-manager, test-strategist
**输出**:
- 多个架构视角
- 数据流考虑
- 用户体验影响
- 业务需求对齐
- 测试策略建议
#### 示例 2: 功能探索
```bash
/workflow:brainstorm:auto-parallel "AI 驱动推荐系统" --count 3
```
**角色**: system-architect, product-manager, subject-matter-expert
**输出**:
- 技术可行性分析
- 业务价值评估
- 领域特定考量
## 文档化工作流 (With-File)
**文档化工作流** 提供带有多 CLI 协作的文档化探索。它们是自包含的,生成全面的会话产物。
| 工作流 | 用途 | 层级 | 主要特性 |
|----------|---------|-------|--------------|
| **brainstorm-with-file** | 多视角创意生成 | 4 | Gemini/Codex/Claude 视角,发散-收敛循环 |
| **debug-with-file** | 假设驱动调试 | 3 | Gemini 验证理解演进NDJSON 日志 |
| **analyze-with-file** | 协作分析 | 3 | 多轮问答CLI 探索,文档化讨论 |
### brainstorm-with-file
**多视角创意生成与文档化探索**
```bash
/workflow:brainstorm-with-file "通知系统重新设计"
```
**输出目录**: `.workflow/.brainstorm/`
**特性**:
- 发散-收敛循环
- 多 CLI 视角 (Gemini, Codex, Claude)
- 内置完成后选项 (创建规划、问题、深度分析)
### debug-with-file
**假设驱动调试与文档化调查**
```bash
/workflow:debug-with-file "系统在负载下随机崩溃"
```
**输出目录**: `.workflow/.debug/`
**特性**:
- 假设驱动迭代
- Gemini 假设验证
- 理解演进跟踪
- NDJSON 日志用于可复现性
### analyze-with-file
**协作分析与文档化讨论**
```bash
/workflow:analyze-with-file "理解认证架构设计决策"
```
**输出目录**: `.workflow/.analysis/`
**特性**:
- 多轮问答
- CLI 探索集成
- 文档化讨论线程
## 检测关键词
| 工作流 | 关键词 |
|----------|----------|
| **brainstorm** | 头脑风暴, 创意, 发散思维, multi-perspective, compare perspectives, 探索可能 |
| **debug-file** | 深度调试, 假设验证, systematic debug, hypothesis debug, 调试记录 |
| **analyze-file** | 协作分析, 深度理解, collaborative analysis, explore concept, 理解架构 |
## 对比: 文档化 vs 标准工作流
| 方面 | 文档化工作流 | 标准工作流 |
|--------|---------------------|-------------------|
| **文档** | 演进式文档 | 会话产物 |
| **多 CLI** | 内置 (Gemini/Codex/Claude) | 可选 |
| **迭代** | 自包含循环 | 手动继续 |
| **完成后选项** | 内置选项 | 手动下一步 |
| **最适合** | 文档化探索 | 结构化执行 |
## 层级 4 总结
| 方面 | 值 |
|--------|-------|
| **复杂度** | 高 |
| **产物** | 多角色分析 + 会话 |
| **规划** | 多视角收敛 |
| **执行** | 标准层级 3 执行 |
| **最适合** | 复杂探索性任务 |
## 相关工作流
- [层级 3: 标准](./level-3-standard.mdx) - 标准规划工作流
- [层级 5: 智能](./level-5-intelligent.mdx) - 自动编排
- [FAQ](./faq.mdx) - 常见问题
## 命令参考
参见 [命令文档](../commands/general/ccw.mdx) 了解:
- `/workflow:brainstorm:auto-parallel` - 多角色头脑风暴
- `/workflow:brainstorm-with-file` - 文档化创意生成
- `/workflow:debug-with-file` - 假设驱动调试
- `/workflow:analyze-with-file` - 协作分析

View File

@@ -0,0 +1,442 @@
---
title: 层级 5: 智能工作流
description: 智能编排工作流 - 自动分析和推荐
sidebar_position: 6
---
import Mermaid from '@theme/Mermaid';
# 层级 5: 智能工作流
**复杂度**: 所有层级 | **产物**: 完整状态持久化 | **自动化**: 完全自动化
层级 5 工作流提供最智能的自动化功能 - 带有顺序执行和状态持久化的自动命令链编排。它们能够自动分析需求、推荐最优命令链,并端到端执行。
## 概述
<Mermaid
chart={`
flowchart TD
Start([用户输入]) --> Analyze[阶段 1: 分析<br/>需求]
Analyze --> Recommend[阶段 2: 发现命令<br/>& 推荐命令链]
Recommend --> Confirm[用户确认<br/>可选]
Confirm --> Execute[阶段 3: 顺序执行<br/>命令链]
Execute --> State[状态持久化<br/>state.json]
State --> Check{完成?}
Check -->|否| Execute
Check -->|是| Complete([完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef phase fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef state fill:#ffecb3,stroke:#ffa000
class Start,Complete startend,Confirm,Check decision,Analyze,Recommend,Execute phase,State state
`}
/>
## 包含的工作流: ccw-coordinator
**自动分析并推荐命令链,支持顺序执行**
### 命令
```bash
/ccw-coordinator "使用 OAuth2 实现用户认证"
# 或者简单输入
/ccw "添加用户认证"
```
### 核心概念: 最小执行单元
**定义**: 一组必须作为原子组一起执行的命令,以实现有意义的工作流里程碑。
**为什么重要**:
- **防止不完整状态**: 避免在生成任务后停止而不执行
- **用户体验**: 用户获得完整结果,而非需要手动跟进的中间产物
- **工作流完整性**: 保持多步骤操作的逻辑连贯性
### 最小执行单元
#### 规划 + 执行单元
| 单元名称 | 命令 | 目的 | 输出 |
|-----------|----------|---------|--------|
| **快速实现** | lite-plan -> lite-execute | 轻量级规划和立即执行 | 工作代码 |
| **多 CLI 规划** | multi-cli-plan -> lite-execute | 多视角分析和执行 | 工作代码 |
| **Bug 修复** | lite-fix -> lite-execute | 快速 bug 诊断和修复执行 | 修复后的代码 |
| **完整规划 + 执行** | plan -> execute | 详细规划和执行 | 工作代码 |
| **验证规划 + 执行** | plan -> plan-verify -> execute | 带验证的规划和执行 | 工作代码 |
| **重新规划 + 执行** | replan -> execute | 更新计划并执行变更 | 工作代码 |
| **TDD 规划 + 执行** | tdd-plan -> execute | 测试驱动开发规划和执行 | 工作代码 |
| **测试生成 + 执行** | test-gen -> execute | 生成测试套件并执行 | 生成的测试 |
#### 测试单元
| 单元名称 | 命令 | 目的 | 输出 |
|-----------|----------|---------|--------|
| **测试验证** | test-fix-gen -> test-cycle-execute | 生成测试任务并执行测试-修复循环 | 测试通过 |
#### 审查单元
| 单元名称 | 命令 | 目的 | 输出 |
|-----------|----------|---------|--------|
| **代码审查 (会话)** | review-session-cycle -> review-fix | 完整审查循环并应用修复 | 修复后的代码 |
| **代码审查 (模块)** | review-module-cycle -> review-fix | 模块审查循环并应用修复 | 修复后的代码 |
### 三阶段工作流
<Mermaid
chart={`
flowchart TD
A([开始]) --> B[阶段 1: 分析需求]
B --> C[解析任务描述]
C --> D[提取: 目标、范围、约束、<br/>复杂度、任务类型]
D --> E[阶段 2: 发现命令<br/>& 推荐命令链]
E --> F[动态命令链<br/>组装]
F --> G[基于端口匹配]
G --> H{用户确认}
H -->|确认| I[阶段 3: 顺序执行<br/>命令链]
H -->|调整| J[修改命令链]
H -->|取消| K([中止])
J --> H
I --> L[初始化状态]
L --> M[遍历每个命令]
M --> N[组装提示词]
N --> O[在后台启动 CLI]
O --> P[保存检查点]
P --> Q{完成?}
Q -->|否| M
Q -->|是| R([完成])
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef phase fill:#e3f2fd,stroke:#1976d2
classDef decision fill:#fff9c4,stroke:#f57c00
classDef execute fill:#c5e1a5,stroke:#388e3c
class A,K,R startend,H,Q decision,B,E,I phase,C,D,F,G,J,L,M,N,O,P execute
`}
/>
#### 阶段 1: 分析需求
解析任务描述以提取: 目标、范围、约束、复杂度和任务类型。
```javascript
function analyzeRequirements(taskDescription) {
return {
goal: extractMainGoal(taskDescription), // 例如: "实现用户注册"
scope: extractScope(taskDescription), // 例如: ["auth", "user_management"]
constraints: extractConstraints(taskDescription), // 例如: ["无破坏性变更"]
complexity: determineComplexity(taskDescription), // 'simple' | 'medium' | 'complex'
task_type: detectTaskType(taskDescription) // 见下方的任务类型模式
};
}
// 任务类型检测模式
function detectTaskType(text) {
// 优先顺序 (第一个匹配胜出)
if (/fix|bug|error|crash|fail|debug|diagnose/.test(text)) return 'bugfix';
if (/tdd|test-driven|test first/.test(text)) return 'tdd';
if (/test fail|fix test|failing test/.test(text)) return 'test-fix';
if (/generate test|add test/.test(text)) return 'test-gen';
if (/review/.test(text)) return 'review';
if (/explore|brainstorm/.test(text)) return 'brainstorm';
if (/multi-perspective|comparison/.test(text)) return 'multi-cli';
return 'feature'; // 默认
}
// 复杂度评估
function determineComplexity(text) {
let score = 0;
if (/refactor|migrate|architect|system/.test(text)) score += 2;
if (/multiple|across|all|entire/.test(text)) score += 2;
if (/integrate|api|database/.test(text)) score += 1;
if (/security|performance|scale/.test(text)) score += 1;
return score >= 4 ? 'complex' : score >= 2 ? 'medium' : 'simple';
}
```
#### 阶段 2: 发现命令并推荐命令链
使用基于端口匹配的动态命令链组装。
**向用户显示**:
```
推荐命令链:
管道 (可视化):
需求 -> lite-plan -> 计划 -> lite-execute -> 代码 -> test-cycle-execute -> 测试通过
命令:
1. /workflow:lite-plan
2. /workflow:lite-execute
3. /workflow:test-cycle-execute
继续? [确认 / 显示详情 / 调整 / 取消]
```
#### 阶段 3: 顺序执行命令链
```javascript
async function executeCommandChain(chain, analysis) {
const sessionId = `ccw-coord-${Date.now()}`;
const stateDir = `.workflow/.ccw-coordinator/${sessionId}`;
// 初始化状态
const state = {
session_id: sessionId,
status: 'running',
created_at: new Date().toISOString(),
analysis: analysis,
command_chain: chain.map((cmd, idx) => ({ ...cmd, index: idx, status: 'pending' })),
execution_results: [],
prompts_used: []
};
// 保存初始状态
Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
for (let i = 0; i < chain.length; i++) {
const cmd = chain[i];
// 组装提示词
let prompt = formatCommand(cmd, state.execution_results, analysis);
prompt += `\n\nTask: ${analysis.goal}`;
if (state.execution_results.length > 0) {
prompt += '\nPrevious results:\n';
state.execution_results.forEach(r => {
if (r.session_id) {
prompt += `- ${r.command}: ${r.session_id}\n`;
}
});
}
// 在后台启动 CLI
const taskId = Bash(
`ccw cli -p "${escapePrompt(prompt)}" --tool claude --mode write`,
{ run_in_background: true }
).task_id;
// 保存检查点
state.execution_results.push({
index: i,
command: cmd.command,
status: 'in-progress',
task_id: taskId,
session_id: null,
artifacts: [],
timestamp: new Date().toISOString()
});
// 在此停止 - 等待 hook 回调
Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
break;
}
state.status = 'waiting';
Write(`${stateDir}/state.json`, JSON.stringify(state, null, 2));
return state;
}
```
### 状态文件结构
**位置**: `.workflow/.ccw-coordinator/{session_id}/state.json`
```json
{
"session_id": "ccw-coord-20250203-143025",
"status": "running|waiting|completed|failed",
"created_at": "2025-02-03T14:30:25Z",
"updated_at": "2025-02-03T14:35:45Z",
"analysis": {
"goal": "实现用户注册",
"scope": ["authentication", "user_management"],
"constraints": ["无破坏性变更"],
"complexity": "medium",
"task_type": "feature"
},
"command_chain": [
{
"index": 0,
"command": "/workflow:plan",
"name": "plan",
"status": "completed"
},
{
"index": 1,
"command": "/workflow:execute",
"name": "execute",
"status": "running"
}
],
"execution_results": [
{
"index": 0,
"command": "/workflow:plan",
"status": "completed",
"task_id": "task-001",
"session_id": "WFS-plan-20250203",
"artifacts": ["IMPL_PLAN.md"],
"timestamp": "2025-02-03T14:30:25Z",
"completed_at": "2025-02-03T14:30:45Z"
}
]
}
```
### 完整生命周期决策流程图
<Mermaid
chart={`
flowchart TD
Start([开始新任务]) --> Q0{是 bug 修复吗?}
Q0 -->|是| BugFix["Bug 修复流程"]
Q0 -->|否| Q1{知道要做什么吗?}
BugFix --> BugSeverity{理解根本原因吗?}
BugSeverity -->|清楚| LiteFix["/workflow:lite-fix<br/>标准修复"]
BugSeverity -->|生产事故| HotFix["/workflow:lite-fix --hotfix<br/>紧急热修复"]
BugSeverity -->|不清楚| BugDiag["/workflow:lite-fix<br/>自动诊断根本原因"]
BugDiag --> LiteFix
LiteFix --> BugComplete["Bug 已修复"]
HotFix --> FollowUp["自动生成后续任务<br/>完整修复 + 复盘"]
FollowUp --> BugComplete
BugComplete --> End(["任务完成"])
Q1 -->|否| Ideation["探索阶段<br/>明确需求"]
Q1 -->|是| Q2{知道如何做吗?}
Ideation --> BrainIdea["/workflow:brainstorm:auto-parallel<br/>探索产品方向"]
BrainIdea --> Q2
Q2 -->|否| Design["设计探索<br/>探索架构"]
Q2 -->|是| Q3{需要规划吗?}
Design --> BrainDesign["/workflow:brainstorm:auto-parallel<br/>探索技术方案"]
BrainDesign --> Q3
Q3 -->|快速简单| LitePlan["轻量级规划<br/>/workflow:lite-plan"]
Q3 -->|复杂完整| FullPlan["标准规划<br/>/workflow:plan"]
LitePlan --> Q4{需要代码探索?}
Q4 -->|是| LitePlanE["/workflow:lite-plan -e"]
Q4 -->|否| LitePlanNormal["/workflow:lite-plan"]
LitePlanE --> LiteConfirm["三维确认:<br/>1. 任务确认<br/>2. 执行方式<br/>3. 代码审查"]
LitePlanNormal --> LiteConfirm
LiteConfirm --> Q5{选择执行方式}
Q5 -->|Agent| LiteAgent["/workflow:lite-execute<br/>使用 @code-developer"]
Q5 -->|CLI 工具| LiteCLI["CLI 执行<br/>Gemini/Qwen/Codex"]
Q5 -->|仅规划| UserImpl["用户手动实现"]
FullPlan --> PlanVerify{验证计划质量?}
PlanVerify -->|是| Verify["/workflow:plan-verify"]
PlanVerify -->|否| Execute
Verify --> Q6{验证通过?}
Q6 -->|否| FixPlan["修复计划问题"]
Q6 -->|是| Execute
FixPlan --> Execute
Execute["执行阶段<br/>/workflow:execute"]
LiteAgent --> TestDecision
LiteCLI --> TestDecision
UserImpl --> TestDecision
Execute --> TestDecision
TestDecision{需要测试?}
TestDecision -->|TDD 模式| TDD["/workflow:tdd-plan<br/>测试驱动开发"]
TestDecision -->|后置测试| TestGen["/workflow:test-gen<br/>生成测试"]
TestDecision -->|已有测试| TestCycle["/workflow:test-cycle-execute<br/>测试-修复循环"]
TestDecision -->|不需要| Review
TDD --> TDDExecute["/workflow:execute<br/>红-绿-重构"]
TDDExecute --> TDDVerify["/workflow:tdd-verify<br/>验证 TDD 合规性"]
TDDVerify --> Review
TestGen --> TestExecute["/workflow:execute<br/>执行测试任务"]
TestExecute --> TestResult{测试通过?}
TestResult -->|否| TestCycle
TestResult -->|是| Review
TestCycle --> TestPass{通过率 >= 95%?}
TestPass -->|否, 继续修复| TestCycle
TestPass -->|是| Review
Review["审查阶段"]
Review --> Q7{需要专项审查?}
Q7 -->|安全| SecurityReview["/workflow:review<br/>--type security"]
Q7 -->|架构| ArchReview["/workflow:review<br/>--type architecture"]
Q7 -->|质量| QualityReview["/workflow:review<br/>--type quality"]
Q7 -->|通用| GeneralReview["/workflow:review<br/>通用审查"]
Q7 -->|不需要| Complete
SecurityReview --> Complete
ArchReview --> Complete
QualityReview --> Complete
GeneralReview --> Complete
Complete["完成阶段<br/>/workflow:session:complete"]
Complete --> End
classDef startend fill:#c8e6c9,stroke:#388e3c
classDef bugfix fill:#ffccbc,stroke:#bf360c
classDef ideation fill:#fff9c4,stroke:#ffa000
classDef planning fill:#e3f2fd,stroke:#1976d2
classDef execute fill:#c5e1a5,stroke:#388e3c
classDef review fill:#d1c4e9,stroke:#512da8
class Start,End startend,BugFix,LiteFix,HotFix,BugDiag,BugComplete bugfix,Ideation,BrainIdea,BrainDesign ideation,LitePlan,LitePlanE,LitePlanNormal,LiteConfirm,FullPlan,PlanVerify,Verify,FixPlan planning,Execute,LiteAgent,LiteCLI,UserImpl,TDD,TDDExecute,TDDVerify,TestGen,TestExecute,TestCycle execute,Review,SecurityReview,ArchReview,QualityReview,GeneralReview,Complete review
`}
/>
### 使用场景
### 何时使用
- 复杂的多步骤工作流
- 不确定使用哪些命令
- 需要端到端自动化
- 需要完整的状态跟踪和可恢复性
- 团队协作需要统一的执行流程
### 何时不使用
- 简单的单命令任务 (直接使用层级 1-4)
- 已经知道确切的所需命令 (直接使用层级 1-4)
### 与其他层级的关系
| 层级 | 手动程度 | CCW Coordinator 角色 |
|-------|---------------|-----------------------|
| 层级 1-4 | 手动选择命令 | 自动组合这些命令 |
| 层级 5 | 自动选择命令 | 智能编排器 |
**CCW Coordinator 内部使用层级 1-4**:
- 分析任务 -> 自动选择合适的层级
- 组装命令链 -> 包含层级 1-4 的命令
- 顺序执行 -> 遵循最小执行单元
## 相关工作流
- [层级 1: 超轻量级](./level-1-ultra-lightweight.mdx) - 快速执行
- [层级 2: 快速](./level-2-rapid.mdx) - 轻量级规划
- [层级 3: 标准](./level-3-standard.mdx) - 完整规划
- [层级 4: 头脑风暴](./level-4-brainstorm.mdx) - 多角色探索
- [常见问题](./faq.mdx) - 常见问题
## 命令参考
参见 [命令文档](../commands/general/ccw.mdx) 了解:
- `/ccw-coordinator` - 智能工作流编排器
- `/ccw` - 主工作流编排器