From 383da9ebb780fc6e5a7018efc5865a1ab14e84ed Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 20 Nov 2025 09:51:50 +0000 Subject: [PATCH 1/2] docs: add CLI tools collaboration mode to Workflow Decision Guide Add comprehensive section on multi-model CLI collaboration (Gemini/Qwen/Codex): - Three execution modes: serial, parallel, and hybrid - Semantic invocation vs command invocation patterns - Integration examples with Lite and Full workflows - Best practices for tool selection and execution strategies Updates both Chinese and English versions with practical examples showing how to leverage ultra-long context models (Gemini/Qwen) for analysis and Codex for precise code implementation. --- WORKFLOW_DECISION_GUIDE.md | 174 ++++++++++++++++++++++++++++++++++ WORKFLOW_DECISION_GUIDE_EN.md | 174 ++++++++++++++++++++++++++++++++++ 2 files changed, 348 insertions(+) diff --git a/WORKFLOW_DECISION_GUIDE.md b/WORKFLOW_DECISION_GUIDE.md index b813381a..92f02d26 100644 --- a/WORKFLOW_DECISION_GUIDE.md +++ b/WORKFLOW_DECISION_GUIDE.md @@ -253,6 +253,180 @@ flowchart TD --- +### 7️⃣ **CLI 工具协作模式 - 多模型智能协同** + +本项目集成了三种 CLI 工具，支持灵活的串联、并行和混合执行方式： + +| 工具 | 核心能力 | 上下文长度 | 适用场景 | +|------|---------|-----------|---------| +| **Gemini** | 深度分析、架构设计、规划 | 超长上下文 | 代码理解、执行流追踪、技术方案评估 | +| **Qwen** | 代码审查、模式识别 | 超长上下文 | Gemini 备选、多维度分析 | +| **Codex** | 精确代码撰写、Bug定位 | 标准上下文 | 功能实现、测试生成、代码重构 | + +#### 📋 三种执行模式 + +**1. 串联执行（Serial Execution）** - 顺序依赖 + +适用场景：后续任务依赖前一任务的结果 + +```bash +# 示例：分析后实现 +# Step 1: Gemini 分析架构 +使用 gemini 分析认证模块的架构设计，识别关键组件和数据流 + +# Step 2: Codex 基于分析结果实现 +让 codex 根据上述架构分析，实现 JWT 认证中间件 +``` + +**执行流程**： +``` +Gemini 分析 → 输出架构报告 → Codex 读取报告 → 实现代码 +``` + +--- + +**2. 并行执行（Parallel Execution）** - 同时进行 + +适用场景：多个独立任务，无依赖关系 + +```bash +# 示例：多维度分析 +用 gemini 分析认证模块的安全性，关注 JWT、密码存储、会话管理 +用 qwen 分析认证模块的性能瓶颈，识别慢查询和优化点 +让 codex 为认证模块生成单元测试，覆盖所有核心功能 +``` + +**执行流程**： +``` + ┌─ Gemini: 安全分析 ─┐ +并行 ───┼─ Qwen: 性能分析 ──┼─→ 汇总结果 + └─ Codex: 测试生成 ─┘ +``` + +--- + +**3. 混合执行（Hybrid Execution）** - 串并结合 + +适用场景：复杂任务，部分并行、部分串联 + +```bash +# 示例：完整功能开发 +# Phase 1: 并行分析（独立任务） +使用 gemini 分析现有认证系统的架构模式 +用 qwen 评估 OAuth2 集成的技术方案 + +# Phase 2: 串联实现（依赖 Phase 1） +让 codex 基于上述分析，实现 OAuth2 认证流程 + +# Phase 3: 并行优化（独立任务） +用 gemini 审查代码质量和安全性 +让 codex 生成集成测试 +``` + +**执行流程**： +``` +Phase 1: Gemini 分析 ──┐ + Qwen 评估 ────┼─→ Phase 2: Codex 实现 ──→ Phase 3: Gemini 审查 ──┐ + │ Codex 测试 ──┼─→ 完成 + └────────────────────────────────────────────────┘ +``` + +--- + +#### 🎯 语义调用 vs 命令调用 + +**方式一：自然语言语义调用**（推荐） + +```bash +# 用户只需自然描述，Claude Code 自动调用工具 +"使用 gemini 分析这个模块的依赖关系" +→ Claude Code 自动生成：cd src && gemini -p "分析依赖关系" + +"让 codex 实现用户注册功能" +→ Claude Code 自动生成：codex -C src/auth --full-auto exec "实现注册" +``` + +**方式二：直接命令调用** + +```bash +# 通过 Slash 命令精准调用 +/cli:chat --tool gemini "解释这个算法" +/cli:analyze --tool qwen "分析性能瓶颈" +/cli:execute --tool codex "优化查询性能" +``` + +--- + +#### 🔄 工作流集成示例 + +**集成到 Lite 工作流**： + +```bash +# 1. 规划阶段：Gemini 分析 +/workflow:lite-plan -e "重构支付模块" +→ 三维确认选择 "CLI 工具执行" + +# 2. 执行阶段：选择执行方式 +# 选项 A: 串联执行 +→ "使用 gemini 分析支付流程" → "让 codex 重构代码" + +# 选项 B: 并行分析 + 串联实现 +→ "用 gemini 分析架构" + "用 qwen 评估方案" +→ "让 codex 基于分析结果重构" +``` + +**集成到 Full 工作流**： + +```bash +# 1. 规划阶段 +/workflow:plan "实现分布式缓存" +/workflow:action-plan-verify + +# 2. 分析阶段（并行） +使用 gemini 分析现有缓存架构 +用 qwen 评估 Redis 集群方案 + +# 3. 实现阶段（串联） +/workflow:execute # 或使用 CLI +让 codex 实现 Redis 集群集成 + +# 4. 测试阶段（并行） +/workflow:test-gen WFS-cache +→ 内部使用 gemini 分析 + codex 生成测试 + +# 5. 审查阶段（串联） +用 gemini 审查代码质量 +/workflow:review --type architecture +``` + +--- + +#### 💡 最佳实践 + +**何时使用串联**： +- 实现依赖设计方案 +- 测试依赖代码实现 +- 优化依赖性能分析 + +**何时使用并行**： +- 多维度分析（安全+性能+架构） +- 多模块独立开发 +- 同时生成代码和测试 + +**何时使用混合**： +- 复杂功能开发（分析→设计→实现→测试） +- 大规模重构（评估→规划→执行→验证） +- 技术栈迁移（调研→方案→实施→优化） + +**工具选择建议**： +1. **需要理解代码** → Gemini（首选）或 Qwen +2. **需要编写代码** → Codex +3. **复杂分析** → Gemini + Qwen 并行（互补验证） +4. **精确实现** → Codex（基于 Gemini 分析） +5. **快速原型** → 直接使用 Codex + +--- + ## 🔄 典型场景完整流程 ### 场景A：新功能开发（知道怎么做） diff --git a/WORKFLOW_DECISION_GUIDE_EN.md b/WORKFLOW_DECISION_GUIDE_EN.md index 93a2ba9d..5b1feea9 100644 --- a/WORKFLOW_DECISION_GUIDE_EN.md +++ b/WORKFLOW_DECISION_GUIDE_EN.md @@ -253,6 +253,180 @@ flowchart TD --- +### 7️⃣ **CLI Tools Collaboration Mode - Multi-Model Intelligent Coordination** + +This project integrates three CLI tools supporting flexible serial, parallel, and hybrid execution: + +| Tool | Core Capabilities | Context Length | Use Cases | +|------|------------------|----------------|-----------| +| **Gemini** | Deep analysis, architecture design, planning | Ultra-long context | Code understanding, execution flow tracing, technical solution evaluation | +| **Qwen** | Code review, pattern recognition | Ultra-long context | Gemini alternative, multi-dimensional analysis | +| **Codex** | Precise code writing, bug location | Standard context | Feature implementation, test generation, code refactoring | + +#### 📋 Three Execution Modes + +**1. Serial Execution** - Sequential dependency + +Use case: Subsequent tasks depend on previous results + +```bash +# Example: Analyze then implement +# Step 1: Gemini analyzes architecture +Use gemini to analyze the authentication module's architecture design, identify key components and data flow + +# Step 2: Codex implements based on analysis +Have codex implement JWT authentication middleware based on the above architecture analysis +``` + +**Execution flow**: +``` +Gemini analysis → Output architecture report → Codex reads report → Implement code +``` + +--- + +**2. Parallel Execution** - Concurrent processing + +Use case: Multiple independent tasks with no dependencies + +```bash +# Example: Multi-dimensional analysis +Use gemini to analyze authentication module security, focus on JWT, password storage, session management +Use qwen to analyze authentication module performance bottlenecks, identify slow queries and optimization points +Have codex generate unit tests for authentication module, covering all core features +``` + +**Execution flow**: +``` + ┌─ Gemini: Security analysis ─┐ +Parallel ┼─ Qwen: Performance analysis ┼─→ Aggregate results + └─ Codex: Test generation ────┘ +``` + +--- + +**3. Hybrid Execution** - Combined serial and parallel + +Use case: Complex tasks with both parallel and serial phases + +```bash +# Example: Complete feature development +# Phase 1: Parallel analysis (independent tasks) +Use gemini to analyze existing authentication system architecture patterns +Use qwen to evaluate OAuth2 integration technical solutions + +# Phase 2: Serial implementation (depends on Phase 1) +Have codex implement OAuth2 authentication flow based on above analysis + +# Phase 3: Parallel optimization (independent tasks) +Use gemini to review code quality and security +Have codex generate integration tests +``` + +**Execution flow**: +``` +Phase 1: Gemini analysis ──┐ + Qwen evaluation ──┼─→ Phase 2: Codex implementation ──→ Phase 3: Gemini review ──┐ + │ Codex tests ───┼─→ Complete + └──────────────────────────────────────────────────────────────┘ +``` + +--- + +#### 🎯 Semantic Invocation vs Command Invocation + +**Method 1: Natural Language Semantic Invocation** (Recommended) + +```bash +# Users simply describe naturally, Claude Code auto-invokes tools +"Use gemini to analyze this module's dependencies" +→ Claude Code auto-generates: cd src && gemini -p "Analyze dependencies" + +"Have codex implement user registration feature" +→ Claude Code auto-generates: codex -C src/auth --full-auto exec "Implement registration" +``` + +**Method 2: Direct Command Invocation** + +```bash +# Precise invocation via Slash commands +/cli:chat --tool gemini "Explain this algorithm" +/cli:analyze --tool qwen "Analyze performance bottlenecks" +/cli:execute --tool codex "Optimize query performance" +``` + +--- + +#### 🔄 Workflow Integration Examples + +**Integration with Lite Workflow**: + +```bash +# 1. Planning phase: Gemini analysis +/workflow:lite-plan -e "Refactor payment module" +→ Three-dimensional confirmation selects "CLI Tools execution" + +# 2. Execution phase: Choose execution method +# Option A: Serial execution +→ "Use gemini to analyze payment flow" → "Have codex refactor code" + +# Option B: Parallel analysis + Serial implementation +→ "Use gemini to analyze architecture" + "Use qwen to evaluate solution" +→ "Have codex refactor based on analysis results" +``` + +**Integration with Full Workflow**: + +```bash +# 1. Planning phase +/workflow:plan "Implement distributed cache" +/workflow:action-plan-verify + +# 2. Analysis phase (parallel) +Use gemini to analyze existing cache architecture +Use qwen to evaluate Redis cluster solution + +# 3. Implementation phase (serial) +/workflow:execute # Or use CLI +Have codex implement Redis cluster integration + +# 4. Testing phase (parallel) +/workflow:test-gen WFS-cache +→ Internally uses gemini analysis + codex test generation + +# 5. Review phase (serial) +Use gemini to review code quality +/workflow:review --type architecture +``` + +--- + +#### 💡 Best Practices + +**When to use serial**: +- Implementation depends on design solution +- Testing depends on code implementation +- Optimization depends on performance analysis + +**When to use parallel**: +- Multi-dimensional analysis (security + performance + architecture) +- Multi-module independent development +- Simultaneous code and test generation + +**When to use hybrid**: +- Complex feature development (analysis → design → implementation → testing) +- Large-scale refactoring (evaluation → planning → execution → verification) +- Tech stack migration (research → solution → implementation → optimization) + +**Tool selection guidelines**: +1. **Need to understand code** → Gemini (preferred) or Qwen +2. **Need to write code** → Codex +3. **Complex analysis** → Gemini + Qwen parallel (complementary verification) +4. **Precise implementation** → Codex (based on Gemini analysis) +5. **Quick prototype** → Direct Codex usage + +--- + ## 🔄 Complete Flow for Typical Scenarios ### Scenario A: New Feature Development (Know How to Build) From c34a6042c0453f189afea8e765fe2246c1229f20 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 20 Nov 2025 09:53:21 +0000 Subject: [PATCH 2/2] docs: add CLI results as memory/context section Add comprehensive explanation of how CLI tool results can be saved and reused as context for subsequent operations: - Result persistence in workflow sessions (.chat/ directory) - Using analysis results as planning basis - Using analysis results as implementation basis - Cross-session references - Memory update loops with iterative optimization - Visual memory flow diagram showing phase-to-phase context passing - Best practices for maintaining continuity and quality This enables intelligent workflows where Gemini/Qwen analysis informs Codex implementation, and all results accumulate as project memory for future decision-making. Integrates with /workflow:plan and /workflow:lite-plan commands. --- WORKFLOW_DECISION_GUIDE.md | 120 ++++++++++++++++++++++++++++++++++ WORKFLOW_DECISION_GUIDE_EN.md | 120 ++++++++++++++++++++++++++++++++++ 2 files changed, 240 insertions(+) diff --git a/WORKFLOW_DECISION_GUIDE.md b/WORKFLOW_DECISION_GUIDE.md index 92f02d26..a42224af 100644 --- a/WORKFLOW_DECISION_GUIDE.md +++ b/WORKFLOW_DECISION_GUIDE.md @@ -357,6 +357,126 @@ Phase 1: Gemini 分析 ──┐ --- +#### 🔗 CLI 结果作为上下文（Memory） + +CLI 工具的分析结果可以被保存并作为后续操作的上下文（memory），实现智能化的工作流程： + +**1. 结果持久化** + +```bash +# CLI 执行结果自动保存到会话目录 +/cli:chat --tool gemini "分析认证模块架构" +→ 保存到：.workflow/active/WFS-xxx/.chat/chat-[timestamp].md + +/cli:analyze --tool qwen "评估性能瓶颈" +→ 保存到：.workflow/active/WFS-xxx/.chat/analyze-[timestamp].md + +/cli:execute --tool codex "实现功能" +→ 保存到：.workflow/active/WFS-xxx/.chat/execute-[timestamp].md +``` + +**2. 结果作为规划依据** + +```bash +# Step 1: 分析现状（生成 memory） +使用 gemini 深度分析认证系统的架构、安全性和性能问题 +→ 输出：详细分析报告（自动保存） + +# Step 2: 基于分析结果规划 +/workflow:plan "根据上述 Gemini 分析报告重构认证系统" +→ 系统自动读取 .chat/ 中的分析报告作为上下文 +→ 生成精准的实施计划 +``` + +**3. 结果作为实现依据** + +```bash +# Step 1: 并行分析（生成多个 memory） +使用 gemini 分析现有代码结构 +用 qwen 评估技术方案可行性 +→ 输出：多份分析报告 + +# Step 2: 基于所有分析结果实现 +让 codex 综合上述 Gemini 和 Qwen 的分析，实现最优方案 +→ Codex 自动读取前序分析结果 +→ 生成符合架构设计的代码 +``` + +**4. 跨会话引用** + +```bash +# 引用历史会话的分析结果 +/cli:execute --tool codex "参考 WFS-2024-001 中的架构分析，实现新的支付模块" +→ 系统自动加载指定会话的上下文 +→ 基于历史分析进行实现 +``` + +**5. Memory 更新循环** + +```bash +# 迭代优化流程 +使用 gemini 分析当前实现的问题 +→ 生成问题报告（memory） + +让 codex 根据问题报告优化代码 +→ 实现改进（更新 memory） + +用 qwen 验证优化效果 +→ 验证报告（追加 memory） + +# 所有结果累积为完整的项目 memory +→ 支持后续决策和实现 +``` + +**Memory 流转示例**： + +``` +┌─────────────────────────────────────────────────────────────┐ +│ Phase 1: 分析阶段（生成 Memory） │ +├─────────────────────────────────────────────────────────────┤ +│ Gemini 分析 → 架构分析报告 (.chat/analyze-001.md) │ +│ Qwen 评估 → 方案评估报告 (.chat/analyze-002.md) │ +└─────────────────────┬───────────────────────────────────────┘ + │ 作为 Memory 输入 + ↓ +┌─────────────────────────────────────────────────────────────┐ +│ Phase 2: 规划阶段（使用 Memory） │ +├─────────────────────────────────────────────────────────────┤ +│ /workflow:plan → 读取分析报告 → 生成实施计划 │ +│ (.task/IMPL-*.json) │ +└─────────────────────┬───────────────────────────────────────┘ + │ 作为 Memory 输入 + ↓ +┌─────────────────────────────────────────────────────────────┐ +│ Phase 3: 实现阶段（使用 Memory） │ +├─────────────────────────────────────────────────────────────┤ +│ Codex 实现 → 读取计划+分析 → 生成代码 │ +│ (.chat/execute-001.md) │ +└─────────────────────┬───────────────────────────────────────┘ + │ 作为 Memory 输入 + ↓ +┌─────────────────────────────────────────────────────────────┐ +│ Phase 4: 验证阶段（使用 Memory） │ +├─────────────────────────────────────────────────────────────┤ +│ Gemini 审查 → 读取实现代码 → 质量报告 │ +│ (.chat/review-001.md) │ +└─────────────────────────────────────────────────────────────┘ + │ + ↓ + 完整的项目 Memory 库 + 支持未来所有决策和实现 +``` + +**最佳实践**： + +1. **保持连续性**：在同一会话中执行相关任务，自动共享 memory +2. **显式引用**：跨会话时明确引用历史分析（如"参考 WFS-xxx 的分析"） +3. **增量更新**：每次分析和实现都追加到 memory，形成完整的决策链 +4. **定期整理**：使用 `/memory:update-related` 将 CLI 结果整合到 CLAUDE.md +5. **质量优先**：高质量的分析 memory 能显著提升后续实现质量 + +--- + #### 🔄 工作流集成示例 **集成到 Lite 工作流**： diff --git a/WORKFLOW_DECISION_GUIDE_EN.md b/WORKFLOW_DECISION_GUIDE_EN.md index 5b1feea9..91772f06 100644 --- a/WORKFLOW_DECISION_GUIDE_EN.md +++ b/WORKFLOW_DECISION_GUIDE_EN.md @@ -357,6 +357,126 @@ Phase 1: Gemini analysis ──┐ --- +#### 🔗 CLI Results as Context (Memory) + +CLI tool analysis results can be saved and used as context (memory) for subsequent operations, enabling intelligent workflows: + +**1. Result Persistence** + +```bash +# CLI execution results automatically saved to session directory +/cli:chat --tool gemini "Analyze authentication module architecture" +→ Saved to: .workflow/active/WFS-xxx/.chat/chat-[timestamp].md + +/cli:analyze --tool qwen "Evaluate performance bottlenecks" +→ Saved to: .workflow/active/WFS-xxx/.chat/analyze-[timestamp].md + +/cli:execute --tool codex "Implement feature" +→ Saved to: .workflow/active/WFS-xxx/.chat/execute-[timestamp].md +``` + +**2. Results as Planning Basis** + +```bash +# Step 1: Analyze current state (generate memory) +Use gemini to deeply analyze authentication system architecture, security, and performance issues +→ Output: Detailed analysis report (auto-saved) + +# Step 2: Plan based on analysis results +/workflow:plan "Refactor authentication system based on above Gemini analysis report" +→ System automatically reads analysis reports from .chat/ as context +→ Generate precise implementation plan +``` + +**3. Results as Implementation Basis** + +```bash +# Step 1: Parallel analysis (generate multiple memories) +Use gemini to analyze existing code structure +Use qwen to evaluate technical solution feasibility +→ Output: Multiple analysis reports + +# Step 2: Implement based on all analysis results +Have codex synthesize above Gemini and Qwen analyses to implement optimal solution +→ Codex automatically reads prior analysis results +→ Generate code conforming to architecture design +``` + +**4. Cross-Session References** + +```bash +# Reference historical session analysis results +/cli:execute --tool codex "Refer to architecture analysis in WFS-2024-001, implement new payment module" +→ System automatically loads specified session context +→ Implement based on historical analysis +``` + +**5. Memory Update Loop** + +```bash +# Iterative optimization flow +Use gemini to analyze problems in current implementation +→ Generate problem report (memory) + +Have codex optimize code based on problem report +→ Implement improvements (update memory) + +Use qwen to verify optimization effectiveness +→ Verification report (append to memory) + +# All results accumulate as complete project memory +→ Support subsequent decisions and implementation +``` + +**Memory Flow Example**: + +``` +┌─────────────────────────────────────────────────────────────┐ +│ Phase 1: Analysis Phase (Generate Memory) │ +├─────────────────────────────────────────────────────────────┤ +│ Gemini analysis → Architecture report (.chat/analyze-001.md)│ +│ Qwen evaluation → Solution report (.chat/analyze-002.md) │ +└─────────────────────┬───────────────────────────────────────┘ + │ As Memory Input + ↓ +┌─────────────────────────────────────────────────────────────┐ +│ Phase 2: Planning Phase (Use Memory) │ +├─────────────────────────────────────────────────────────────┤ +│ /workflow:plan → Read analysis reports → Generate plan │ +│ (.task/IMPL-*.json) │ +└─────────────────────┬───────────────────────────────────────┘ + │ As Memory Input + ↓ +┌─────────────────────────────────────────────────────────────┐ +│ Phase 3: Implementation Phase (Use Memory) │ +├─────────────────────────────────────────────────────────────┤ +│ Codex implement → Read plan+analysis → Generate code │ +│ (.chat/execute-001.md) │ +└─────────────────────┬───────────────────────────────────────┘ + │ As Memory Input + ↓ +┌─────────────────────────────────────────────────────────────┐ +│ Phase 4: Verification Phase (Use Memory) │ +├─────────────────────────────────────────────────────────────┤ +│ Gemini review → Read implementation code → Quality report│ +│ (.chat/review-001.md) │ +└─────────────────────────────────────────────────────────────┘ + │ + ↓ + Complete Project Memory Library + Supporting All Future Decisions and Implementation +``` + +**Best Practices**: + +1. **Maintain Continuity**: Execute related tasks in the same session to automatically share memory +2. **Explicit References**: Explicitly reference historical analyses when crossing sessions (e.g., "Refer to WFS-xxx analysis") +3. **Incremental Updates**: Each analysis and implementation appends to memory, forming complete decision chain +4. **Regular Organization**: Use `/memory:update-related` to consolidate CLI results into CLAUDE.md +5. **Quality First**: High-quality analysis memory significantly improves subsequent implementation quality + +--- + #### 🔄 Workflow Integration Examples **Integration with Lite Workflow**: