claudecode-omc 4.5.7 → 4.8.0

package/docs/partials/mode-selection-guide.md

@@ -4,34 +4,43 @@
 
 | If you want... | Use this | Keyword |
 |----------------|----------|---------|
+| Clarify vague requirements first | `deep-interview` | "deep interview", "ouroboros", "don't assume" |
 | Full autonomous build from idea | `autopilot` | "autopilot", "build me", "I want a" |
-| Parallel autonomous (3-5x faster) | `ultrapilot` | "ultrapilot", "parallel build" |
+| Parallel autonomous (3-5x faster) | `team` (replaces `ultrapilot`) | `/team N:executor "task"` |
 | Persistence until verified done | `ralph` | "ralph", "don't stop" |
 | Parallel execution, manual oversight | `ultrawork` | "ulw", "ultrawork" |
 | Cost-efficient execution | `` (modifier) | "eco", "budget" |
-| Many similar independent tasks | `swarm` | "swarm N agents" |
+| Many similar independent tasks | `team` (replaces `swarm`) | `/team N:executor "task"` |
 
-## If You're Confused
+> **Note:** `ultrapilot` and `swarm` are **deprecated** — they now route to `team` mode.
 
-**Start with `autopilot`** - it handles most scenarios and transitions to other modes automatically.
+## If You're Confused or Uncertain
+
+**Don't know what you don't know?** Start with `/deep-interview` - it uses Socratic questioning to clarify vague ideas, expose hidden assumptions, and measure clarity before any code is written.
+
+**Already have a clear idea?** Start with `autopilot` - it handles most scenarios and transitions to other modes automatically.
 
 ## Detailed Decision Flowchart
 
 ```
+Uncertain about requirements or have a vague idea?
+├── YES: Use deep-interview to clarify before execution
+└── NO: Continue below
+
 Want autonomous execution?
 ├── YES: Is task parallelizable into 3+ independent components?
-│   ├── YES: ultrapilot (parallel autopilot with file ownership)
+│   ├── YES: team N:deep-executor (parallel autonomous with file ownership)
 │   └── NO: autopilot (sequential with ralph phases)
 └── NO: Want parallel execution with manual oversight?
     ├── YES: Do you want cost optimization?
-    │   ├── YES:  + ultrawork
+    │   ├── YES: eco + ultrawork
     │   └── NO: ultrawork alone
     └── NO: Want persistence until verified done?
         ├── YES: ralph (persistence + ultrawork + verification)
         └── NO: Standard orchestration (delegate to agents directly)
 
 Have many similar independent tasks (e.g., "fix 47 errors")?
-└── YES: swarm (N agents claiming from task pool)
+└── YES: team N:executor (N agents claiming from task pool)
 ```
 
 ## Examples
@@ -39,8 +48,8 @@ Have many similar independent tasks (e.g., "fix 47 errors")?
 | User Request | Best Mode | Why |
 |--------------|-----------|-----|
 | "Build me a REST API" | autopilot | Single coherent deliverable |
-| "Build frontend, backend, and database" | ultrapilot | Clear component boundaries |
-| "Fix all 47 TypeScript errors" | swarm | Many independent similar tasks |
+| "Build frontend, backend, and database" | team 3:deep-executor | Clear component boundaries |
+| "Fix all 47 TypeScript errors" | team 5:executor | Many independent similar tasks |
 | "Refactor auth module thoroughly" | ralph | Need persistence + verification |
 | "Quick parallel execution" | ultrawork | Manual oversight preferred |
 | "Save tokens while fixing errors" |  + ultrawork | Cost-conscious parallel |
@@ -51,8 +60,9 @@ Have many similar independent tasks (e.g., "fix 47 errors")?
 ### Standalone Modes
 These run independently:
 - **autopilot**: Autonomous end-to-end execution
-- **ultrapilot**: Parallel autonomous with file ownership
-- **swarm**: N-agent coordination with task pool
+- **team**: Canonical orchestration with coordinated agents (replaces `ultrapilot` and `swarm`)
+
+> **Deprecated:** `ultrapilot` and `swarm` now route to `team` mode.
 
 ### Wrapper Modes
 These wrap other modes:
@@ -78,5 +88,5 @@ These modify how other modes work:
 
 | Combination | Why Invalid |
 |-------------|-------------|
-| `autopilot ultrapilot` | Both are standalone - use one |
+| `autopilot team` | Both are standalone - use one |
 | `` alone | Needs an execution mode to modify |

package/docs/plans/2026-03-06-llm-testing-system-design.md

@@ -0,0 +1,311 @@
+# LLM 驱动的持续开发测试系统设计
+
+**日期**: 2026-03-06
+**状态**: 已批准
+**作者**: Claude Opus 4.6
+
+## 概述
+
+为 oh-my-claudecode 构建一个完整的测试系统，支持 LLM 驱动的持续开发和迭代。系统通过自动测试生成、覆盖率分析、行为驱动开发（BDD）和测试驱动开发（TDD）的结合，以及 AI 代码审查和持续重构，实现大模型对复杂应用的持续迭代能力。
+
+## 目标
+
+### 主要目标（按优先级）
+1. **测试覆盖率 80%+**：在不需要大量手动编写测试的情况下达到高覆盖率
+2. **持续迭代保护**：每次代码改进都有测试保证不会退化
+3. **降低测试成本**：减少测试编写的时间和精力投入
+4. **自动验证**：LLM 生成代码后自动验证正确性
+
+### 技术需求
+- 支持多语言：Node.js、Python、Go、Rust
+- 支持多框架：React (Tauri/Electron/Web)
+- 支持多数据库：PostgreSQL、MySQL、MongoDB
+- 支持多 API 类型：REST、GraphQL、gRPC
+- 支持多 LLM：Claude Code、Codex
+
+## 架构设计
+
+### 整体架构
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    用户交互层                                  │
+│  /test-gen  /ultraqa  /autopilot  /ralph                     │
+└─────────────────┬───────────────────────────────────────────┘
+                  │
+    ┌─────────────┴─────────────┐
+    │                           │
+┌───▼────────────┐    ┌────────▼──────────┐
+│  OMC Skills    │    │  OMC Agents       │
+│  • test-gen    │───►│  • test-engineer  │
+│  • tdd         │    │  • coverage-analyzer│
+│  • ultraqa     │    │  • contract-tester│
+└───┬────────────┘    └────────┬──────────┘
+    │                          │
+    │         ┌────────────────┴──────────┐
+    │         │                           │
+    │    ┌────▼─────────┐      ┌─────────▼────────┐
+    │    │ omc test CLI │      │ Agent Tools      │
+    │    │ (shell调用)   │      │ (直接调用)        │
+    │    └──────────────┘      └──────────────────┘
+    │
+┌───▼────────────────────────────────────────────────────────┐
+│              测试执行和分析层                                 │
+│  • Promptfoo (测试生成)                                      │
+│  • Giskard (行为测试)                                        │
+│  • 技术栈检测器                                              │
+│  • 覆盖率分析器                                              │
+└──────────────────────────────────────────────────────────────┘
+```
+
+### 核心设计原则
+
+1. **分层解耦**：CLI 工具独立运行，agent 通过 shell 调用
+2. **渐进增强**：Phase 1 先实现核心功能，后续逐步深化集成
+3. **技术栈无关**：通过适配器模式支持多语言多框架
+4. **成本优化**：简单测试用 Haiku，复杂分析用 Sonnet/Opus
+5. **Skill 集成**：完全通过 OMC skill 系统集成，无需 MCP
+
+## 核心组件
+
+### 1. CLI 工具层 (`omc test`)
+
+集成到现有的 `omc` CLI 中作为子命令：
+
+```bash
+omc test gen <file>           # 生成测试
+omc test analyze              # 分析覆盖率
+omc test contract <api>       # 生成契约测试
+omc test detect-stack         # 检测技术栈
+```
+
+**项目结构**：
+```
+oh-my-claudecode/
+├── src/
+│   └── testing/
+│       ├── cli/          # omc test 子命令
+│       ├── generators/   # 测试生成器
+│       ├── analyzers/    # 覆盖率分析
+│       ├── adapters/     # 多语言适配器
+│       └── integrations/ # Promptfoo/Giskard 集成
+```
+
+### 2. Skills 层
+
+**新增 Skills**：
+- `/test-gen` - 显式生成测试
+- `/tdd` - 增强现有 TDD skill，强制测试优先
+
+**增强现有 Skills**：
+- `/ultraqa` - 集成测试生成和验证循环
+- `/autopilot` - 生成代码时自动生成测试
+
+### 3. Agents 层
+
+**新增 Agents**：
+- `test-spec-generator` - 生成 BDD 风格的测试规范
+- `coverage-analyzer` - 分析覆盖率缺口
+- `contract-tester` - API 契约测试
+
+**增强现有 Agents**：
+- `test-engineer` - 支持多语言测试生成，智能复杂度判断
+
+### 4. 测试框架适配器
+
+**前端（React）**：
+- Vitest + Testing Library（单元测试）
+- Playwright（E2E 测试）
+
+**后端**：
+- Node.js: Vitest/Jest
+- Python: pytest
+- Go: testing package
+- Rust: cargo test
+
+**集成测试**：
+- API 契约测试：基于 OpenAPI/Pact
+- E2E 用户流程：Playwright 跨栈测试
+
+## 工作流程
+
+### 混合模式：智能判断复杂度
+
+**简单代码（自动生成测试）**：
+- 函数行数 < 50
+- 圈复杂度 < 10
+- 嵌套层级 < 3
+- 无外部依赖
+
+**复杂代码（提示补充测试）**：
+- 涉及支付、认证等关键业务
+- 多步骤状态机或工作流
+- 跨服务分布式事务
+- 需要 mock 多个外部依赖
+- 需要复杂的测试数据准备
+- 异步/并发场景
+
+### TDD 工作流
+
+```
+用户需求 → 技术栈检测（自动 + 确认）→ 生成测试规范 →
+AI 生成代码 → 自动验证 → 覆盖率分析 →
+补充测试 → 持续迭代
+```
+
+### 集成到现有工作流
+
+**Autopilot 模式**：
+```
+需求分析 → 生成测试规范 → 生成代码 + 测试 → 验证 → 部署
+```
+
+**Ralph 模式**：
+```
+生成代码 → 生成测试 → 验证 →
+如果失败：分析 → 修复 → 重新测试 →
+循环直到通过
+```
+
+**Ultraqa 模式**：
+```
+测试 → 验证 → 修复 → 重复
+（现在包含自动测试生成）
+```
+
+## 技术栈检测
+
+### 自动检测
+- 扫描 `package.json`、`requirements.txt`、`go.mod`、`Cargo.toml`
+- 分析项目结构（src/、tests/、__tests__/）
+- 识别框架（React、Vue、Svelte）
+- 识别测试工具（Jest、Vitest、pytest）
+
+### 用户确认
+- 显示检测结果
+- 允许用户修正或补充
+- 保存到项目配置（`.omc/project-config.json`）
+
+## 测试类型
+
+### 1. 单元测试
+- 自动为函数/类生成测试
+- 覆盖正常路径和边界情况
+- Mock 外部依赖
+
+### 2. API 契约测试
+- 基于 OpenAPI 规范生成
+- 验证请求/响应格式
+- 确保前后端接口一致
+
+### 3. E2E 测试
+- 模拟真实用户操作
+- 跨前后端的完整流程
+- 使用 Playwright 执行
+
+### 4. 行为测试（Giskard）
+- 扰动测试（typos、negations）
+- 鲁棒性验证
+- 公平性指标
+
+## 实施路径
+
+### Phase 1：核心功能（2-3 周）
+- ✅ 设计文档
+- `omc test` CLI 基础命令
+- 技术栈检测器
+- 基础测试生成（React + Node.js）
+- `/test-gen` skill
+- 集成 Promptfoo
+
+**交付物**：
+- 可以为简单的 React 组件和 Node.js 函数生成测试
+- 自动检测技术栈
+- 通过 `/test-gen` 显式调用
+
+### Phase 2：深度集成（3-4 周）
+- 覆盖率分析器
+- 多语言支持（Python、Go、Rust）
+- 增强 `test-engineer` agent
+- 复杂度判断逻辑
+- 契约测试生成
+- 集成到 `/ultraqa`
+
+**交付物**：
+- 支持所有目标语言
+- 智能判断何时需要人工补充测试
+- API 契约测试自动生成
+- Ultraqa 包含测试生成
+
+### Phase 3：完整生态（4-6 周）
+- 集成 Giskard 行为测试
+- E2E 测试生成
+- CI/CD 集成
+- Ralph 模式测试循环
+- Autopilot 自动测试
+- 性能优化
+
+**交付物**：
+- 完整的测试生态系统
+- 所有 OMC 模式都包含测试
+- 达到 80%+ 覆盖率目标
+- 持续迭代保护
+
+## 成功指标
+
+### 定量指标
+- 测试覆盖率：80%+
+- 测试生成时间：< 30 秒/文件
+- 测试通过率：> 90%
+- 手动测试编写减少：70%+
+
+### 定性指标
+- 开发者信心提升
+- 重构更安全
+- 技术债务减少
+- 迭代速度提升
+
+## 风险和缓解
+
+### 风险 1：多语言支持复杂度高
+**缓解**：Phase 1 先支持 React + Node.js，后续逐步添加
+
+### 风险 2：测试质量不稳定
+**缓解**：
+- 使用 Promptfoo 的反馈循环
+- 人工审查复杂测试
+- 持续优化提示词
+
+### 风险 3：性能开销
+**缓解**：
+- 简单测试用 Haiku（成本低）
+- 并行生成测试
+- 缓存技术栈检测结果
+
+### 风险 4：与现有工作流冲突
+**缓解**：
+- 渐进式集成
+- 保持向后兼容
+- 提供开关控制
+
+## 参考资料
+
+### 调研发现
+1. **TDD with AI**: 测试即规范，测试告诉 AI "做什么"和"何时完成"
+2. **GitHub Copilot**: 71% 可操作反馈率，15% 更快的审查速度
+3. **三层验证**: 确定性测试 → LLM 评估器 → 人工审批
+4. **90 天重构**: 73% 技术债务减少，280% 可维护性提升
+5. **60-70% 通过率**: 高级 AI 模型仍需人工验证
+
+### 工具选择
+- **Promptfoo**: 开源、隐私优先、多提供商支持
+- **Giskard**: 行为测试、公平性指标
+- **Playwright**: 跨浏览器 E2E 测试
+- **Vitest**: 快速、现代的测试框架
+
+## 下一步
+
+1. ✅ 设计文档批准
+2. 创建详细实施计划
+3. Phase 1 开发启动
+4. 持续迭代和优化