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

File diff suppressed because one or more lines are too long

File diff suppressed because one or more lines are too long

View File

@@ -21,7 +21,7 @@
"sidebar": "docs",
"previous": {
"title": "Overview",
"permalink": "/docs/docs/"
"permalink": "/docs/docs/overview"
},
"next": {
"title": "/ccw-plan",

View File

@@ -4,8 +4,8 @@
"description": "CCW is a professional workflow automation platform that combines AI-powered intelligence with structured development workflows. With 40+ commands and 15 integrated workflows, CCW transforms how you build, test, and ship software.",
"source": "@site/docs/overview.mdx",
"sourceDirName": ".",
"slug": "/",
"permalink": "/docs/docs/",
"slug": "/overview",
"permalink": "/docs/docs/overview",
"draft": false,
"unlisted": false,
"editUrl": "https://github.com/ccw/docs/tree/main/docs/overview.mdx",
@@ -15,8 +15,7 @@
"frontMatter": {
"title": "Welcome to CCW",
"sidebar_label": "Overview",
"sidebar_position": 1,
"slug": "/"
"sidebar_position": 1
},
"sidebar": "docs",
"next": {

File diff suppressed because one or more lines are too long

View File

@@ -7,10 +7,11 @@ export default {
"title": "CCW Help Documentation",
"tagline": "Professional Workflow Automation Platform",
"favicon": "img/favicon.ico",
"url": "https://ccw.dev",
"url": "http://localhost:3001",
"baseUrl": "/docs/",
"organizationName": "ccw",
"projectName": "docs",
"trailingSlash": false,
"onBrokenLinks": "throw",
"i18n": {
"defaultLocale": "en",

View File

@@ -127,7 +127,7 @@
},
{
"id": "overview",
"path": "/docs/docs/",
"path": "/docs/docs/overview",
"sidebar": "docs"
},
{
@@ -169,7 +169,7 @@
"sidebars": {
"docs": {
"link": {
"path": "/docs/docs/",
"path": "/docs/docs/overview",
"label": "Quick Start"
}
}

View File

@@ -14,7 +14,7 @@
"calendar": "gregory",
"path": "en",
"translate": false,
"url": "https://ccw.dev",
"url": "http://localhost:3001",
"baseUrl": "/docs/"
},
"zh": {
@@ -24,7 +24,7 @@
"calendar": "gregory",
"path": "zh",
"translate": true,
"url": "https://ccw.dev",
"url": "http://localhost:3001",
"baseUrl": "/docs/zh/"
}
}

View File

@@ -11,7 +11,6 @@ export default {
"__comp---theme-docs-root-5-e-9-0b6": [() => import(/* webpackChunkName: "__comp---theme-docs-root-5-e-9-0b6" */ "@theme/DocsRoot"), "@theme/DocsRoot", require.resolveWeak("@theme/DocsRoot")],
"__props---docs-docsa-20-f19": [() => import(/* webpackChunkName: "__props---docs-docsa-20-f19" */ "@generated/docusaurus-plugin-content-docs/default/p/docs-docs-fbb.json"), "@generated/docusaurus-plugin-content-docs/default/p/docs-docs-fbb.json", require.resolveWeak("@generated/docusaurus-plugin-content-docs/default/p/docs-docs-fbb.json")],
"__props---docs-docusaurus-debug-content-344-8d5": [() => import(/* webpackChunkName: "__props---docs-docusaurus-debug-content-344-8d5" */ "@generated/docusaurus-plugin-debug/default/p/docs-docusaurus-debug-content-a52.json"), "@generated/docusaurus-plugin-debug/default/p/docs-docusaurus-debug-content-a52.json", require.resolveWeak("@generated/docusaurus-plugin-debug/default/p/docs-docusaurus-debug-content-a52.json")],
"content---docs-docs-188-f57": [() => import(/* webpackChunkName: "content---docs-docs-188-f57" */ "@site/docs/overview.mdx"), "@site/docs/overview.mdx", require.resolveWeak("@site/docs/overview.mdx")],
"content---docs-docs-commands-cli-cli-init-056-2d3": [() => import(/* webpackChunkName: "content---docs-docs-commands-cli-cli-init-056-2d3" */ "@site/docs/commands/cli/cli-init.mdx"), "@site/docs/commands/cli/cli-init.mdx", require.resolveWeak("@site/docs/commands/cli/cli-init.mdx")],
"content---docs-docs-commands-cli-codex-reviewf-1-b-532": [() => import(/* webpackChunkName: "content---docs-docs-commands-cli-codex-reviewf-1-b-532" */ "@site/docs/commands/cli/codex-review.mdx"), "@site/docs/commands/cli/codex-review.mdx", require.resolveWeak("@site/docs/commands/cli/codex-review.mdx")],
"content---docs-docs-commands-general-ccw-coordinatord-55-a04": [() => import(/* webpackChunkName: "content---docs-docs-commands-general-ccw-coordinatord-55-a04" */ "@site/docs/commands/general/ccw-coordinator.mdx"), "@site/docs/commands/general/ccw-coordinator.mdx", require.resolveWeak("@site/docs/commands/general/ccw-coordinator.mdx")],
@@ -35,6 +34,7 @@ export default {
"content---docs-docs-commands-memory-memory-update-full-666-28e": [() => import(/* webpackChunkName: "content---docs-docs-commands-memory-memory-update-full-666-28e" */ "@site/docs/commands/memory/memory-update-full.mdx"), "@site/docs/commands/memory/memory-update-full.mdx", require.resolveWeak("@site/docs/commands/memory/memory-update-full.mdx")],
"content---docs-docs-commands-memory-memory-update-related-611-f0a": [() => import(/* webpackChunkName: "content---docs-docs-commands-memory-memory-update-related-611-f0a" */ "@site/docs/commands/memory/memory-update-related.mdx"), "@site/docs/commands/memory/memory-update-related.mdx", require.resolveWeak("@site/docs/commands/memory/memory-update-related.mdx")],
"content---docs-docs-faqea-3-29f": [() => import(/* webpackChunkName: "content---docs-docs-faqea-3-29f" */ "@site/docs/faq.mdx"), "@site/docs/faq.mdx", require.resolveWeak("@site/docs/faq.mdx")],
"content---docs-docs-overview-188-8fe": [() => import(/* webpackChunkName: "content---docs-docs-overview-188-8fe" */ "@site/docs/overview.mdx"), "@site/docs/overview.mdx", require.resolveWeak("@site/docs/overview.mdx")],
"content---docs-docs-workflows-faqbcf-a47": [() => import(/* webpackChunkName: "content---docs-docs-workflows-faqbcf-a47" */ "@site/docs/workflows/faq.mdx"), "@site/docs/workflows/faq.mdx", require.resolveWeak("@site/docs/workflows/faq.mdx")],
"content---docs-docs-workflows-introduction-9-f-4-dba": [() => import(/* webpackChunkName: "content---docs-docs-workflows-introduction-9-f-4-dba" */ "@site/docs/workflows/introduction.mdx"), "@site/docs/workflows/introduction.mdx", require.resolveWeak("@site/docs/workflows/introduction.mdx")],
"content---docs-docs-workflows-level-1-ultra-lightweightc-5-a-692": [() => import(/* webpackChunkName: "content---docs-docs-workflows-level-1-ultra-lightweightc-5-a-692" */ "@site/docs/workflows/level-1-ultra-lightweight.mdx"), "@site/docs/workflows/level-1-ultra-lightweight.mdx", require.resolveWeak("@site/docs/workflows/level-1-ultra-lightweight.mdx")],

View File

@@ -39,22 +39,16 @@ export default [
},
{
path: '/docs/docs',
component: ComponentCreator('/docs/docs', '7fe'),
component: ComponentCreator('/docs/docs', '942'),
routes: [
{
path: '/docs/docs',
component: ComponentCreator('/docs/docs', '830'),
component: ComponentCreator('/docs/docs', 'a90'),
routes: [
{
path: '/docs/docs',
component: ComponentCreator('/docs/docs', '77f'),
component: ComponentCreator('/docs/docs', 'c2e'),
routes: [
{
path: '/docs/docs/',
component: ComponentCreator('/docs/docs/', '2fa'),
exact: true,
sidebar: "docs"
},
{
path: '/docs/docs/commands/cli/cli-init',
component: ComponentCreator('/docs/docs/commands/cli/cli-init', 'c74'),
@@ -193,6 +187,12 @@ export default [
exact: true,
sidebar: "docs"
},
{
path: '/docs/docs/overview',
component: ComponentCreator('/docs/docs/overview', '7df'),
exact: true,
sidebar: "docs"
},
{
path: '/docs/docs/workflows/faq',
component: ComponentCreator('/docs/docs/workflows/faq', 'f47'),

View File

@@ -42,23 +42,19 @@
"plugin": "plugin---docs-docusaurus-debugb-38-c84"
}
},
"/docs/docs-7fe": {
"/docs/docs-942": {
"__comp": "__comp---theme-docs-root-5-e-9-0b6",
"__context": {
"plugin": "plugin---docs-docsaba-31e"
}
},
"/docs/docs-830": {
"/docs/docs-a90": {
"__comp": "__comp---theme-doc-version-roota-7-b-5de",
"__props": "__props---docs-docsa-20-f19"
},
"/docs/docs-77f": {
"/docs/docs-c2e": {
"__comp": "__comp---theme-doc-roota-94-67a"
},
"/docs/docs/-2fa": {
"__comp": "__comp---theme-doc-item-178-a40",
"content": "content---docs-docs-188-f57"
},
"/docs/docs/commands/cli/cli-init-c74": {
"__comp": "__comp---theme-doc-item-178-a40",
"content": "content---docs-docs-commands-cli-cli-init-056-2d3"
@@ -151,6 +147,10 @@
"__comp": "__comp---theme-doc-item-178-a40",
"content": "content---docs-docs-faqea-3-29f"
},
"/docs/docs/overview-7df": {
"__comp": "__comp---theme-doc-item-178-a40",
"content": "content---docs-docs-overview-188-8fe"
},
"/docs/docs/workflows/faq-f47": {
"__comp": "__comp---theme-doc-item-178-a40",
"content": "content---docs-docs-workflows-faqbcf-a47"

View File

@@ -2,7 +2,6 @@
title: Welcome to CCW
sidebar_label: Overview
sidebar_position: 1
slug: /
---
import Mermaid from '@theme/Mermaid';
@@ -29,7 +28,7 @@ CCW (Claude Code Workflows) is an advanced development environment that orchestr
<div className="row">
<div className="col col--4">
<Link to="/docs/workflows/introduction" className="card padding--lg">
<Link to="/workflows/introduction" className="card padding--lg">
<div className="card__header">
<h3>Workflows</h3>
</div>
@@ -39,7 +38,7 @@ CCW (Claude Code Workflows) is an advanced development environment that orchestr
</Link>
</div>
<div className="col col--4">
<Link to="/docs/commands/workflow/workflow-plan" className="card padding--lg">
<Link to="/commands/general/ccw" className="card padding--lg">
<div className="card__header">
<h3>Commands</h3>
</div>
@@ -49,7 +48,7 @@ CCW (Claude Code Workflows) is an advanced development environment that orchestr
</Link>
</div>
<div className="col col--4">
<Link to="/docs/faq" className="card padding--lg">
<Link to="/faq" className="card padding--lg">
<div className="card__header">
<h3>FAQ</h3>
</div>

View File

@@ -7,12 +7,14 @@ const config: Config = {
tagline: 'Professional Workflow Automation Platform',
favicon: 'img/favicon.ico',
url: 'https://ccw.dev',
url: 'http://localhost:3001',
baseUrl: '/docs/',
organizationName: 'ccw',
projectName: 'docs',
trailingSlash: false,
onBrokenLinks: 'throw',
onBrokenMarkdownLinks: 'warn',

View File

@@ -0,0 +1,331 @@
---
title: 欢迎使用 CCW
sidebar_label: 概览
sidebar_position: 1
---
import Mermaid from '@theme/Mermaid';
import Link from '@docusaurus/Link';
# 欢迎使用 CCW
CCW 是一个专业的工作流自动化平台,结合了 AI 驱动的智能与结构化开发工作流。凭借 40+ 命令和 15 个集成工作流CCW 彻底改变了您构建、测试和交付软件的方式。
## 什么是 CCW
CCW (Claude Code Workflows) 是一个高级开发环境,编排 AI 代理、工作流和工具以加速软件开发,同时保持质量标准。
**核心能力:**
- **AI 驱动开发** - 利用多种 AI 模型Gemini、Codex、Claude、Qwen进行代码分析、生成和审查
- **结构化工作流** - 从快速执行到智能编排的 15 个工作流级别
- **40+ 命令** - 覆盖规划、执行、测试、审查和维护的全面命令集
- **会话管理** - 完整的状态持久化,支持可恢复的会话
- **多代理协调** - 具有依赖感知任务分配的并行执行
- **质量关卡** - 内置的测试、验证和代码审查工作流
## 快速链接
<div className="row">
<div className="col col--4">
<Link to="/docs/workflows/introduction" className="card padding--lg">
<div className="card__header">
<h3>工作流</h3>
</div>
<div className="card__body">
<p>探索从快速执行到智能编排的 15 个工作流级别</p>
</div>
</Link>
</div>
<div className="col col--4">
<Link to="/docs/commands/general/ccw" className="card padding--lg">
<div className="card__header">
<h3>命令</h3>
</div>
<div className="card__body">
<p>工作流、问题、CLI 和内存操作的完整命令参考</p>
</div>
</Link>
</div>
<div className="col col--4">
<Link to="/docs/faq" className="card padding--lg">
<div className="card__header">
<h3>常见问题</h3>
</div>
<div className="card__body">
<p>常见问题、故障排除提示和最佳实践</p>
</div>
</Link>
</div>
</div>
## 核心功能
### 40+ 命令
CCW 提供按类别组织的全面命令集:
| 类别 | 命令数 | 用途 |
|----------|----------|---------|
| **工作流** | 13 命令 | 规划、执行、审查、清理 |
| **问题** | 7 命令 | 问题发现、规划、解决 |
| **CLI** | 2 命令 | CLI 初始化和审查 |
| **内存** | 6 命令 | 知识管理和文档 |
| **通用** | 7+ 命令 | 协调、调试、流程创建 |
### 15 个集成工作流
<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["问题工作流"]
I1["阶段 1: 积累"]
I2["阶段 2: 解决"]
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
`}
/>
**主工作流级别:**
- **级别 1**:零开销的超轻量级直接执行
- **级别 2**:轻量级规划 (lite-plan)、错误修复 (lite-fix)、多 CLI 分析 (multi-cli-plan)
- **级别 3**:标准规划 (plan)、测试驱动开发 (tdd-plan)、测试修复生成 (test-fix-gen)
- **级别 4**:多角色并行分析的头脑风暴
- **级别 5**:自动命令选择的智能编排
**问题工作流:**
- **积累阶段**discover、new
- **解决阶段**plan、queue、execute
### AI 驱动的智能
CCW 集成多种 AI 模型提供智能辅助:
| 模型 | 能力 | 使用场景 |
|-------|--------------|-----------|
| **Gemini** | 分析 + 写入 | 代码审查、调试、重构 |
| **Codex** | 分析 + 写入 + 审查 | Git 感知代码审查、实现 |
| **Claude** | 分析 + 写入 | 复杂推理、文档 |
| **Qwen** | 分析 + 写入 | 代码生成、模式匹配 |
**多 CLI 协作:**
```bash
# 比较多个 AI 视角的解决方案
/ccw multi-cli-plan "比较 Redis vs RabbitMQ 用于消息队列"
```
### 会话管理
CCW 为所有工作流会话提供完整的状态持久化:
```bash
# 启动规划会话
/ccw workflow:plan "实现用户认证"
# 恢复暂停的会话
/ccw workflow:session:resume WFS-user-auth
# 列出所有会话
/ccw workflow:session:list
# 完成并归档
/ccw workflow:session:complete WFS-user-auth
```
**会话结构:**
```
.workflow/active/WFS-{session}/
├── workflow-session.json # 会话元数据
├── IMPL_PLAN.md # 实现计划
├── TODO_LIST.md # 进度跟踪
├── .task/
│ ├── IMPL-001.json # 任务定义
│ └── ...
└── .summaries/
├── IMPL-001-summary.md # 完成摘要
└── ...
```
## 快速入门
### 选择您的起点
<div className="row">
<div className="col col--6">
<div className="card padding--md">
<div className="card__header">
<h3>CCW 新手?</h3>
</div>
<div className="card__body">
<p>从 <strong>级别 1 工作流</strong> 开始处理简单任务:</p>
<ul>
<li>快速修复和配置调整</li>
<li>简单功能实现</li>
<li>无规划开销的直接执行</li>
</ul>
<Link to="/docs/workflows/level-1-ultra-lightweight" className="button button--primary button--sm">学习级别 1</Link>
</div>
</div>
</div>
<div className="col col--6">
<div className="card padding--md">
<div className="card__header">
<h3>经验丰富的开发者?</h3>
</div>
<div className="card__body">
<p>直接跳到 <strong>级别 3 工作流</strong> 处理复杂功能:</p>
<ul>
<li>多模块变更</li>
<li>测试驱动开发</li>
<li>带验证的完整规划</li>
</ul>
<Link to="/docs/workflows/level-3-standard" className="button button--primary button--sm">学习级别 3</Link>
</div>
</div>
</div>
</div>
### 快速入门示例
**快速修复 (级别 1)**
```bash
# 简单更改的直接执行
/ccw lite-lite-lite "修复登录按钮中的拼写错误"
```
**带诊断的错误修复 (级别 2)**
```bash
# 智能错误诊断和修复
/ccw lite-fix "用户在个人资料更新时遇到 500 错误"
```
**功能开发 (级别 3)**
```bash
# 完整的规划和执行
/ccw workflow:plan "添加 OAuth2 认证"
/ccw workflow:execute --session WFS-oauth-auth
```
**新功能设计 (级别 4)**
```bash
# 多角色头脑风暴
/ccw brainstorm:auto-parallel "设计实时通知系统"
```
**不确定的命令 (级别 5)**
```bash
# 自动分析并推荐命令链
/ccw ccw-coordinator "需要重构整个 API 层"
```
## 架构概览
<Mermaid
chart={`
flowchart LR
User[开发者] --> CCW[CCW CLI]
CCW --> Workflow{工作流引擎}
Workflow --> L1[级别 1: 直接]
Workflow --> L2[级别 2: 轻量级]
Workflow --> L3[级别 3: 标准]
Workflow --> L4[级别 4: 头脑风暴]
Workflow --> L5[级别 5: 智能化]
L1 --> Agent[代理执行]
L2 --> Agent
L3 --> Agent
L4 --> MultiAgent[多代理并行]
L5 --> Coordinator[智能协调器]
Agent --> AI[AI 模型]
MultiAgent --> AI
Coordinator --> AI
AI --> Output[代码 + 工件]
Output --> Repo[Git 仓库]
Repo --> Session[会话状态]
classDef user fill:#f3f9ff,stroke:#1976d2
classDef ccw fill:#e3f2fd,stroke:#1976d2,stroke-width:2px
classDef agent fill:#c8e6c9,stroke:#388e3c
classDef ai fill:#fff9c4,stroke:#f57c00
classDef storage fill:#f1f8e9,stroke:#33691e
class User user,CCW ccw,Workflow ccw,Agent agent,MultiAgent agent,Coordinator ccw,AI ai,Output storage,Repo storage,Session storage
`}
/>
## 下一步
### 学习基础知识
1. **[工作流简介](./workflows/introduction.mdx)** - 了解工作流级别和选择
2. **[命令参考](./commands/general/ccw.mdx)** - 完整的命令文档
3. **[常见问题](./faq.mdx)** - 常见问题和故障排除
### 按使用场景探索
| 使用场景 | 推荐工作流 | 文档 |
|----------|---------------------|---------------|
| 快速修复 | `lite-lite-lite` | [级别 1](./workflows/level-1-ultra-lightweight.mdx) |
| 错误诊断 | `lite-fix` | [级别 2](./workflows/level-2-rapid.mdx) |
| 功能开发 | `plan` → `execute` | [级别 3](./workflows/level-3-standard.mdx) |
| 测试驱动开发 | `tdd-plan` → `execute` | [级别 3](./workflows/level-3-standard.mdx) |
| 架构设计 | `brainstorm:auto-parallel` | [级别 4](./workflows/level-4-brainstorm.mdx) |
| 复杂工作流 | `ccw-coordinator` | [级别 5](./workflows/level-5-intelligent.mdx) |
| 问题跟踪 | 问题工作流 | [工作流 FAQ](./workflows/faq.mdx) |
### 试用一下
**安装:**
```bash
npm install -g @ccw/cli
```
**初始化项目:**
```bash
ccw init
```
**第一个工作流:**
```bash
# 简单任务
ccw lite-lite-lite "添加用户个人资料页面"
# 复杂功能
ccw workflow:plan "实现购物车"
```
## 支持
- **文档**: [docs.ccw.dev](https://docs.ccw.dev)
- **GitHub**: [github.com/ccw/ccw](https://github.com/ccw/ccw)
- **问题**: [github.com/ccw/ccw/issues](https://github.com/ccw/ccw/issues)
---
**准备开始了吗?** 探索 [工作流简介](./workflows/introduction.mdx) 了解所有 15 个工作流级别。

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` - 主工作流编排器