mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-11 02:33:51 +08:00
feat: 增强 command-guide skill 支持深度命令分析和 CLI 辅助查询
新增 Mode 6: 深度命令分析 - 创建 reference 备份目录（80个文档：11 agents + 69 commands） - 支持简单查询（直接文件查找）和复杂查询（CLI 辅助分析） - 集成 gemini/qwen 进行跨命令对比、最佳实践、工作流分析 - 添加查询复杂度自动分类和降级策略 更新文档 - SKILL.md: 添加 Mode 6 说明和 Reference Documentation 章节 - implementation-details.md: 添加完整的 Mode 6 实现逻辑 - 版本更新至 v1.3.0 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
catlog22
136
.claude/skills/command-guide/reference/commands/cli/analyze.md
Normal file
136
.claude/skills/command-guide/reference/commands/cli/analyze.md
Normal file
@@ -0,0 +1,136 @@
|
||||
---
|
||||
name: analyze
|
||||
description: Read-only codebase analysis using Gemini (default), Qwen, or Codex with auto-pattern detection and template selection
|
||||
argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] analysis target"
|
||||
allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Analyze Command (/cli:analyze)
|
||||
|
||||
## Purpose
|
||||
|
||||
Quick codebase analysis using CLI tools. **Read-only - does NOT modify code**.
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for code analysis
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for deep analysis
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--agent` - Use cli-execution-agent for automated context discovery
|
||||
- `--enhance` - Use `/enhance-prompt` for context-aware enhancement
|
||||
- `<analysis-target>` - Description of what to analyze
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
--tool gemini # or omit (default)
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Standard Mode
|
||||
1. Parse tool selection (default: gemini)
|
||||
2. Optional: enhance with `/enhance-prompt`
|
||||
3. Auto-detect file patterns from keywords
|
||||
4. Build command with analysis template
|
||||
5. Execute analysis (read-only)
|
||||
6. Save results
|
||||
|
||||
### Agent Mode (`--agent`)
|
||||
|
||||
Delegates to agent for intelligent analysis:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Codebase analysis",
|
||||
prompt=`
|
||||
Task: ${analysis_target}
|
||||
Mode: analyze
|
||||
Tool: ${tool_flag || 'auto-select'} // gemini|qwen|codex
|
||||
Enhance: ${enhance_flag || false}
|
||||
|
||||
Agent responsibilities:
|
||||
1. Context Discovery:
|
||||
- Discover relevant files/patterns
|
||||
- Identify analysis scope
|
||||
- Build file context
|
||||
|
||||
2. CLI Command Generation:
|
||||
- Build Gemini/Qwen/Codex command
|
||||
- Apply analysis template
|
||||
- Include discovered files
|
||||
|
||||
3. Execution & Output:
|
||||
- Execute analysis
|
||||
- Generate insights report
|
||||
- Save to .workflow/.chat/ or .scratchpad/
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Analyzes code, does NOT modify files
|
||||
- **Auto-pattern**: Detects file patterns from keywords
|
||||
- **Template-based**: Auto-selects analysis template
|
||||
- **Output**: Saves to `.workflow/WFS-[id]/.chat/` or `.scratchpad/`
|
||||
|
||||
## File Pattern Auto-Detection
|
||||
|
||||
Keywords → file patterns:
|
||||
- "auth" → `@**/*auth* @**/*user*`
|
||||
- "component" → `@src/components/**/*`
|
||||
- "API" → `@**/api/**/* @**/routes/**/*`
|
||||
- "test" → `@**/*.test.* @**/*.spec.*`
|
||||
- Generic → `@src/**/*`
|
||||
|
||||
## CLI Command Templates
|
||||
|
||||
**Gemini/Qwen**:
|
||||
```bash
|
||||
cd . && gemini -p "
|
||||
PURPOSE: [goal]
|
||||
TASK: [analysis type]
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [auto-detected patterns]
|
||||
EXPECTED: Insights, recommendations
|
||||
RULES: [auto-selected template]
|
||||
"
|
||||
# Qwen: Replace 'gemini' with 'qwen'
|
||||
```
|
||||
|
||||
**Codex**:
|
||||
```bash
|
||||
codex -C . --full-auto exec "
|
||||
PURPOSE: [goal]
|
||||
TASK: [analysis type]
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [patterns]
|
||||
EXPECTED: Deep insights
|
||||
RULES: [template]
|
||||
" -m gpt-5 --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Output
|
||||
|
||||
- **With session**: `.workflow/WFS-[id]/.chat/analyze-[timestamp].md`
|
||||
- **No session**: `.workflow/.scratchpad/analyze-[desc]-[timestamp].md`
|
||||
|
||||
## Notes
|
||||
|
||||
- See `intelligent-tools-strategy.md` for detailed tool usage and templates
|
||||
125
.claude/skills/command-guide/reference/commands/cli/chat.md
Normal file
125
.claude/skills/command-guide/reference/commands/cli/chat.md
Normal file
@@ -0,0 +1,125 @@
|
||||
---
|
||||
name: chat
|
||||
description: Read-only Q&A interaction with Gemini/Qwen/Codex for codebase questions with automatic context inference
|
||||
argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] inquiry"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Chat Command (/cli:chat)
|
||||
|
||||
## Purpose
|
||||
|
||||
Direct Q&A interaction with CLI tools for codebase analysis. **Read-only - does NOT modify code**.
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for Q&A and explanations
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for technical deep-dives
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--agent` - Use cli-execution-agent for automated context discovery
|
||||
- `--enhance` - Enhance inquiry with `/enhance-prompt`
|
||||
- `<inquiry>` (Required) - Question or analysis request
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
--tool gemini # or omit (default)
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Standard Mode
|
||||
1. Parse tool selection (default: gemini)
|
||||
2. Optional: enhance with `/enhance-prompt`
|
||||
3. Assemble context: `@CLAUDE.md` + inferred files
|
||||
4. Execute Q&A (read-only)
|
||||
5. Return answer
|
||||
|
||||
### Agent Mode (`--agent`)
|
||||
|
||||
Delegates to agent for intelligent Q&A:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Codebase Q&A",
|
||||
prompt=`
|
||||
Task: ${inquiry}
|
||||
Mode: chat (Q&A)
|
||||
Tool: ${tool_flag || 'auto-select'} // gemini|qwen|codex
|
||||
Enhance: ${enhance_flag || false}
|
||||
|
||||
Agent responsibilities:
|
||||
1. Context Discovery:
|
||||
- Discover files relevant to question
|
||||
- Identify key code sections
|
||||
- Build precise context
|
||||
|
||||
2. CLI Command Generation:
|
||||
- Build Gemini/Qwen/Codex command
|
||||
- Include discovered context
|
||||
- Apply Q&A template
|
||||
|
||||
3. Execution & Output:
|
||||
- Execute Q&A analysis
|
||||
- Generate detailed answer
|
||||
- Save to .workflow/.chat/ or .scratchpad/
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Provides answers, does NOT modify code
|
||||
- **Context**: `@CLAUDE.md` + inferred or all files (`@**/*`)
|
||||
- **Output**: Saves to `.workflow/WFS-[id]/.chat/` or `.scratchpad/`
|
||||
|
||||
## CLI Command Templates
|
||||
|
||||
**Gemini/Qwen**:
|
||||
```bash
|
||||
cd . && gemini -p "
|
||||
PURPOSE: Answer question
|
||||
TASK: [inquiry]
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [inferred or @**/*]
|
||||
EXPECTED: Clear answer
|
||||
RULES: Focus on accuracy
|
||||
"
|
||||
# Qwen: Replace 'gemini' with 'qwen'
|
||||
```
|
||||
|
||||
**Codex**:
|
||||
```bash
|
||||
codex -C . --full-auto exec "
|
||||
PURPOSE: Answer question
|
||||
TASK: [inquiry]
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [inferred or @**/*]
|
||||
EXPECTED: Detailed answer
|
||||
RULES: Technical depth
|
||||
" -m gpt-5 --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Output
|
||||
|
||||
- **With session**: `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
|
||||
- **No session**: `.workflow/.scratchpad/chat-[desc]-[timestamp].md`
|
||||
|
||||
## Notes
|
||||
|
||||
- See `intelligent-tools-strategy.md` for detailed tool usage and templates
|
||||
449
.claude/skills/command-guide/reference/commands/cli/cli-init.md
Normal file
449
.claude/skills/command-guide/reference/commands/cli/cli-init.md
Normal file
@@ -0,0 +1,449 @@
|
||||
---
|
||||
name: cli-init
|
||||
description: Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection
|
||||
argument-hint: "[--tool gemini|qwen|all] [--output path] [--preview]"
|
||||
allowed-tools: Bash(*), Read(*), Write(*), Glob(*)
|
||||
---
|
||||
|
||||
# CLI Initialization Command (/cli:cli-init)
|
||||
|
||||
## Overview
|
||||
Initializes CLI tool configurations for the workspace by:
|
||||
1. Analyzing current workspace using `get_modules_by_depth.sh` to identify technology stacks
|
||||
2. Generating ignore files (`.geminiignore` and `.qwenignore`) with filtering rules optimized for detected technologies
|
||||
3. Creating configuration directories (`.gemini/` and `.qwen/`) with settings.json files
|
||||
|
||||
**Supported Tools**: gemini, qwen, all (default: all)
|
||||
|
||||
## Core Functionality
|
||||
|
||||
### Configuration Generation
|
||||
1. **Workspace Analysis**: Runs `get_modules_by_depth.sh` to analyze project structure
|
||||
2. **Technology Stack Detection**: Identifies tech stacks based on file extensions, directories, and configuration files
|
||||
3. **Config Creation**: Generates tool-specific configuration directories and settings files
|
||||
4. **Ignore Rules Generation**: Creates ignore files with filtering patterns for detected technologies
|
||||
|
||||
### Generated Files
|
||||
|
||||
#### Configuration Directories
|
||||
Creates tool-specific configuration directories:
|
||||
|
||||
**For Gemini** (`.gemini/`):
|
||||
- `.gemini/settings.json`:
|
||||
```json
|
||||
{
|
||||
"contextfilename": ["CLAUDE.md","GEMINI.md"]
|
||||
}
|
||||
```
|
||||
|
||||
**For Qwen** (`.qwen/`):
|
||||
- `.qwen/settings.json`:
|
||||
```json
|
||||
{
|
||||
"contextfilename": ["CLAUDE.md","QWEN.md"]
|
||||
}
|
||||
```
|
||||
|
||||
#### Ignore Files
|
||||
Uses gitignore syntax to filter files from CLI tool analysis:
|
||||
- `.geminiignore` - For Gemini CLI
|
||||
- `.qwenignore` - For Qwen CLI
|
||||
|
||||
Both files have identical content based on detected technologies.
|
||||
|
||||
### Supported Technology Stacks
|
||||
|
||||
#### Frontend Technologies
|
||||
- **React/Next.js**: Ignores build artifacts, .next/, node_modules
|
||||
- **Vue/Nuxt**: Ignores .nuxt/, dist/, .cache/
|
||||
- **Angular**: Ignores dist/, .angular/, node_modules
|
||||
- **Webpack/Vite**: Ignores build outputs, cache directories
|
||||
|
||||
#### Backend Technologies
|
||||
- **Node.js**: Ignores node_modules, package-lock.json, npm-debug.log
|
||||
- **Python**: Ignores __pycache__, .venv, *.pyc, .pytest_cache
|
||||
- **Java**: Ignores target/, .gradle/, *.class, .mvn/
|
||||
- **Go**: Ignores vendor/, *.exe, go.sum (when appropriate)
|
||||
- **C#/.NET**: Ignores bin/, obj/, *.dll, *.pdb
|
||||
|
||||
#### Database & Infrastructure
|
||||
- **Docker**: Ignores .dockerignore, docker-compose.override.yml
|
||||
- **Kubernetes**: Ignores *.secret.yaml, helm charts temp files
|
||||
- **Database**: Ignores *.db, *.sqlite, database dumps
|
||||
|
||||
### Generated Rules Structure
|
||||
|
||||
#### Base Rules (Always Included)
|
||||
```
|
||||
# Version Control
|
||||
.git/
|
||||
.svn/
|
||||
.hg/
|
||||
|
||||
# OS Files
|
||||
.DS_Store
|
||||
Thumbs.db
|
||||
*.tmp
|
||||
*.swp
|
||||
|
||||
# IDE Files
|
||||
.vscode/
|
||||
.idea/
|
||||
.vs/
|
||||
|
||||
# Logs
|
||||
*.log
|
||||
logs/
|
||||
```
|
||||
|
||||
#### Technology-Specific Rules
|
||||
Rules are added based on detected technologies:
|
||||
|
||||
**Node.js Projects** (package.json detected):
|
||||
```
|
||||
# Node.js
|
||||
node_modules/
|
||||
npm-debug.log*
|
||||
.npm/
|
||||
.yarn/
|
||||
package-lock.json
|
||||
yarn.lock
|
||||
.pnpm-store/
|
||||
```
|
||||
|
||||
**Python Projects** (requirements.txt, setup.py, pyproject.toml detected):
|
||||
```
|
||||
# Python
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
.venv/
|
||||
venv/
|
||||
.pytest_cache/
|
||||
.coverage
|
||||
htmlcov/
|
||||
```
|
||||
|
||||
**Java Projects** (pom.xml, build.gradle detected):
|
||||
```
|
||||
# Java
|
||||
target/
|
||||
.gradle/
|
||||
*.class
|
||||
*.jar
|
||||
*.war
|
||||
.mvn/
|
||||
```
|
||||
|
||||
## Command Options
|
||||
|
||||
### Tool Selection
|
||||
|
||||
**Initialize All Tools (default)**:
|
||||
```bash
|
||||
/cli:cli-init
|
||||
```
|
||||
- Creates `.gemini/`, `.qwen/` directories with settings.json
|
||||
- Creates `.geminiignore` and `.qwenignore` files
|
||||
- Sets contextfilename to "CLAUDE.md" for both
|
||||
|
||||
**Initialize Gemini Only**:
|
||||
```bash
|
||||
/cli:cli-init --tool gemini
|
||||
```
|
||||
- Creates only `.gemini/` directory and `.geminiignore` file
|
||||
|
||||
**Initialize Qwen Only**:
|
||||
```bash
|
||||
/cli:cli-init --tool qwen
|
||||
```
|
||||
- Creates only `.qwen/` directory and `.qwenignore` file
|
||||
|
||||
### Preview Mode
|
||||
```bash
|
||||
/cli:cli-init --preview
|
||||
```
|
||||
- Shows what would be generated without creating files
|
||||
- Displays detected technologies, configuration, and ignore rules
|
||||
|
||||
### Custom Output Path
|
||||
```bash
|
||||
/cli:cli-init --output=.config/
|
||||
```
|
||||
- Generates files in specified directory
|
||||
- Creates directories if they don't exist
|
||||
|
||||
### Combined Options
|
||||
```bash
|
||||
/cli:cli-init --tool qwen --preview
|
||||
/cli:cli-init --tool all --output=.config/
|
||||
```
|
||||
|
||||
## EXECUTION INSTRUCTIONS - START HERE
|
||||
|
||||
**When this command is triggered, follow these exact steps:**
|
||||
|
||||
### Step 1: Parse Tool Selection
|
||||
```bash
|
||||
# Extract --tool flag (default: all)
|
||||
# Options: gemini, qwen, all
|
||||
```
|
||||
|
||||
### Step 2: Workspace Analysis (MANDATORY FIRST)
|
||||
```bash
|
||||
# Analyze workspace structure
|
||||
bash(~/.claude/scripts/get_modules_by_depth.sh json)
|
||||
```
|
||||
|
||||
### Step 3: Technology Detection
|
||||
```bash
|
||||
# Check for common tech stack indicators
|
||||
bash(find . -name "package.json" -not -path "*/node_modules/*" | head -1)
|
||||
bash(find . -name "requirements.txt" -o -name "setup.py" -o -name "pyproject.toml" | head -1)
|
||||
bash(find . -name "pom.xml" -o -name "build.gradle" | head -1)
|
||||
bash(find . -name "Dockerfile" | head -1)
|
||||
```
|
||||
|
||||
### Step 4: Generate Configuration Files
|
||||
|
||||
**For Gemini** (if --tool is gemini or all):
|
||||
```bash
|
||||
# Create .gemini/ directory and settings.json
|
||||
mkdir -p .gemini
|
||||
Write({file_path: '.gemini/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
|
||||
|
||||
# Create .geminiignore file with detected technology rules
|
||||
# Backup existing files if present
|
||||
```
|
||||
|
||||
**For Qwen** (if --tool is qwen or all):
|
||||
```bash
|
||||
# Create .qwen/ directory and settings.json
|
||||
mkdir -p .qwen
|
||||
Write({file_path: '.qwen/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
|
||||
|
||||
# Create .qwenignore file with detected technology rules
|
||||
# Backup existing files if present
|
||||
```
|
||||
|
||||
### Step 5: Validation
|
||||
```bash
|
||||
# Verify generated files are valid
|
||||
bash(ls -la .gemini* .qwen* 2>/dev/null || echo "Configuration files created")
|
||||
```
|
||||
|
||||
## Implementation Process (Technical Details)
|
||||
|
||||
### Phase 1: Tool Selection
|
||||
1. Parse `--tool` flag from command arguments
|
||||
2. Determine which configurations to generate:
|
||||
- `gemini`: Generate .gemini/ and .geminiignore only
|
||||
- `qwen`: Generate .qwen/ and .qwenignore only
|
||||
- `all` (default): Generate both sets of files
|
||||
|
||||
### Phase 2: Workspace Analysis
|
||||
1. Execute `get_modules_by_depth.sh json` to get structured project data
|
||||
2. Parse JSON output to identify directories and files
|
||||
3. Scan for technology indicators:
|
||||
- Configuration files (package.json, requirements.txt, etc.)
|
||||
- Directory patterns (src/, tests/, etc.)
|
||||
- File extensions (.js, .py, .java, etc.)
|
||||
4. Detect project name from directory name or package.json
|
||||
|
||||
### Phase 3: Technology Detection
|
||||
```bash
|
||||
# Technology detection logic
|
||||
detect_nodejs() {
|
||||
[ -f "package.json" ] || find . -name "package.json" -not -path "*/node_modules/*" | head -1
|
||||
}
|
||||
|
||||
detect_python() {
|
||||
[ -f "requirements.txt" ] || [ -f "setup.py" ] || [ -f "pyproject.toml" ] || \
|
||||
find . -name "*.py" -not -path "*/__pycache__/*" | head -1
|
||||
}
|
||||
|
||||
detect_java() {
|
||||
[ -f "pom.xml" ] || [ -f "build.gradle" ] || \
|
||||
find . -name "*.java" | head -1
|
||||
}
|
||||
```
|
||||
|
||||
### Phase 4: Configuration Generation
|
||||
**For each selected tool**, create:
|
||||
|
||||
1. **Config Directory**:
|
||||
- Create `.gemini/` or `.qwen/` directory if it doesn't exist
|
||||
- Generate `settings.json` with contextfilename setting
|
||||
- Set contextfilename to "CLAUDE.md" by default
|
||||
|
||||
2. **Settings.json Format** (identical for both tools):
|
||||
```json
|
||||
{
|
||||
"contextfilename": "CLAUDE.md"
|
||||
}
|
||||
```
|
||||
|
||||
### Phase 5: Ignore Rules Generation
|
||||
1. Start with base rules (always included)
|
||||
2. Add technology-specific rules based on detection
|
||||
3. Add workspace-specific patterns if found
|
||||
4. Sort and deduplicate rules
|
||||
5. Generate identical content for both `.geminiignore` and `.qwenignore`
|
||||
|
||||
### Phase 6: File Creation
|
||||
1. **Generate config directories**: Create `.gemini/` and/or `.qwen/` directories with settings.json
|
||||
2. **Generate ignore files**: Create organized ignore files with sections
|
||||
3. **Create backups**: Backup existing files if present
|
||||
4. **Validate**: Check generated files are valid
|
||||
|
||||
## Generated File Format
|
||||
|
||||
### Configuration Files
|
||||
```json
|
||||
// .gemini/settings.json or .qwen/settings.json
|
||||
{
|
||||
"contextfilename": "CLAUDE.md"
|
||||
}
|
||||
```
|
||||
|
||||
### Ignore Files
|
||||
```
|
||||
# .geminiignore / .qwenignore
|
||||
# Generated by Claude Code /cli:cli-init command
|
||||
# Creation date: 2024-01-15 10:30:00
|
||||
# Detected technologies: Node.js, Python, Docker
|
||||
#
|
||||
# This file uses gitignore syntax to filter files for CLI tool analysis
|
||||
# Edit this file to customize filtering rules for your project
|
||||
|
||||
# ============================================================================
|
||||
# Base Rules (Always Applied)
|
||||
# ============================================================================
|
||||
|
||||
# Version Control
|
||||
.git/
|
||||
.svn/
|
||||
.hg/
|
||||
|
||||
# ============================================================================
|
||||
# Node.js (Detected: package.json found)
|
||||
# ============================================================================
|
||||
|
||||
node_modules/
|
||||
npm-debug.log*
|
||||
.npm/
|
||||
yarn-error.log
|
||||
package-lock.json
|
||||
|
||||
# ============================================================================
|
||||
# Python (Detected: requirements.txt, *.py files found)
|
||||
# ============================================================================
|
||||
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
.venv/
|
||||
.pytest_cache/
|
||||
.coverage
|
||||
|
||||
# ============================================================================
|
||||
# Docker (Detected: Dockerfile found)
|
||||
# ============================================================================
|
||||
|
||||
.dockerignore
|
||||
docker-compose.override.yml
|
||||
|
||||
# ============================================================================
|
||||
# Custom Rules (Add your project-specific rules below)
|
||||
# ============================================================================
|
||||
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
### Missing Dependencies
|
||||
- If `get_modules_by_depth.sh` not found, show error with path to script
|
||||
- Gracefully handle cases where script fails
|
||||
|
||||
### Write Permissions
|
||||
- Check write permissions before attempting file creation
|
||||
- Show clear error message if cannot write to target location
|
||||
|
||||
### Backup Existing Files
|
||||
- If `.gemini/` directory exists, create backup as `.gemini.backup/`
|
||||
- If `.qwen/` directory exists, create backup as `.qwen.backup/`
|
||||
- If `.geminiignore` exists, create backup as `.geminiignore.backup`
|
||||
- If `.qwenignore` exists, create backup as `.qwenignore.backup`
|
||||
- Include timestamp in backup filename
|
||||
|
||||
## Integration Points
|
||||
|
||||
### Workflow Commands
|
||||
- **After `/cli:plan`**: Suggest running cli-init for better analysis
|
||||
- **Before analysis**: Recommend updating ignore patterns for cleaner results
|
||||
|
||||
### CLI Tool Integration
|
||||
- Automatically update when new technologies detected
|
||||
- Integrate with `intelligent-tools-strategy.md` recommendations
|
||||
|
||||
## Usage Examples
|
||||
|
||||
### Basic Project Setup
|
||||
```bash
|
||||
# Initialize all CLI tools (Gemini + Qwen)
|
||||
/cli:cli-init
|
||||
|
||||
# Initialize only Gemini
|
||||
/cli:cli-init --tool gemini
|
||||
|
||||
# Initialize only Qwen
|
||||
/cli:cli-init --tool qwen
|
||||
|
||||
# Preview what would be generated
|
||||
/cli:cli-init --preview
|
||||
|
||||
# Generate in subdirectory
|
||||
/cli:cli-init --output=.config/
|
||||
```
|
||||
|
||||
### Technology Migration
|
||||
```bash
|
||||
# After adding new tech stack (e.g., Docker)
|
||||
/cli:cli-init # Regenerates all config and ignore files with new rules
|
||||
|
||||
# Check what changed
|
||||
/cli:cli-init --preview # Compare with existing configuration
|
||||
|
||||
# Update only Qwen configuration
|
||||
/cli:cli-init --tool qwen
|
||||
```
|
||||
|
||||
### Tool-Specific Initialization
|
||||
```bash
|
||||
# Setup for Gemini-only workflow
|
||||
/cli:cli-init --tool gemini
|
||||
|
||||
# Setup for Qwen-only workflow
|
||||
/cli:cli-init --tool qwen
|
||||
|
||||
# Setup both with preview
|
||||
/cli:cli-init --tool all --preview
|
||||
```
|
||||
|
||||
## Key Benefits
|
||||
|
||||
- **Automatic Detection**: No manual configuration needed
|
||||
- **Multi-Tool Support**: Configure Gemini and Qwen simultaneously
|
||||
- **Technology Aware**: Rules adapted to actual project stack
|
||||
- **Maintainable**: Clear sections for easy customization
|
||||
- **Consistent**: Follows gitignore syntax standards
|
||||
- **Safe**: Creates backups of existing files
|
||||
- **Flexible**: Initialize specific tools or all at once
|
||||
|
||||
## Tool Selection Guide
|
||||
|
||||
| Scenario | Command | Result |
|
||||
|----------|---------|--------|
|
||||
| **New project, using both tools** | `/cli:cli-init` | Creates .gemini/, .qwen/, .geminiignore, .qwenignore |
|
||||
| **Gemini-only workflow** | `/cli:cli-init --tool gemini` | Creates .gemini/ and .geminiignore only |
|
||||
| **Qwen-only workflow** | `/cli:cli-init --tool qwen` | Creates .qwen/ and .qwenignore only |
|
||||
| **Preview before commit** | `/cli:cli-init --preview` | Shows what would be generated |
|
||||
| **Update configurations** | `/cli:cli-init` | Regenerates all files with backups |
|
||||
@@ -0,0 +1,519 @@
|
||||
---
|
||||
name: codex-execute
|
||||
description: Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity
|
||||
argument-hint: "[--verify-git] task description or task-id"
|
||||
allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
|
||||
---
|
||||
|
||||
# CLI Codex Execute Command (/cli:codex-execute)
|
||||
|
||||
## Purpose
|
||||
|
||||
Automated task decomposition and sequential execution with Codex, using `codex exec "..." resume --last` mechanism for continuity between subtasks.
|
||||
|
||||
**Input**: User description or task ID (automatically loads from `.task/[ID].json` if applicable)
|
||||
|
||||
## Core Workflow
|
||||
|
||||
```
|
||||
Task Input → Analyze Dependencies → Create Task Flow Diagram →
|
||||
Decompose into Subtask Groups → TodoWrite Tracking →
|
||||
For Each Subtask Group:
|
||||
For First Subtask in Group:
|
||||
0. Stage existing changes (git add -A) if valid git repo
|
||||
1. Execute with Codex (new session)
|
||||
2. [Optional] Git verification
|
||||
3. Mark complete in TodoWrite
|
||||
For Related Subtasks in Same Group:
|
||||
0. Stage changes from previous subtask
|
||||
1. Execute with `codex exec "..." resume --last` (continue session)
|
||||
2. [Optional] Git verification
|
||||
3. Mark complete in TodoWrite
|
||||
→ Final Summary
|
||||
```
|
||||
|
||||
## Parameters
|
||||
|
||||
- `<input>` (Required): Task description or task ID (e.g., "implement auth" or "IMPL-001")
|
||||
- If input matches task ID format, loads from `.task/[ID].json`
|
||||
- Otherwise, uses input as task description
|
||||
- `--verify-git` (Optional): Verify git status after each subtask completion
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Phase 1: Input Processing & Task Flow Analysis
|
||||
|
||||
1. **Parse Input**:
|
||||
- Check if input matches task ID pattern (e.g., `IMPL-001`, `TASK-123`)
|
||||
- If yes: Load from `.task/[ID].json` and extract requirements
|
||||
- If no: Use input as task description directly
|
||||
|
||||
2. **Analyze Dependencies & Create Task Flow Diagram**:
|
||||
- Analyze task complexity and scope
|
||||
- Identify dependencies and relationships between subtasks
|
||||
- Create visual task flow diagram showing:
|
||||
- Independent task groups (parallel execution possible)
|
||||
- Sequential dependencies (must use resume)
|
||||
- Branching logic (conditional paths)
|
||||
- Display flow diagram for user review
|
||||
|
||||
**Task Flow Diagram Format**:
|
||||
```
|
||||
[Group A: Auth Core]
|
||||
A1: Create user model ──┐
|
||||
A2: Add validation ─┤─► [resume] ─► A3: Database schema
|
||||
│
|
||||
[Group B: API Layer] │
|
||||
B1: Auth endpoints ─────┘─► [new session]
|
||||
B2: Middleware ────────────► [resume] ─► B3: Error handling
|
||||
|
||||
[Group C: Testing]
|
||||
C1: Unit tests ─────────────► [new session]
|
||||
C2: Integration tests ──────► [resume]
|
||||
```
|
||||
|
||||
**Diagram Symbols**:
|
||||
- `──►` Sequential dependency (must resume previous session)
|
||||
- `─┐` Branch point (multiple paths)
|
||||
- `─┘` Merge point (wait for completion)
|
||||
- `[resume]` Use `codex exec "..." resume --last`
|
||||
- `[new session]` Start fresh Codex session
|
||||
|
||||
3. **Decompose into Subtask Groups**:
|
||||
- Group related subtasks that share context
|
||||
- Break down into 3-8 subtasks total
|
||||
- Assign each subtask to a group
|
||||
- Create TodoWrite tracker with groups
|
||||
- Display decomposition for user review
|
||||
|
||||
**Decomposition Criteria**:
|
||||
- Each subtask: 5-15 minutes completable
|
||||
- Clear, testable outcomes
|
||||
- Explicit dependencies
|
||||
- Focused file scope (1-5 files per subtask)
|
||||
- **Group coherence**: Subtasks in same group share context/files
|
||||
|
||||
### File Discovery for Task Decomposition
|
||||
|
||||
Use `rg` or MCP tools to discover relevant files, then group by domain:
|
||||
|
||||
**Workflow**: Discover → Analyze scope → Group by files → Create task flow
|
||||
|
||||
**Example**:
|
||||
```bash
|
||||
# Discover files
|
||||
rg "authentication" --files-with-matches --type ts
|
||||
|
||||
# Group by domain
|
||||
# Group A: src/auth/model.ts, src/auth/schema.ts
|
||||
# Group B: src/api/auth.ts, src/middleware/auth.ts
|
||||
# Group C: tests/auth/*.test.ts
|
||||
|
||||
# Each group becomes a session with related subtasks
|
||||
```
|
||||
|
||||
File patterns: see intelligent-tools-strategy.md (loaded in memory)
|
||||
|
||||
### Phase 2: Group-Based Execution
|
||||
|
||||
**Pre-Execution Git Staging** (if valid git repository):
|
||||
```bash
|
||||
# Stage all current changes before codex execution
|
||||
# This makes codex changes clearly visible in git diff
|
||||
git add -A
|
||||
git status --short
|
||||
```
|
||||
|
||||
**For First Subtask in Each Group** (New Session):
|
||||
```bash
|
||||
# Start new Codex session for independent task group
|
||||
codex -C [dir] --full-auto exec "
|
||||
PURPOSE: [group goal]
|
||||
TASK: [subtask description - first in group]
|
||||
CONTEXT: @{relevant_files} @CLAUDE.md
|
||||
EXPECTED: [specific deliverables]
|
||||
RULES: [constraints]
|
||||
Group [X]: [group name] - Subtask 1 of N in this group
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
**For Related Subtasks in Same Group** (Resume Session):
|
||||
```bash
|
||||
# Stage changes from previous subtask (if valid git repository)
|
||||
git add -A
|
||||
|
||||
# Resume session ONLY for subtasks in same group
|
||||
codex exec "
|
||||
CONTINUE IN SAME GROUP:
|
||||
Group [X]: [group name] - Subtask N of M
|
||||
|
||||
PURPOSE: [continuation goal within group]
|
||||
TASK: [subtask N description]
|
||||
CONTEXT: Previous work in this group completed, now focus on @{new_relevant_files}
|
||||
EXPECTED: [specific deliverables]
|
||||
RULES: Build on previous subtask in group, maintain consistency
|
||||
" resume --last --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
**For First Subtask in Different Group** (New Session):
|
||||
```bash
|
||||
# Stage changes from previous group
|
||||
git add -A
|
||||
|
||||
# Start NEW session for different group (no resume)
|
||||
codex -C [dir] --full-auto exec "
|
||||
PURPOSE: [new group goal]
|
||||
TASK: [subtask description - first in new group]
|
||||
CONTEXT: @{different_files} @CLAUDE.md
|
||||
EXPECTED: [specific deliverables]
|
||||
RULES: [constraints]
|
||||
Group [Y]: [new group name] - Subtask 1 of N in this group
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
**Resume Decision Logic**:
|
||||
```
|
||||
if (subtask.group == previous_subtask.group):
|
||||
use `codex exec "..." resume --last` # Continue session
|
||||
else:
|
||||
use `codex -C [dir] exec "..."` # New session
|
||||
```
|
||||
|
||||
### Phase 3: Verification (if --verify-git enabled)
|
||||
|
||||
After each subtask completion:
|
||||
```bash
|
||||
# Check git status
|
||||
git status --short
|
||||
|
||||
# Verify expected changes
|
||||
git diff --stat
|
||||
|
||||
# Optional: Check for untracked files that should be committed
|
||||
git ls-files --others --exclude-standard
|
||||
```
|
||||
|
||||
**Verification Checks**:
|
||||
- Files modified match subtask scope
|
||||
- No unexpected changes in unrelated files
|
||||
- No merge conflicts or errors
|
||||
- Code compiles/runs (if applicable)
|
||||
|
||||
### Phase 4: TodoWrite Tracking with Groups
|
||||
|
||||
**Initial Setup with Task Flow**:
|
||||
```javascript
|
||||
TodoWrite({
|
||||
todos: [
|
||||
// Display task flow diagram first
|
||||
{ content: "Task Flow Analysis Complete - See diagram above", status: "completed", activeForm: "Analyzing task flow" },
|
||||
|
||||
// Group A subtasks (will use resume within group)
|
||||
{ content: "[Group A] Subtask 1: [description]", status: "in_progress", activeForm: "Executing Group A subtask 1" },
|
||||
{ content: "[Group A] Subtask 2: [description] [resume]", status: "pending", activeForm: "Executing Group A subtask 2" },
|
||||
|
||||
// Group B subtasks (new session, then resume within group)
|
||||
{ content: "[Group B] Subtask 1: [description] [new session]", status: "pending", activeForm: "Executing Group B subtask 1" },
|
||||
{ content: "[Group B] Subtask 2: [description] [resume]", status: "pending", activeForm: "Executing Group B subtask 2" },
|
||||
|
||||
// Group C subtasks (new session)
|
||||
{ content: "[Group C] Subtask 1: [description] [new session]", status: "pending", activeForm: "Executing Group C subtask 1" },
|
||||
|
||||
{ content: "Final verification and summary", status: "pending", activeForm: "Verifying and summarizing" }
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
**After Each Subtask**:
|
||||
```javascript
|
||||
TodoWrite({
|
||||
todos: [
|
||||
{ content: "Task Flow Analysis Complete - See diagram above", status: "completed", activeForm: "Analyzing task flow" },
|
||||
{ content: "[Group A] Subtask 1: [description]", status: "completed", activeForm: "Executing Group A subtask 1" },
|
||||
{ content: "[Group A] Subtask 2: [description] [resume]", status: "in_progress", activeForm: "Executing Group A subtask 2" },
|
||||
// ... update status
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
## Codex Resume Mechanism
|
||||
|
||||
**Why Group-Based Resume?**
|
||||
- **Within Group**: Maintains conversation context for related subtasks
|
||||
- Codex remembers previous decisions and patterns
|
||||
- Reduces context repetition
|
||||
- Ensures consistency in implementation style
|
||||
- **Between Groups**: Fresh session for independent tasks
|
||||
- Avoids context pollution from unrelated work
|
||||
- Prevents confusion when switching domains
|
||||
- Maintains focused attention on current group
|
||||
|
||||
**How It Works**:
|
||||
1. **First subtask in Group A**: Creates new Codex session
|
||||
2. **Subsequent subtasks in Group A**: Use `codex resume --last` to continue session
|
||||
3. **First subtask in Group B**: Creates NEW Codex session (no resume)
|
||||
4. **Subsequent subtasks in Group B**: Use `codex resume --last` within Group B
|
||||
5. Each group builds on its own context, isolated from other groups
|
||||
|
||||
**When to Resume vs New Session**:
|
||||
```
|
||||
RESUME (same group):
|
||||
- Subtasks share files/modules
|
||||
- Logical continuation of previous work
|
||||
- Same architectural domain
|
||||
|
||||
NEW SESSION (different group):
|
||||
- Independent task area
|
||||
- Different files/modules
|
||||
- Switching architectural domains
|
||||
- Testing after implementation
|
||||
```
|
||||
|
||||
**Image Support**:
|
||||
```bash
|
||||
# First subtask with design reference
|
||||
codex -C [dir] -i design.png --full-auto exec "..." --skip-git-repo-check -s danger-full-access
|
||||
|
||||
# Resume for next subtask (image context preserved)
|
||||
codex exec "CONTINUE TO NEXT SUBTASK: ..." resume --last --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
**Subtask Failure**:
|
||||
1. Mark subtask as blocked in TodoWrite
|
||||
2. Report error details to user
|
||||
3. Pause execution for manual intervention
|
||||
4. Use AskUserQuestion for recovery decision:
|
||||
|
||||
```typescript
|
||||
AskUserQuestion({
|
||||
questions: [{
|
||||
question: "Codex execution failed for the subtask. How should the workflow proceed?",
|
||||
header: "Recovery",
|
||||
options: [
|
||||
{ label: "Retry Subtask", description: "Attempt to execute the same subtask again." },
|
||||
{ label: "Skip Subtask", description: "Continue to the next subtask in the plan." },
|
||||
{ label: "Abort Workflow", description: "Stop the entire execution." }
|
||||
],
|
||||
multiSelect: false
|
||||
}]
|
||||
})
|
||||
```
|
||||
|
||||
**Git Verification Failure** (if --verify-git):
|
||||
1. Show unexpected changes
|
||||
2. Pause execution
|
||||
3. Request user decision:
|
||||
- Continue anyway
|
||||
- Rollback and retry
|
||||
- Manual fix
|
||||
|
||||
**Codex Session Lost**:
|
||||
1. Detect if `codex exec "..." resume --last` fails
|
||||
2. Attempt retry with fresh session
|
||||
3. Report to user if manual intervention needed
|
||||
|
||||
## Output Format
|
||||
|
||||
**During Execution**:
|
||||
```
|
||||
Task Flow Diagram:
|
||||
[Group A: Auth Core]
|
||||
A1: Create user model ──┐
|
||||
A2: Add validation ─┤─► [resume] ─► A3: Database schema
|
||||
│
|
||||
[Group B: API Layer] │
|
||||
B1: Auth endpoints ─────┘─► [new session]
|
||||
B2: Middleware ────────────► [resume] ─► B3: Error handling
|
||||
|
||||
[Group C: Testing]
|
||||
C1: Unit tests ─────────────► [new session]
|
||||
C2: Integration tests ──────► [resume]
|
||||
|
||||
Task Decomposition:
|
||||
[Group A] 1. Create user model
|
||||
[Group A] 2. Add validation logic [resume]
|
||||
[Group A] 3. Implement database schema [resume]
|
||||
[Group B] 4. Create auth endpoints [new session]
|
||||
[Group B] 5. Add middleware [resume]
|
||||
[Group B] 6. Error handling [resume]
|
||||
[Group C] 7. Unit tests [new session]
|
||||
[Group C] 8. Integration tests [resume]
|
||||
|
||||
[Group A] Executing Subtask 1/8: Create user model
|
||||
Starting new Codex session for Group A...
|
||||
[Codex output]
|
||||
Subtask 1 completed
|
||||
|
||||
Git Verification:
|
||||
M src/models/user.ts
|
||||
Changes verified
|
||||
|
||||
[Group A] Executing Subtask 2/8: Add validation logic
|
||||
Resuming Codex session (same group)...
|
||||
[Codex output]
|
||||
Subtask 2 completed
|
||||
|
||||
[Group B] Executing Subtask 4/8: Create auth endpoints
|
||||
Starting NEW Codex session for Group B...
|
||||
[Codex output]
|
||||
Subtask 4 completed
|
||||
...
|
||||
|
||||
All Subtasks Completed
|
||||
Summary: [file references, changes, next steps]
|
||||
```
|
||||
|
||||
**Final Summary**:
|
||||
```markdown
|
||||
# Task Execution Summary: [Task Description]
|
||||
|
||||
## Subtasks Completed
|
||||
1. [Subtask 1]: [files modified]
|
||||
2. [Subtask 2]: [files modified]
|
||||
...
|
||||
|
||||
## Files Modified
|
||||
- src/file1.ts:10-50 - [changes]
|
||||
- src/file2.ts - [changes]
|
||||
|
||||
## Git Status
|
||||
- N files modified
|
||||
- M files added
|
||||
- No conflicts
|
||||
|
||||
## Next Steps
|
||||
- [Suggested follow-up actions]
|
||||
```
|
||||
|
||||
## Examples
|
||||
|
||||
**Example 1: Simple Task with Groups**
|
||||
```bash
|
||||
/cli:codex-execute "implement user authentication system"
|
||||
|
||||
# Task Flow Diagram:
|
||||
# [Group A: Data Layer]
|
||||
# A1: Create user model ──► [resume] ──► A2: Database schema
|
||||
#
|
||||
# [Group B: Auth Logic]
|
||||
# B1: JWT token generation ──► [new session]
|
||||
# B2: Authentication middleware ──► [resume]
|
||||
#
|
||||
# [Group C: API Endpoints]
|
||||
# C1: Login/logout endpoints ──► [new session]
|
||||
#
|
||||
# [Group D: Testing]
|
||||
# D1: Unit tests ──► [new session]
|
||||
# D2: Integration tests ──► [resume]
|
||||
|
||||
# Execution:
|
||||
# Group A: A1 (new) → A2 (resume)
|
||||
# Group B: B1 (new) → B2 (resume)
|
||||
# Group C: C1 (new)
|
||||
# Group D: D1 (new) → D2 (resume)
|
||||
```
|
||||
|
||||
**Example 2: With Git Verification**
|
||||
```bash
|
||||
/cli:codex-execute --verify-git "refactor API layer to use dependency injection"
|
||||
|
||||
# After each subtask, verifies:
|
||||
# - Only expected files modified
|
||||
# - No breaking changes in unrelated code
|
||||
# - Tests still pass
|
||||
```
|
||||
|
||||
**Example 3: With Task ID**
|
||||
```bash
|
||||
/cli:codex-execute IMPL-001
|
||||
|
||||
# Loads task from .task/IMPL-001.json
|
||||
# Decomposes based on task requirements
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Task Flow First**: Always create visual flow diagram before execution
|
||||
2. **Group Related Work**: Cluster subtasks by domain/files for efficient resume
|
||||
3. **Subtask Granularity**: Keep subtasks small and focused (5-15 min each)
|
||||
4. **Clear Boundaries**: Each subtask should have well-defined input/output
|
||||
5. **Git Hygiene**: Use `--verify-git` for critical refactoring
|
||||
6. **Pre-Execution Staging**: Stage changes before each subtask to clearly see codex modifications
|
||||
7. **Smart Resume**: Use `resume --last` ONLY within same group
|
||||
8. **Fresh Sessions**: Start new session when switching to different group/domain
|
||||
9. **Recovery Points**: TodoWrite with group labels provides clear progress tracking
|
||||
10. **Image References**: Attach design files for UI tasks (first subtask in group)
|
||||
|
||||
## Input Processing
|
||||
|
||||
**Automatic Detection**:
|
||||
- Input matches task ID pattern → Load from `.task/[ID].json`
|
||||
- Otherwise → Use as task description
|
||||
|
||||
**Task JSON Structure** (when loading from file):
|
||||
```json
|
||||
{
|
||||
"task_id": "IMPL-001",
|
||||
"title": "Implement user authentication",
|
||||
"description": "Create JWT-based auth system",
|
||||
"acceptance_criteria": [...],
|
||||
"scope": {...},
|
||||
"brainstorming_refs": [...]
|
||||
}
|
||||
```
|
||||
|
||||
## Output Routing
|
||||
|
||||
**Execution Log Destination**:
|
||||
- **IF** active workflow session exists:
|
||||
- Execution log: `.workflow/WFS-[id]/.chat/codex-execute-[timestamp].md`
|
||||
- Task summaries: `.workflow/WFS-[id]/.summaries/[TASK-ID]-summary.md` (if task ID)
|
||||
- Task updates: `.workflow/WFS-[id]/.task/[TASK-ID].json` status updates
|
||||
- TodoWrite tracking: Embedded in execution log
|
||||
- **ELSE** (no active session):
|
||||
- **Recommended**: Create workflow session first (`/workflow:session:start`)
|
||||
- **Alternative**: Save to `.workflow/.scratchpad/codex-execute-[description]-[timestamp].md`
|
||||
|
||||
**Output Files** (during execution):
|
||||
```
|
||||
.workflow/WFS-[session-id]/
|
||||
├── .chat/
|
||||
│ └── codex-execute-20250105-143022.md # Full execution log with task flow
|
||||
├── .summaries/
|
||||
│ ├── IMPL-001.1-summary.md # Subtask summaries
|
||||
│ ├── IMPL-001.2-summary.md
|
||||
│ └── IMPL-001-summary.md # Final task summary
|
||||
└── .task/
|
||||
├── IMPL-001.json # Updated task status
|
||||
└── [subtask JSONs if decomposed]
|
||||
```
|
||||
|
||||
**Examples**:
|
||||
- During session `WFS-auth-system`, executing multi-stage auth implementation:
|
||||
- Log: `.workflow/WFS-auth-system/.chat/codex-execute-20250105-143022.md`
|
||||
- Summaries: `.workflow/WFS-auth-system/.summaries/IMPL-001.{1,2,3}-summary.md`
|
||||
- Task status: `.workflow/WFS-auth-system/.task/IMPL-001.json` (status: completed)
|
||||
- No session, ad-hoc multi-stage task:
|
||||
- Log: `.workflow/.scratchpad/codex-execute-auth-refactor-20250105-143045.md`
|
||||
|
||||
**Save Results**:
|
||||
- Execution log with task flow diagram and TodoWrite tracking
|
||||
- Individual summaries for each completed subtask
|
||||
- Final consolidated summary when all subtasks complete
|
||||
- Modified code files throughout project
|
||||
|
||||
## Notes
|
||||
|
||||
**vs. `/cli:execute`**:
|
||||
- `/cli:execute`: Single-shot execution with Gemini/Qwen/Codex
|
||||
- `/cli:codex-execute`: Multi-stage Codex execution with automatic task decomposition and resume mechanism
|
||||
|
||||
**Input Flexibility**: Accepts both freeform descriptions and task IDs (auto-detects and loads JSON)
|
||||
|
||||
**Context Window**: `codex exec "..." resume --last` maintains conversation history, ensuring consistency across subtasks without redundant context injection.
|
||||
|
||||
**Output Details**:
|
||||
- Session management: see intelligent-tools-strategy.md
|
||||
- **⚠️ Code Modification**: This command performs multi-stage code modifications - execution log tracks all changes
|
||||
@@ -0,0 +1,320 @@
|
||||
---
|
||||
name: discuss-plan
|
||||
description: Multi-round collaborative planning using Gemini, Codex, and Claude synthesis with iterative discussion cycles (read-only, no code changes)
|
||||
argument-hint: "[--topic '...'] [--task-id '...'] [--rounds N]"
|
||||
allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
|
||||
---
|
||||
|
||||
# CLI Discuss-Plan Command (/cli:discuss-plan)
|
||||
|
||||
## Purpose
|
||||
|
||||
Orchestrates a multi-model collaborative discussion for in-depth planning and problem analysis. This command facilitates an iterative dialogue between Gemini, Codex, and Claude (the orchestrating AI) to explore a topic from multiple perspectives, refine ideas, and build a robust plan.
|
||||
|
||||
**This command is for discussion and planning ONLY. It does NOT modify any code.**
|
||||
|
||||
## Core Workflow: The Discussion Loop
|
||||
|
||||
The command operates in iterative rounds, allowing the plan to evolve with each cycle. The user can choose to continue for more rounds or conclude when consensus is reached.
|
||||
|
||||
```
|
||||
Topic Input → [Round 1: Gemini → Codex → Claude] → [User Review] →
|
||||
[Round 2: Gemini → Codex → Claude] → ... → Final Plan
|
||||
```
|
||||
|
||||
### Model Roles & Priority
|
||||
|
||||
**Priority Order**: Gemini > Codex > Claude
|
||||
|
||||
1. **Gemini (The Analyst)** - Priority 1
|
||||
- Kicks off each round with deep analysis
|
||||
- Provides foundational ideas and draft plans
|
||||
- Analyzes current context or previous synthesis
|
||||
|
||||
2. **Codex (The Architect/Critic)** - Priority 2
|
||||
- Reviews Gemini's output critically
|
||||
- Uses deep reasoning for technical trade-offs
|
||||
- Proposes alternative strategies
|
||||
- **Participates purely in conversational/reasoning capacity**
|
||||
- Uses resume mechanism to maintain discussion context
|
||||
|
||||
3. **Claude (The Synthesizer/Moderator)** - Priority 3
|
||||
- Synthesizes discussion from Gemini and Codex
|
||||
- Highlights agreements and contentions
|
||||
- Structures refined plan
|
||||
- Poses key questions for next round
|
||||
|
||||
## Parameters
|
||||
|
||||
- `<input>` (Required): Topic description or task ID (e.g., "Design a new caching layer" or `PLAN-002`)
|
||||
- `--rounds <N>` (Optional): Maximum number of discussion rounds (default: prompts after each round)
|
||||
- `--task-id <id>` (Optional): Associates discussion with workflow task ID
|
||||
- `--topic <description>` (Optional): High-level topic for discussion
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Phase 1: Initial Setup
|
||||
|
||||
1. **Input Processing**: Parse topic or task ID
|
||||
2. **Context Gathering**: Identify relevant files based on topic
|
||||
|
||||
### Phase 2: Discussion Round
|
||||
|
||||
Each round consists of three sequential steps, tracked via `TodoWrite`.
|
||||
|
||||
**Step 1: Gemini's Analysis (Priority 1)**
|
||||
|
||||
Gemini analyzes the topic and proposes preliminary plan.
|
||||
|
||||
```bash
|
||||
# Round 1: CONTEXT_INPUT is the initial topic
|
||||
# Subsequent rounds: CONTEXT_INPUT is the synthesis from previous round
|
||||
gemini -p "
|
||||
PURPOSE: Analyze and propose a plan for '[topic]'
|
||||
TASK: Provide initial analysis, identify key modules, and draft implementation plan
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [auto-detected files]
|
||||
INPUT: [CONTEXT_INPUT]
|
||||
EXPECTED: Structured analysis and draft plan for discussion
|
||||
RULES: Focus on technical depth and practical considerations
|
||||
"
|
||||
```
|
||||
|
||||
**Step 2: Codex's Critique (Priority 2)**
|
||||
|
||||
Codex reviews Gemini's output using conversational reasoning. Uses `resume --last` to maintain context across rounds.
|
||||
|
||||
```bash
|
||||
# First round (new session)
|
||||
codex --full-auto exec "
|
||||
PURPOSE: Critically review technical plan
|
||||
TASK: Review the provided plan, identify weaknesses, suggest alternatives, reason about trade-offs
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [relevant files]
|
||||
INPUT_PLAN: [Output from Gemini's analysis]
|
||||
EXPECTED: Critical review with alternative ideas and risk analysis
|
||||
RULES: Focus on architectural soundness and implementation feasibility
|
||||
" --skip-git-repo-check
|
||||
|
||||
# Subsequent rounds (resume discussion)
|
||||
codex --full-auto exec "
|
||||
PURPOSE: Re-evaluate plan based on latest synthesis
|
||||
TASK: Review updated plan and discussion points, provide further critique or refined ideas
|
||||
MODE: analysis
|
||||
CONTEXT: Previous discussion context (maintained via resume)
|
||||
INPUT_PLAN: [Output from Gemini's analysis for current round]
|
||||
EXPECTED: Updated critique building on previous discussion
|
||||
RULES: Build on previous insights, avoid repeating points
|
||||
" resume --last --skip-git-repo-check
|
||||
```
|
||||
|
||||
**Step 3: Claude's Synthesis (Priority 3)**
|
||||
|
||||
Claude (orchestrating AI) synthesizes both outputs:
|
||||
|
||||
- Summarizes Gemini's proposal and Codex's critique
|
||||
- Highlights agreements and disagreements
|
||||
- Structures consolidated plan
|
||||
- Presents open questions for next round
|
||||
- This synthesis becomes input for next round
|
||||
|
||||
### Phase 3: User Review and Iteration
|
||||
|
||||
1. **Present Synthesis**: Show synthesized plan and key discussion points
|
||||
2. **Continue or Conclude**: Use AskUserQuestion to prompt user:
|
||||
|
||||
```typescript
|
||||
AskUserQuestion({
|
||||
questions: [{
|
||||
question: "Round of discussion complete. What is the next step?",
|
||||
header: "Next Round",
|
||||
options: [
|
||||
{ label: "Start another round", description: "Continue the discussion to refine the plan further." },
|
||||
{ label: "Conclude and finalize", description: "End the discussion and save the final plan." }
|
||||
],
|
||||
multiSelect: false
|
||||
}]
|
||||
})
|
||||
```
|
||||
|
||||
3. **Loop or Finalize**:
|
||||
- Continue → New round with Gemini analyzing latest synthesis
|
||||
- Conclude → Save final synthesized document
|
||||
|
||||
## TodoWrite Tracking
|
||||
|
||||
Progress tracked for each round and model.
|
||||
|
||||
```javascript
|
||||
// Example for 2-round discussion
|
||||
TodoWrite({
|
||||
todos: [
|
||||
// Round 1
|
||||
{ content: "[Round 1] Gemini: Analyzing topic", status: "completed", activeForm: "Analyzing with Gemini" },
|
||||
{ content: "[Round 1] Codex: Critiquing plan", status: "completed", activeForm: "Critiquing with Codex" },
|
||||
{ content: "[Round 1] Claude: Synthesizing discussion", status: "completed", activeForm: "Synthesizing discussion" },
|
||||
{ content: "[User Action] Review Round 1 and decide next step", status: "in_progress", activeForm: "Awaiting user decision" },
|
||||
|
||||
// Round 2
|
||||
{ content: "[Round 2] Gemini: Analyzing refined plan", status: "pending", activeForm: "Analyzing refined plan" },
|
||||
{ content: "[Round 2] Codex: Re-evaluating plan [resume]", status: "pending", activeForm: "Re-evaluating with Codex" },
|
||||
{ content: "[Round 2] Claude: Finalizing plan", status: "pending", activeForm: "Finalizing plan" },
|
||||
{ content: "Discussion complete - Final plan generated", status: "pending", activeForm: "Generating final document" }
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
## Output Routing
|
||||
|
||||
- **Primary Log**: Entire multi-round discussion logged to single file:
|
||||
- `.workflow/WFS-[id]/.chat/discuss-plan-[topic]-[timestamp].md`
|
||||
- **Final Plan**: Clean final version saved upon conclusion:
|
||||
- `.workflow/WFS-[id]/.summaries/plan-[topic].md`
|
||||
- **Scratchpad**: If no session active:
|
||||
- `.workflow/.scratchpad/discuss-plan-[topic]-[timestamp].md`
|
||||
|
||||
## Discussion Structure
|
||||
|
||||
Each round's output is structured as:
|
||||
|
||||
```markdown
|
||||
## Round N: [Topic]
|
||||
|
||||
### Gemini's Analysis (Priority 1)
|
||||
[Gemini's full analysis and proposal]
|
||||
|
||||
### Codex's Critique (Priority 2)
|
||||
[Codex's critical review and alternatives]
|
||||
|
||||
### Claude's Synthesis (Priority 3)
|
||||
**Points of Agreement:**
|
||||
- [Agreement 1]
|
||||
- [Agreement 2]
|
||||
|
||||
**Points of Contention:**
|
||||
- [Issue 1]: Gemini suggests X, Codex suggests Y
|
||||
- [Issue 2]: Trade-off between A and B
|
||||
|
||||
**Consolidated Plan:**
|
||||
[Structured plan incorporating both perspectives]
|
||||
|
||||
**Open Questions for Next Round:**
|
||||
1. [Question 1]
|
||||
2. [Question 2]
|
||||
```
|
||||
|
||||
## Examples
|
||||
|
||||
### Example 1: Multi-Round Architecture Discussion
|
||||
|
||||
**Command**: `/cli:discuss-plan --topic "Design a real-time notification system"`
|
||||
|
||||
**Round 1**:
|
||||
1. **Gemini**: Proposes WebSocket-based architecture with RabbitMQ message queue
|
||||
2. **Codex**: Critiques as overly complex for MVP. Suggests Server-Sent Events (SSE) for simplicity (one-way notifications). Questions RabbitMQ necessity, proposes simpler Redis Pub/Sub
|
||||
3. **Claude**: Synthesizes views:
|
||||
- **Plan A (Gemini)**: WebSockets + RabbitMQ (highly scalable, complex)
|
||||
- **Plan B (Codex)**: SSE + Redis (simpler, less overhead)
|
||||
- **Open Question**: Is bi-directional communication critical, or is simplicity priority?
|
||||
4. **User Action**: Opts for another round to explore trade-offs
|
||||
|
||||
**Round 2**:
|
||||
1. **Gemini**: Analyzes synthesized document. Notes that if features like "user is typing" indicators are roadmapped, WebSockets better long-term. Drafts plan starting with SSE/Redis but designing for easy migration
|
||||
2. **Codex**: Reviews migration plan. Reasons that migration itself could be complex. If feature set likely to expand, starting with WebSockets using managed service might be best cost/benefit
|
||||
3. **Claude**: Synthesizes new discussion:
|
||||
- **Consensus**: Simple SSE/Redis too short-sighted
|
||||
- **Refined Options**:
|
||||
1. Phased approach (SSE → WebSocket) with clear migration plan
|
||||
2. Direct WebSocket with managed service (Pusher, Ably) to reduce ops overhead
|
||||
- **Recommendation**: Option 2 most robust and future-proof
|
||||
4. **User Action**: Agrees with recommendation, concludes discussion
|
||||
|
||||
**Final Output**: Planning document saved with:
|
||||
- Chosen architecture (Managed WebSocket service)
|
||||
- Multi-round reasoning
|
||||
- High-level implementation steps
|
||||
|
||||
### Example 2: Feature Design Discussion
|
||||
|
||||
**Command**: `/cli:discuss-plan --topic "Design user permission system" --rounds 2`
|
||||
|
||||
**Round 1**:
|
||||
1. **Gemini**: Proposes RBAC (Role-Based Access Control) with predefined roles
|
||||
2. **Codex**: Suggests ABAC (Attribute-Based Access Control) for more flexibility
|
||||
3. **Claude**: Synthesizes trade-offs between simplicity (RBAC) vs flexibility (ABAC)
|
||||
|
||||
**Round 2**:
|
||||
1. **Gemini**: Analyzes hybrid approach - RBAC for core permissions, attributes for fine-grained control
|
||||
2. **Codex**: Reviews hybrid model, identifies implementation challenges
|
||||
3. **Claude**: Final plan with phased rollout strategy
|
||||
|
||||
**Automatic Conclusion**: Command concludes after 2 rounds as specified
|
||||
|
||||
### Example 3: Problem-Solving Discussion
|
||||
|
||||
**Command**: `/cli:discuss-plan --topic "Debug memory leak in data pipeline" --task-id ISSUE-042`
|
||||
|
||||
**Round 1**:
|
||||
1. **Gemini**: Identifies potential leak sources (unclosed handles, growing cache, event listeners)
|
||||
2. **Codex**: Adds profiling tool recommendations, suggests memory monitoring
|
||||
3. **Claude**: Structures debugging plan with phased approach
|
||||
|
||||
**User Decision**: Single round sufficient, concludes with debugging strategy
|
||||
|
||||
## Consensus Mechanisms
|
||||
|
||||
**When to Continue:**
|
||||
- Significant disagreement between models
|
||||
- Open questions requiring deeper analysis
|
||||
- Trade-offs need more exploration
|
||||
- User wants additional perspectives
|
||||
|
||||
**When to Conclude:**
|
||||
- Models converge on solution
|
||||
- All key questions addressed
|
||||
- User satisfied with plan depth
|
||||
- Maximum rounds reached (if specified)
|
||||
|
||||
## Comparison with Other Commands
|
||||
|
||||
| Command | Models | Rounds | Discussion | Implementation | Use Case |
|
||||
|---------|--------|--------|------------|----------------|----------|
|
||||
| `/cli:mode:plan` | Gemini | 1 | NO | NO | Single-model planning |
|
||||
| `/cli:analyze` | Gemini/Qwen | 1 | NO | NO | Code analysis |
|
||||
| `/cli:execute` | Any | 1 | NO | YES | Direct implementation |
|
||||
| `/cli:codex-execute` | Codex | 1 | NO | YES | Multi-stage implementation |
|
||||
| `/cli:discuss-plan` | **Gemini+Codex+Claude** | **Multiple** | **YES** | **NO** | **Multi-perspective planning** |
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Use for Complex Decisions**: Ideal for architectural decisions, design trade-offs, problem-solving
|
||||
2. **Start with Broad Topic**: Let first round establish scope, subsequent rounds refine
|
||||
3. **Review Each Synthesis**: Claude's synthesis is key decision point - review carefully
|
||||
4. **Know When to Stop**: Don't over-iterate - 2-3 rounds usually sufficient
|
||||
5. **Task Association**: Use `--task-id` for traceability in workflow
|
||||
6. **Save Intermediate Results**: Each round's synthesis saved automatically
|
||||
7. **Let Models Disagree**: Divergent views often reveal important trade-offs
|
||||
8. **Focus Questions**: Use Claude's open questions to guide next round
|
||||
|
||||
## Breaking Discussion Loops
|
||||
|
||||
**Detecting Loops:**
|
||||
- Models repeating same arguments
|
||||
- No new insights emerging
|
||||
- Trade-offs well understood
|
||||
|
||||
**Breaking Strategies:**
|
||||
1. **User Decision**: Make executive decision when enough info gathered
|
||||
2. **Timeboxing**: Set max rounds upfront with `--rounds`
|
||||
3. **Criteria-Based**: Define decision criteria before starting
|
||||
4. **Hybrid Approach**: Accept multiple valid solutions in final plan
|
||||
|
||||
## Notes
|
||||
|
||||
- **Pure Discussion**: This command NEVER modifies code - only produces planning documents
|
||||
- **Codex Role**: Codex participates as reasoning/critique tool, not executor
|
||||
- **Resume Context**: Codex maintains discussion context via `resume --last`
|
||||
- **Priority System**: Ensures Gemini leads analysis, Codex provides critique, Claude synthesizes
|
||||
- **Output Quality**: Multi-perspective discussion produces more robust plans than single-model analysis
|
||||
- Command patterns and session management: see intelligent-tools-strategy.md (loaded in memory)
|
||||
- For implementation after discussion, use `/cli:execute` or `/cli:codex-execute` separately
|
||||
221
.claude/skills/command-guide/reference/commands/cli/execute.md
Normal file
221
.claude/skills/command-guide/reference/commands/cli/execute.md
Normal file
@@ -0,0 +1,221 @@
|
||||
---
|
||||
name: execute
|
||||
description: Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection
|
||||
argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Execute Command (/cli:execute)
|
||||
|
||||
## Purpose
|
||||
|
||||
Execute implementation tasks with **YOLO permissions** (auto-approves all confirmations). **MODIFIES CODE**.
|
||||
|
||||
**Intent**: Autonomous code implementation, modification, and generation
|
||||
**Supported Tools**: codex, gemini (default), qwen
|
||||
**Key Feature**: Automatic context inference and file pattern detection
|
||||
|
||||
## Core Behavior
|
||||
|
||||
1. **Code Modification**: This command MODIFIES, CREATES, and DELETES code files
|
||||
2. **Auto-Approval**: YOLO mode bypasses confirmation prompts for all operations
|
||||
3. **Implementation Focus**: Executes actual code changes, not just recommendations
|
||||
4. **Requires Explicit Intent**: Use only when implementation is intended
|
||||
|
||||
## Core Concepts
|
||||
|
||||
### YOLO Permissions
|
||||
Auto-approves: file pattern inference, execution, **file modifications**, summary generation
|
||||
|
||||
**WARNING**: This command will make actual code changes without manual confirmation
|
||||
|
||||
### Execution Modes
|
||||
|
||||
**1. Description Mode** (supports `--enhance`):
|
||||
- Input: Natural language description
|
||||
- Process: [Optional: Enhance] → Keyword analysis → Pattern inference → Execute
|
||||
|
||||
**2. Task ID Mode** (no `--enhance`):
|
||||
- Input: Workflow task identifier (e.g., `IMPL-001`)
|
||||
- Process: Task JSON parsing → Scope analysis → Execute
|
||||
|
||||
**3. Agent Mode** (`--agent` flag):
|
||||
- Input: Description or task-id
|
||||
- Process: 5-Phase Workflow → Context Discovery → Optimal Tool Selection → Execute
|
||||
|
||||
### Context Inference
|
||||
|
||||
Auto-selects files based on keywords and technology (each @ references one pattern):
|
||||
- "auth" → `@**/*auth* @**/*user*`
|
||||
- "React" → `@src/**/*.jsx @src/**/*.tsx`
|
||||
- "api" → `@**/api/**/* @**/routes/**/*`
|
||||
- Always includes: `@CLAUDE.md @**/*CLAUDE.md`
|
||||
|
||||
For precise file targeting, use `rg` or MCP tools to discover files first.
|
||||
|
||||
### Codex Session Continuity
|
||||
|
||||
**Resume Pattern** for related tasks:
|
||||
```bash
|
||||
# First task - establish session
|
||||
codex -C [dir] --full-auto exec "[task]" --skip-git-repo-check -s danger-full-access
|
||||
|
||||
# Related task - continue session
|
||||
codex --full-auto exec "[related-task]" resume --last --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
Use `resume --last` when current task extends/relates to previous execution. See intelligent-tools-strategy.md for auto-resume rules.
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
|
||||
- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini, ignored in agent mode unless specified)
|
||||
- `--enhance` - Enhance input with `/enhance-prompt` first (Description Mode only)
|
||||
- `<description|task-id>` - Natural language description or task identifier
|
||||
- `--debug` - Verbose logging
|
||||
- `--save-session` - Save execution to workflow session
|
||||
|
||||
## Workflow Integration
|
||||
|
||||
**Session Management**: Auto-detects `.workflow/.active-*` marker
|
||||
- Active session: Save to `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
|
||||
- No session: Create new session or save to scratchpad
|
||||
|
||||
**Task Integration**: Load from `.task/[TASK-ID].json`, update status, generate summary
|
||||
|
||||
## Output Routing
|
||||
|
||||
**Execution Log Destination**:
|
||||
- **IF** active workflow session exists:
|
||||
- Save to `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
|
||||
- Update task status in `.task/[TASK-ID].json` (if task ID provided)
|
||||
- Generate summary in `.workflow/WFS-[id]/.summaries/[TASK-ID]-summary.md`
|
||||
- **ELSE** (no active session):
|
||||
- **Option 1**: Create new workflow session for task
|
||||
- **Option 2**: Save to `.workflow/.scratchpad/execute-[description]-[timestamp].md`
|
||||
|
||||
**Output Files** (when active session exists):
|
||||
- Execution log: `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
|
||||
- Task summary: `.workflow/WFS-[id]/.summaries/[TASK-ID]-summary.md` (if task ID)
|
||||
- Modified code: Project files per implementation
|
||||
|
||||
**Examples**:
|
||||
- During session `WFS-auth-system`, executing `IMPL-001`:
|
||||
- Log: `.workflow/WFS-auth-system/.chat/execute-20250105-143022.md`
|
||||
- Summary: `.workflow/WFS-auth-system/.summaries/IMPL-001-summary.md`
|
||||
- No session, ad-hoc implementation:
|
||||
- Log: `.workflow/.scratchpad/execute-jwt-auth-20250105-143045.md`
|
||||
|
||||
## Execution Modes
|
||||
|
||||
### Standard Mode (Default)
|
||||
```bash
|
||||
# Gemini/Qwen: MODE=write with --approval-mode yolo
|
||||
cd . && gemini --approval-mode yolo "
|
||||
PURPOSE: [implementation goal]
|
||||
TASK: [specific implementation]
|
||||
MODE: write
|
||||
CONTEXT: @CLAUDE.md [auto-detected files]
|
||||
EXPECTED: Working implementation with code changes
|
||||
RULES: [constraints] | Auto-approve all changes
|
||||
"
|
||||
|
||||
# Codex: MODE=auto with danger-full-access
|
||||
codex -C . --full-auto exec "
|
||||
PURPOSE: [implementation goal]
|
||||
TASK: [specific implementation]
|
||||
MODE: auto
|
||||
CONTEXT: [auto-detected files]
|
||||
EXPECTED: Complete implementation with tests
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
### Agent Mode (`--agent` flag)
|
||||
|
||||
Delegate implementation to `cli-execution-agent` for intelligent execution with automated context discovery.
|
||||
|
||||
**Agent invocation**:
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Implement with automated context discovery and optimal tool selection",
|
||||
prompt=`
|
||||
Task: ${description_or_task_id}
|
||||
Mode: execute
|
||||
Tool Preference: ${tool_flag || 'auto-select'}
|
||||
${enhance_flag ? 'Enhance: true' : ''}
|
||||
|
||||
Agent will autonomously:
|
||||
- Discover implementation files and dependencies
|
||||
- Assess complexity and select optimal tool
|
||||
- Execute with YOLO permissions (auto-approve)
|
||||
- Generate task summary if task-id provided
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
The agent handles all phases internally, including complexity-based tool selection.
|
||||
|
||||
## Examples
|
||||
|
||||
**Basic Implementation (Standard Mode)** (modifies code):
|
||||
```bash
|
||||
/cli:execute "implement JWT authentication with middleware"
|
||||
# Executes: Creates auth middleware, updates routes, modifies config
|
||||
# Result: NEW/MODIFIED code files with JWT implementation
|
||||
```
|
||||
|
||||
**Intelligent Implementation (Agent Mode)** (modifies code):
|
||||
```bash
|
||||
/cli:execute --agent "implement OAuth2 authentication with token refresh"
|
||||
# Phase 1: Classifies intent=execute, complexity=complex, keywords=['oauth2', 'auth', 'token', 'refresh']
|
||||
# Phase 2: MCP discovers auth patterns, existing middleware, JWT dependencies
|
||||
# Phase 3: Enhances prompt with discovered patterns and best practices
|
||||
# Phase 4: Selects Codex (complex task), executes with comprehensive context
|
||||
# Phase 5: Saves execution log + generates implementation summary
|
||||
# Result: Complete OAuth2 implementation + detailed execution log
|
||||
```
|
||||
|
||||
**Enhanced Implementation** (modifies code):
|
||||
```bash
|
||||
/cli:execute --enhance "implement JWT authentication"
|
||||
# Step 1: Enhance to expand requirements
|
||||
# Step 2: Execute implementation with auto-approval
|
||||
# Result: Complete auth system with MODIFIED code files
|
||||
```
|
||||
|
||||
**Task Execution** (modifies code):
|
||||
```bash
|
||||
/cli:execute IMPL-001
|
||||
# Reads: .task/IMPL-001.json for requirements
|
||||
# Executes: Implementation based on task spec
|
||||
# Result: Code changes per task definition
|
||||
```
|
||||
|
||||
**Codex Implementation** (modifies code):
|
||||
```bash
|
||||
/cli:execute --tool codex "optimize database queries"
|
||||
# Executes: Codex with full file access
|
||||
# Result: MODIFIED query code, new indexes, updated tests
|
||||
```
|
||||
|
||||
**Qwen Code Generation** (modifies code):
|
||||
```bash
|
||||
/cli:execute --tool qwen --enhance "refactor auth module"
|
||||
# Step 1: Enhanced refactoring plan
|
||||
# Step 2: Execute with MODE=write
|
||||
# Result: REFACTORED auth code with structural changes
|
||||
```
|
||||
|
||||
## Comparison with Analysis Commands
|
||||
|
||||
| Command | Intent | Code Changes | Auto-Approve |
|
||||
|---------|--------|--------------|--------------|
|
||||
| `/cli:analyze` | Understand code | NO | N/A |
|
||||
| `/cli:chat` | Ask questions | NO | N/A |
|
||||
| `/cli:execute` | **Implement** | **YES** | **YES** |
|
||||
|
||||
## Notes
|
||||
|
||||
- Command templates, YOLO mode details, and session management: see intelligent-tools-strategy.md (loaded in memory)
|
||||
- **Code Modification**: This command modifies code - execution logs document changes made
|
||||
@@ -0,0 +1,130 @@
|
||||
---
|
||||
name: bug-diagnosis
|
||||
description: Read-only bug root cause analysis using Gemini/Qwen/Codex with systematic diagnosis template for fix suggestions
|
||||
argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Mode: Bug Diagnosis (/cli:mode:bug-diagnosis)
|
||||
|
||||
## Purpose
|
||||
|
||||
Systematic bug diagnosis with root cause analysis template (`~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`).
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for bug diagnosis
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for complex bug analysis
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--agent` - Use cli-execution-agent for automated context discovery
|
||||
- `--enhance` - Enhance bug description with `/enhance-prompt`
|
||||
- `--cd "path"` - Target directory for focused diagnosis
|
||||
- `<bug-description>` (Required) - Bug description or error details
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
# Uses gemini by default, or specify explicitly
|
||||
--tool gemini
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Standard Mode
|
||||
1. Parse tool selection (default: gemini)
|
||||
2. Optional: enhance with `/enhance-prompt`
|
||||
3. Detect directory from `--cd` or auto-infer
|
||||
4. Build command with template
|
||||
5. Execute diagnosis (read-only)
|
||||
6. Save to `.workflow/WFS-[id]/.chat/`
|
||||
|
||||
### Agent Mode (`--agent`)
|
||||
|
||||
Delegates to agent for intelligent diagnosis:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Bug root cause diagnosis",
|
||||
prompt=`
|
||||
Task: ${bug_description}
|
||||
Mode: bug-diagnosis
|
||||
Tool: ${tool_flag || 'auto-select'} // gemini|qwen|codex
|
||||
Directory: ${cd_path || 'auto-detect'}
|
||||
Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt
|
||||
|
||||
Agent responsibilities:
|
||||
1. Context Discovery:
|
||||
- Locate error traces and logs
|
||||
- Find related code sections
|
||||
- Identify data flow paths
|
||||
|
||||
2. CLI Command Generation:
|
||||
- Build Gemini/Qwen/Codex command
|
||||
- Include diagnostic context
|
||||
- Apply ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt template
|
||||
|
||||
3. Execution & Output:
|
||||
- Execute root cause analysis
|
||||
- Generate fix suggestions
|
||||
- Save to .workflow/.chat/
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Diagnoses bugs, does NOT modify code
|
||||
- **Template**: Uses `~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt` for root cause analysis
|
||||
- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
|
||||
|
||||
## CLI Command Templates
|
||||
|
||||
**Gemini/Qwen** (default, diagnosis only):
|
||||
```bash
|
||||
cd [dir] && gemini -p "
|
||||
PURPOSE: [goal]
|
||||
TASK: Root cause analysis
|
||||
MODE: analysis
|
||||
CONTEXT: @**/*
|
||||
EXPECTED: Diagnosis, fix plan
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt)
|
||||
"
|
||||
# Qwen: Replace 'gemini' with 'qwen'
|
||||
```
|
||||
|
||||
**Codex** (diagnosis + potential fixes):
|
||||
```bash
|
||||
codex -C [dir] --full-auto exec "
|
||||
PURPOSE: [goal]
|
||||
TASK: Bug diagnosis
|
||||
MODE: analysis
|
||||
CONTEXT: @**/*
|
||||
EXPECTED: Diagnosis, fix suggestions
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt)
|
||||
" -m gpt-5 --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Output
|
||||
|
||||
- **With session**: `.workflow/WFS-[id]/.chat/bug-diagnosis-[timestamp].md`
|
||||
- **No session**: `.workflow/.scratchpad/bug-diagnosis-[desc]-[timestamp].md`
|
||||
|
||||
## Notes
|
||||
|
||||
- Template: `~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`
|
||||
- See `intelligent-tools-strategy.md` for detailed tool usage
|
||||
@@ -0,0 +1,137 @@
|
||||
---
|
||||
name: code-analysis
|
||||
description: Read-only execution path tracing using Gemini/Qwen/Codex with specialized analysis template for call flow and optimization
|
||||
argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Mode: Code Analysis (/cli:mode:code-analysis)
|
||||
|
||||
## Purpose
|
||||
|
||||
Systematic code analysis with execution path tracing template (`~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`).
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for code analysis and tracing
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for complex analysis tasks
|
||||
|
||||
**Key Feature**: `--cd` flag for directory-scoped analysis
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--agent` - Use cli-execution-agent for automated context discovery
|
||||
- `--enhance` - Enhance analysis target with `/enhance-prompt` first
|
||||
- `--cd "path"` - Target directory for focused analysis
|
||||
- `<analysis-target>` (Required) - Code analysis target or question
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
/cli:mode:code-analysis --tool gemini "trace auth flow"
|
||||
# OR (default)
|
||||
/cli:mode:code-analysis "trace auth flow"
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
/cli:mode:code-analysis --tool qwen "trace auth flow"
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
/cli:mode:code-analysis --tool codex "trace auth flow"
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Standard Mode (Default)
|
||||
|
||||
1. Parse tool selection (default: gemini)
|
||||
2. Optional: enhance analysis target with `/enhance-prompt`
|
||||
3. Detect target directory from `--cd` or auto-infer
|
||||
4. Build command with template
|
||||
5. Execute analysis (read-only)
|
||||
6. Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
|
||||
|
||||
### Agent Mode (`--agent` flag)
|
||||
|
||||
Delegates to `cli-execution-agent` for intelligent context discovery and analysis.
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Analyzes code, does NOT modify files
|
||||
- **Template**: Uses `~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt` for systematic analysis
|
||||
- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
|
||||
|
||||
## CLI Command Templates
|
||||
|
||||
**Gemini/Qwen** (default, read-only analysis):
|
||||
```bash
|
||||
cd [dir] && gemini -p "
|
||||
PURPOSE: [goal]
|
||||
TASK: Execution path tracing
|
||||
MODE: analysis
|
||||
CONTEXT: @**/*
|
||||
EXPECTED: Trace, call diagram
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt)
|
||||
"
|
||||
# Qwen: Replace 'gemini' with 'qwen'
|
||||
```
|
||||
|
||||
**Codex** (analysis + optimization suggestions):
|
||||
```bash
|
||||
codex -C [dir] --full-auto exec "
|
||||
PURPOSE: [goal]
|
||||
TASK: Path analysis
|
||||
MODE: analysis
|
||||
CONTEXT: @**/*
|
||||
EXPECTED: Trace, optimization
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt)
|
||||
" -m gpt-5 --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Agent Execution Context
|
||||
|
||||
When `--agent` flag is used, delegate to agent:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Code execution path analysis",
|
||||
prompt=`
|
||||
Task: ${analysis_target}
|
||||
Mode: code-analysis
|
||||
Tool: ${tool_flag || 'auto-select'} // gemini|qwen|codex
|
||||
Directory: ${cd_path || 'auto-detect'}
|
||||
Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt
|
||||
|
||||
Agent responsibilities:
|
||||
1. Context Discovery:
|
||||
- Identify entry points and call chains
|
||||
- Discover related files (MCP/ripgrep)
|
||||
- Map execution flow paths
|
||||
|
||||
2. CLI Command Generation:
|
||||
- Build Gemini/Qwen/Codex command
|
||||
- Include discovered context
|
||||
- Apply ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt template
|
||||
|
||||
3. Execution & Output:
|
||||
- Execute analysis with selected tool
|
||||
- Save to .workflow/WFS-[id]/.chat/
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Output
|
||||
|
||||
- **With session**: `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
|
||||
- **No session**: `.workflow/.scratchpad/code-analysis-[desc]-[timestamp].md`
|
||||
|
||||
## Notes
|
||||
|
||||
- Template: `~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`
|
||||
- See `intelligent-tools-strategy.md` for detailed tool usage
|
||||
129
.claude/skills/command-guide/reference/commands/cli/mode/plan.md
Normal file
129
.claude/skills/command-guide/reference/commands/cli/mode/plan.md
Normal file
@@ -0,0 +1,129 @@
|
||||
---
|
||||
name: plan
|
||||
description: Read-only architecture planning using Gemini/Qwen/Codex with strategic planning template for modification plans and impact analysis
|
||||
argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Mode: Plan (/cli:mode:plan)
|
||||
|
||||
## Purpose
|
||||
|
||||
Strategic software architecture planning template (`~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`).
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for architecture planning
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for implementation planning
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--agent` - Use cli-execution-agent for automated context discovery
|
||||
- `--enhance` - Enhance task with `/enhance-prompt`
|
||||
- `--cd "path"` - Target directory for focused planning
|
||||
- `<planning-task>` (Required) - Architecture planning task or modification requirements
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
--tool gemini # or omit (default)
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Standard Mode
|
||||
1. Parse tool selection (default: gemini)
|
||||
2. Optional: enhance with `/enhance-prompt`
|
||||
3. Detect directory from `--cd` or auto-infer
|
||||
4. Build command with template
|
||||
5. Execute planning (read-only, no code generation)
|
||||
6. Save to `.workflow/WFS-[id]/.chat/`
|
||||
|
||||
### Agent Mode (`--agent`)
|
||||
|
||||
Delegates to agent for intelligent planning:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Architecture modification planning",
|
||||
prompt=`
|
||||
Task: ${planning_task}
|
||||
Mode: architecture-planning
|
||||
Tool: ${tool_flag || 'auto-select'} // gemini|qwen|codex
|
||||
Directory: ${cd_path || 'auto-detect'}
|
||||
Template: ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt
|
||||
|
||||
Agent responsibilities:
|
||||
1. Context Discovery:
|
||||
- Analyze current architecture
|
||||
- Identify affected components
|
||||
- Map dependencies and impacts
|
||||
|
||||
2. CLI Command Generation:
|
||||
- Build Gemini/Qwen/Codex command
|
||||
- Include architecture context
|
||||
- Apply ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt template
|
||||
|
||||
3. Execution & Output:
|
||||
- Execute strategic planning
|
||||
- Generate modification plan
|
||||
- Save to .workflow/.chat/
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Planning only**: Creates modification plans, does NOT generate code
|
||||
- **Template**: Uses `~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt` for strategic planning
|
||||
- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
|
||||
|
||||
## CLI Command Templates
|
||||
|
||||
**Gemini/Qwen** (default, planning only):
|
||||
```bash
|
||||
cd [dir] && gemini -p "
|
||||
PURPOSE: [goal]
|
||||
TASK: Architecture planning
|
||||
MODE: analysis
|
||||
CONTEXT: @**/*
|
||||
EXPECTED: Modification plan, impact analysis
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt)
|
||||
"
|
||||
# Qwen: Replace 'gemini' with 'qwen'
|
||||
```
|
||||
|
||||
**Codex** (planning + implementation guidance):
|
||||
```bash
|
||||
codex -C [dir] --full-auto exec "
|
||||
PURPOSE: [goal]
|
||||
TASK: Architecture planning
|
||||
MODE: analysis
|
||||
CONTEXT: @**/*
|
||||
EXPECTED: Plan, implementation roadmap
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt)
|
||||
" -m gpt-5 --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Output
|
||||
|
||||
- **With session**: `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
|
||||
- **No session**: `.workflow/.scratchpad/plan-[desc]-[timestamp].md`
|
||||
|
||||
## Notes
|
||||
|
||||
- Template: `~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`
|
||||
- See `intelligent-tools-strategy.md` for detailed tool usage
|
||||
Reference in New Issue
Block a user