catlog22/Claude-Code-Workflow
1
0
Fork 0
mirror of https://github.com/catlog22/Claude-Code-Workflow.git synced 2026-02-12 02:37:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: consolidate CLI commands and templates structure

Browse Source 
- Consolidate Gemini, Qwen, and Codex commands into unified CLI commands
- Add new code-analysis mode template
- Update context-gather documentation
- Remove redundant tool-specific command files

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
catlog22
2025-09-30 15:52:26 +08:00
parent 76bd4885d3
commit 029f3a3c12
25 changed files with 1306 additions and 2423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
.claude/commands/cli/analyze.md Normal file
View File

@@ -0,0 +1,201 @@
---
name: analyze
description: Quick codebase analysis using CLI tools (codex/gemini/qwen)
usage: /cli:analyze [--tool <codex|gemini|qwen>] [--enhance] <analysis-target>
argument-hint: "[--tool codex|gemini|qwen] [--enhance] analysis target"
examples:
- /cli:analyze "authentication patterns"
- /cli:analyze --tool qwen "API security"
- /cli:analyze --tool codex --enhance "performance bottlenecks"
allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
---
# CLI Analyze Command (/cli:analyze)
## Purpose
Execute CLI tool analysis on codebase patterns, architecture, or code quality.
**Supported Tools**: codex, gemini (default), qwen
## Execution Flow
1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
2. **If `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` and use enhanced output
3. Parse analysis target (original or enhanced)
4. Detect analysis type (pattern/architecture/security/quality)
5. Build command for selected tool with template
6. Execute analysis
7. Return results
## Core Rules
1. **Tool Selection**: Use `--tool` value or default to gemini
2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis when `--enhance` present
3. **Execute Immediately**: Build and run command without preliminary analysis
4. **Template Selection**: Auto-select template based on keywords
5. **Context Inclusion**: Always include CLAUDE.md in context
6. **Direct Output**: Return tool output directly to user
## Tool Selection
| Tool | Wrapper | Best For | Permissions |
|------|---------|----------|-------------|
| **gemini** (default) | `~/.claude/scripts/gemini-wrapper` | Analysis, exploration, documentation | Read-only |
| **qwen** | `~/.claude/scripts/qwen-wrapper` | Architecture, code generation | Read-only for analyze |
| **codex** | `codex --full-auto exec` | Development analysis, deep inspection | `-s danger-full-access --skip-git-repo-check` |
## Enhancement Integration
**When `--enhance` flag present**:
```bash
# Step 1: Enhance the prompt
SlashCommand(command="/enhance-prompt \"[analysis-target]\"")
# Step 2: Use enhanced output as analysis target
# Enhanced output provides:
# - INTENT: Clear technical goal
# - CONTEXT: Session memory + patterns
# - ACTION: Implementation steps
# - ATTENTION: Critical constraints
```
**Example**:
```bash
# User: /gemini:analyze --enhance "fix auth issues"
# Step 1: Enhance
/enhance-prompt "fix auth issues"
# Returns:
# INTENT: Debug authentication failures
# CONTEXT: JWT implementation in src/auth/, known token expiry issue
# ACTION: Analyze token lifecycle → verify refresh flow → check middleware
# ATTENTION: Preserve existing session management
# Step 2: Analyze with enhanced context
cd . && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: Debug authentication failures (from enhanced: JWT token lifecycle)
TASK: Analyze token lifecycle, refresh flow, and middleware integration
CONTEXT: @{src/auth/**/*} @{CLAUDE.md} Session context: known token expiry issue
EXPECTED: Root cause analysis with file references
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/security.txt) | Focus on JWT token handling
"
```
## Analysis Types
| Type | Keywords | Template | Context |
|------|----------|----------|---------|
| **pattern** | pattern, hooks, usage | analysis/pattern.txt | Matched files + CLAUDE.md |
| **architecture** | architecture, structure, design | analysis/architecture.txt | Full codebase + CLAUDE.md |
| **security** | security, vulnerability, auth | analysis/security.txt | Matched files + CLAUDE.md |
| **quality** | quality, test, coverage | analysis/quality.txt | Source + test files + CLAUDE.md |
## Command Templates
### Gemini (Default)
```bash
cd [target-dir] && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: [analysis goal from user input]
TASK: [specific analysis task]
CONTEXT: @{[file-patterns]} @{CLAUDE.md}
EXPECTED: [expected output format]
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
"
```
### Qwen
```bash
cd [target-dir] && ~/.claude/scripts/qwen-wrapper -p "
PURPOSE: [analysis goal from user input]
TASK: [specific analysis task]
CONTEXT: @{[file-patterns]} @{CLAUDE.md}
EXPECTED: [expected output format]
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
"
```
### Codex
```bash
codex -C [target-dir] --full-auto exec "
PURPOSE: [analysis goal from user input]
TASK: [specific analysis task]
CONTEXT: @{[file-patterns]} @{CLAUDE.md}
EXPECTED: [expected output format]
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/[category]/[template].txt) | [constraints]
" --skip-git-repo-check -s danger-full-access
```
## Examples
**Pattern Analysis (Gemini - default)**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: Analyze authentication patterns
TASK: Identify auth implementation patterns and conventions
CONTEXT: @{**/*auth*} @{CLAUDE.md}
EXPECTED: Pattern summary with file references
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt) | Focus on security
"
```
**Architecture Review (Qwen)**:
```bash
# User: /cli:analyze --tool qwen "component architecture"
cd . && ~/.claude/scripts/qwen-wrapper -p "
PURPOSE: Review component architecture
TASK: Analyze component structure and dependencies
CONTEXT: @{src/**/*} @{CLAUDE.md}
EXPECTED: Architecture diagram and integration points
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt) | Focus on modularity
"
```
**Deep Inspection (Codex)**:
```bash
# User: /cli:analyze --tool codex "performance bottlenecks"
codex -C . --full-auto exec "
PURPOSE: Identify performance bottlenecks
TASK: Deep analysis of performance issues
CONTEXT: @{src/**/*} @{CLAUDE.md}
EXPECTED: Performance metrics and optimization recommendations
RULES: Focus on computational complexity and memory usage
" --skip-git-repo-check -s danger-full-access
```
## File Pattern Logic
**Keyword Matching**:
- "auth" → `@{**/*auth*}`
- "component" → `@{src/components/**/*}`
- "API" → `@{**/api/**/*}`
- "test" → `@{**/*.test.*}`
- Generic → `@{src/**/*}` or `@{**/*}`
## Session Integration
**Detect Active Session**: Check for `.workflow/.active-*` marker file
**If Session Active**:
- Save results to `.workflow/WFS-[id]/.chat/analysis-[timestamp].md`
- Include session context in analysis
**If No Session**:
- Return results directly to user
## Output Format
Return Gemini's output directly, which includes:
- File references (file:line format)
- Code snippets
- Pattern analysis
- Recommendations
## Error Handling
- **Missing Template**: Use generic analysis prompt
- **No Context**: Use `@{**/*}` as fallback
- **Command Failure**: Report error and suggest manual command

161
.claude/commands/cli/chat.md Normal file
View File

@@ -0,0 +1,161 @@
---
name: chat
description: Simple CLI interaction command for direct codebase analysis
usage: /cli:chat [--tool <codex|gemini|qwen>] [--enhance] "inquiry"
argument-hint: "[--tool codex|gemini|qwen] [--enhance] inquiry"
examples:
- /cli:chat "analyze the authentication flow"
- /cli:chat --tool qwen --enhance "optimize React component"
- /cli:chat --tool codex "review security vulnerabilities"
allowed-tools: SlashCommand(*), Bash(*)
model: sonnet
---
### 🚀 **Command Overview: `/cli:chat`**
- **Type**: CLI Tool Wrapper for Interactive Analysis
- **Purpose**: Direct interaction with CLI tools for codebase analysis
- **Supported Tools**: codex, gemini (default), qwen
### 📥 **Parameters & Usage**
- **`<inquiry>` (Required)**: Your question or analysis request
- **`--tool <codex|gemini|qwen>` (Optional)**: Select CLI tool (default: gemini)
- **`--enhance` (Optional)**: Enhance inquiry with `/enhance-prompt` before execution
- **`--all-files` (Optional)**: Includes the entire codebase in the analysis context
- **`--save-session` (Optional)**: Saves the interaction to current workflow session directory
- **File References**: Specify files or patterns using `@{path/to/file}` syntax
### 🔄 **Execution Workflow**
`Parse Tool` **->** `Parse Input` **->** `[Optional] Enhance` **->** `Assemble Context` **->** `Construct Prompt` **->** `Execute CLI Tool` **->** `(Optional) Save Session`
### 🛠️ **Tool Selection**
| Tool | Best For | Wrapper |
|------|----------|---------|
| **gemini** (default) | General analysis, exploration | `~/.claude/scripts/gemini-wrapper` |
| **qwen** | Architecture, design patterns | `~/.claude/scripts/qwen-wrapper` |
| **codex** | Development queries, deep analysis | `codex --full-auto exec` |
### 🔄 **Original Execution Workflow**
`Parse Input` **->** `[Optional] Enhance` **->** `Assemble Context` **->** `Construct Prompt` **->** `Execute Gemini CLI` **->** `(Optional) Save Session`
### 🎯 **Enhancement Integration**
**When `--enhance` flag present**:
```bash
# Step 1: Enhance the inquiry
SlashCommand(command="/enhance-prompt \"[inquiry]\"")
# Step 2: Use enhanced output for chat
# Enhanced output provides enriched context and structured intent
```
**Example**:
```bash
# User: /gemini:chat --enhance "fix the login"
# Step 1: Enhance
/enhance-prompt "fix the login"
# Returns:
# INTENT: Debug login authentication failure
# CONTEXT: JWT auth in src/auth/, session state issue
# ACTION: Check token validation → verify middleware → test flow
# Step 2: Chat with enhanced context
gemini -p "Debug login authentication failure. Focus on JWT token validation
in src/auth/, verify middleware integration, and test authentication flow.
Known issue: session state management"
```
### 📚 **Context Assembly**
Context is gathered from:
1. **Project Guidelines**: Always includes `@{CLAUDE.md,**/*CLAUDE.md}`
2. **User-Explicit Files**: Files specified by the user (e.g., `@{src/auth/*.js}`)
3. **All Files Flag**: The `--all-files` flag includes the entire codebase
### 📝 **Prompt Format**
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
```bash
cd [directory] && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: [clear analysis/inquiry goal]
TASK: [specific analysis or question]
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} @{target_files}
EXPECTED: [expected response format]
RULES: [constraints or focus areas]
"
```
### ⚙️ **Execution Implementation**
**Standard Template**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: [user inquiry goal]
TASK: [specific question or analysis]
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} @{inferred_or_specified_files}
EXPECTED: Analysis with file references and code examples
RULES: [focus areas based on inquiry]
"
```
**With --all-files flag**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: [user inquiry goal]
TASK: [specific question or analysis]
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase]
EXPECTED: Comprehensive analysis across all files
RULES: [focus areas based on inquiry]
"
```
**Example - Authentication Analysis**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: Understand authentication flow implementation
TASK: Analyze authentication flow and identify patterns
CONTEXT: @{**/*auth*,**/*login*} @{CLAUDE.md}
EXPECTED: Flow diagram, security assessment, integration points
RULES: Focus on security patterns and JWT handling
"
```
**Example - Performance Optimization**:
```bash
cd src/components && ~/.claude/scripts/gemini-wrapper -p "
PURPOSE: Optimize React component performance
TASK: Identify performance bottlenecks in component rendering
CONTEXT: @{**/*.{jsx,tsx}} @{CLAUDE.md}
EXPECTED: Specific optimization recommendations with file:line references
RULES: Focus on re-render patterns and memoization opportunities
"
```
### 💾 **Session Persistence**
When `--save-session` flag is used:
- Check for existing active session (`.workflow/.active-*` markers)
- Save to existing session's `.chat/` directory or create new session
- File format: `chat-YYYYMMDD-HHMMSS.md`
- Include query, context, and response in saved file
**Session Template:**
```markdown
# Chat Session: [Timestamp]
## Query
[Original user inquiry]
## Context
[Files and patterns included in analysis]
## Gemini Response
[Complete response from Gemini CLI]
```

222
.claude/commands/gemini/gemini-init.md → .claude/commands/cli/cli-init.md
View File

@@ -1,43 +1,61 @@
---
name: gemini-init
description: Initialize Gemini CLI configuration with .gemini config and .geminiignore based on workspace analysis
usage: /gemini:gemini-init [--output=<path>] [--preview]
argument-hint: [optional: output path, preview flag]
name: cli-init
description: Initialize CLI tool configurations (Gemini and Qwen) based on workspace analysis
usage: /cli:cli-init [--tool <gemini|qwen|all>] [--output=<path>] [--preview]
argument-hint: "[--tool gemini|qwen|all] [--output path] [--preview]"
examples:
- /gemini:gemini-init
- /gemini:gemini-init --output=.config/
- /gemini:gemini-init --preview
- /cli:cli-init
- /cli:cli-init --tool qwen
- /cli:cli-init --tool all --preview
- /cli:cli-init --output=.config/
allowed-tools: Bash(*), Read(*), Write(*), Glob(*)
---
# Gemini Initialization Command
# CLI Initialization Command (/cli:cli-init)
## Overview
Initializes Gemini CLI configuration for the workspace by:
Initializes CLI tool configurations for the workspace by:
1. Analyzing current workspace using `get_modules_by_depth.sh` to identify technology stacks
2. Generating `.geminiignore` file with filtering rules optimized for detected technologies
3. Creating `.gemini` configuration file with contextfilename and other settings
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. **Gemini Config Creation**: Generates `.gemini` file with contextfilename and workspace-specific settings
4. **Ignore Rules Generation**: Creates `.geminiignore` file with filtering patterns for detected technologies
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
#### .gemini Configuration Directory
Creates `.gemini/` directory containing configuration files:
- `.gemini/settings.json` - Main configuration with contextfilename setting:
#### Configuration Directories
Creates tool-specific configuration directories:
**For Gemini** (`.gemini/`):
- `.gemini/settings.json`:
```json
{
"contextfilename": "CLAUDE.md"
}
```
#### .geminiignore Filter File
Uses gitignore syntax to filter files from Gemini CLI analysis
**For Qwen** (`.qwen/`):
- `.qwen/settings.json`:
```json
{
"contextfilename": "CLAUDE.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
@@ -124,39 +142,65 @@ target/
## Command Options
### Basic Usage
### Tool Selection
**Initialize All Tools (default)**:
```bash
/gemini:gemini-init
/cli:cli-init
```
- Analyzes workspace and generates `.gemini/` directory with `settings.json` and `.geminiignore` in current directory
- Creates backup of existing files if present
- Sets contextfilename to "CLAUDE.md" by default
- 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
/gemini:gemini-init --preview
/cli:cli-init --preview
```
- Shows what would be generated without creating files
- Displays detected technologies, configuration, and ignore rules
### Custom Output Path
```bash
/gemini:gemini-init --output=.config/
/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: Workspace Analysis (MANDATORY FIRST)
### 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 2: Technology Detection
### Step 3: Technology Detection
```bash
# Check for common tech stack indicators
bash(find . -name "package.json" -not -path "*/node_modules/*" | head -1)
@@ -165,22 +209,44 @@ bash(find . -name "pom.xml" -o -name "build.gradle" | head -1)
bash(find . -name "Dockerfile" | head -1)
```
### Step 3: Generate Configuration Files
### Step 4: Generate Configuration Files
**For Gemini** (if --tool is gemini or all):
```bash
# Create .gemini/ directory and settings.json config file
# Create .gemini/ directory and settings.json
mkdir -p .gemini
echo '{"contextfilename": "CLAUDE.md"}' > .gemini/settings.json
# Create .geminiignore file with detected technology rules
# Backup existing files if present
```
### Step 4: Validation
**For Qwen** (if --tool is qwen or all):
```bash
# Create .qwen/ directory and settings.json
mkdir -p .qwen
echo '{"contextfilename": "CLAUDE.md"}' > .qwen/settings.json
# 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* 2>/dev/null || echo "Configuration files created")
bash(ls -la .gemini* .qwen* 2>/dev/null || echo "Configuration files created")
```
## Implementation Process (Technical Details)
### Phase 1: Workspace Analysis
### 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:
@@ -189,7 +255,7 @@ bash(ls -la .gemini* 2>/dev/null || echo "Configuration files created")
- File extensions (.js, .py, .java, etc.)
4. Detect project name from directory name or package.json
### Phase 2: Technology Detection
### Phase 3: Technology Detection
```bash
# Technology detection logic
detect_nodejs() {
@@ -207,33 +273,52 @@ detect_java() {
}
```
### Phase 3: Configuration Generation
1. **Gemini Config (.gemini/ directory)**:
- Create `.gemini/` directory if it doesn't exist
### 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
### Phase 4: Ignore Rules Generation
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 5: File Creation
1. **Generate .gemini/ directory and settings.json**: Create directory structure and JSON configuration file
2. **Generate .geminiignore**: Create organized ignore file with sections
### 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"
}
```
# .geminiignore
# Generated by Claude Code gemini:gemini-ignore command
### 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 Gemini CLI analysis
# This file uses gitignore syntax to filter files for CLI tool analysis
# Edit this file to customize filtering rules for your project
# ============================================================================
@@ -290,13 +375,15 @@ docker-compose.override.yml
### 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 `/gemini:plan`**: Suggest running gemini-ignore for better analysis
- **After `/cli:plan`**: Suggest running cli-init for better analysis
- **Before analysis**: Recommend updating ignore patterns for cleaner results
### CLI Tool Integration
@@ -307,29 +394,62 @@ docker-compose.override.yml
### Basic Project Setup
```bash
# New project - initialize Gemini configuration
/gemini:gemini-init
# 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
/gemini:gemini-init --preview
/cli:cli-init --preview
# Generate in subdirectory
/gemini:gemini-init --output=.config/
/cli:cli-init --output=.config/
```
### Technology Migration
```bash
# After adding new tech stack (e.g., Docker)
/gemini:gemini-init # Regenerates both config and ignore files with new rules
/cli:cli-init # Regenerates all config and ignore files with new rules
# Check what changed
/gemini:gemini-init --preview # Compare with existing configuration
/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
- **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 |

235
.claude/commands/cli/execute.md Normal file
View File

@@ -0,0 +1,235 @@
---
name: execute
description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference
usage: /cli:execute [--tool <codex|gemini|qwen>] [--enhance] <description|task-id>
argument-hint: "[--tool codex|gemini|qwen] [--enhance] description or task-id"
examples:
- /cli:execute "implement user authentication system"
- /cli:execute --tool qwen --enhance "optimize React component"
- /cli:execute --tool codex IMPL-001
- /cli:execute --enhance "fix API performance issues"
allowed-tools: SlashCommand(*), Bash(*)
model: sonnet
---
# CLI Execute Command (/cli:execute)
## Overview
**⚡ YOLO-enabled execution**: Auto-approves all confirmations for streamlined implementation workflow.
**Purpose**: Execute implementation tasks using intelligent context inference and CLI tools with full permissions.
**Supported Tools**: codex, gemini (default), qwen
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
## 🚨 YOLO Permissions
**All confirmations auto-approved by default:**
- ✅ File pattern inference confirmation
- ✅ Gemini execution confirmation
- ✅ File modification confirmation
- ✅ Implementation summary generation
## 🎯 Enhancement Integration
**When `--enhance` flag present** (for Description Mode only):
```bash
# Step 1: Enhance the description
SlashCommand(command="/enhance-prompt \"[description]\"")
# Step 2: Use enhanced output for execution
# Enhanced output provides:
# - INTENT: Clear technical goal
# - CONTEXT: Session memory + codebase patterns
# - ACTION: Specific implementation steps
# - ATTENTION: Critical constraints
```
**Example**:
```bash
# User: /gemini:execute --enhance "fix login"
# Step 1: Enhance
/enhance-prompt "fix login"
# Returns:
# INTENT: Debug authentication failure in login flow
# CONTEXT: JWT auth in src/auth/, known token expiry issue
# ACTION: Fix token validation → update refresh logic → test flow
# ATTENTION: Preserve existing session management
# Step 2: Execute with enhanced context
gemini --all-files -p "@{src/auth/**/*} @{CLAUDE.md}
Implementation: Debug authentication failure in login flow
Focus: Token validation, refresh logic, test flow
Constraints: Preserve existing session management"
```
**Note**: `--enhance` only applies to Description Mode. Task ID Mode uses task JSON directly.
## Execution Modes
### 1. Description Mode (supports --enhance)
**Input**: Natural language description
```bash
/gemini:execute "implement JWT authentication with middleware"
/gemini:execute --enhance "implement JWT authentication with middleware"
```
**Process**: [Optional: Enhance] → Keyword analysis → Pattern inference → Context collection → Execution
### 2. Task ID Mode (no --enhance)
**Input**: Workflow task identifier
```bash
/gemini:execute IMPL-001
```
**Process**: Task JSON parsing → Scope analysis → Context integration → Execution
## Context Inference Logic
**Auto-selects relevant files based on:**
- **Keywords**: "auth" → `@{**/*auth*,**/*user*}`
- **Technology**: "React" → `@{src/**/*.{jsx,tsx}}`
- **Task Type**: "api" → `@{**/api/**/*,**/routes/**/*}`
- **Always includes**: `@{CLAUDE.md,**/*CLAUDE.md}`
## Command Options
| Option | Purpose |
|--------|---------|
| `--debug` | Verbose execution logging |
| `--save-session` | Save complete execution session to workflow |
## Workflow Integration
### Session Management
⚠️ **Auto-detects active session**: Checks `.workflow/.active-*` marker file
**Session storage:**
- **Active session exists**: Saves to `.workflow/WFS-[topic]/.chat/execute-[timestamp].md`
- **No active session**: Creates new session directory
### Task Integration
```bash
# Execute specific workflow task
/gemini:execute IMPL-001
# Loads from: .task/IMPL-001.json
# Uses: task context, brainstorming refs, scope definitions
# Updates: workflow status, generates summary
```
## Execution Templates
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
### Permission Requirements
**Gemini Write Access** (when file modifications needed):
- Add `--approval-mode yolo` flag for auto-approval
- Required for: file creation, modification, deletion
### User Description Template
```bash
cd [target-directory] && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
PURPOSE: [clear implementation goal from description]
TASK: [specific implementation task]
CONTEXT: @{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Implementation code with file:line locations, test cases, integration guidance
RULES: [template reference if applicable] | [constraints]
"
```
**Example**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
PURPOSE: Implement JWT authentication with middleware
TASK: Create authentication system with token validation
CONTEXT: @{**/*auth*,**/*middleware*} @{CLAUDE.md}
EXPECTED: Auth service, middleware, tests with file modifications
RULES: Follow existing auth patterns | Security best practices
"
```
### Task ID Template
```bash
cd [task-directory] && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
PURPOSE: [task_title]
TASK: Execute [task-id] implementation
CONTEXT: @{task_files} @{brainstorming_refs} @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Complete implementation following acceptance criteria
RULES: $(cat [task_template]) | Task type: [task_type], Scope: [task_scope]
"
```
**Example**:
```bash
cd .workflow/WFS-123 && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
PURPOSE: Implement user profile editing
TASK: Execute IMPL-001 implementation
CONTEXT: @{src/user/**/*} @{.brainstorming/feature-planner/analysis.md} @{CLAUDE.md}
EXPECTED: Profile edit API, UI components, validation, tests
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/feature.txt) | Type: feature, Scope: user module
"
```
## Auto-Generated Outputs
### 1. Implementation Summary
**Location**: `.summaries/[TASK-ID]-summary.md` or auto-generated ID
```markdown
# Task Summary: [Task-ID] [Description]
## Implementation
- **Files Modified**: [file:line references]
- **Features Added**: [specific functionality]
- **Context Used**: [inferred patterns]
## Integration
- [Links to workflow documents]
```
### 2. Execution Session
**Location**: `.chat/execute-[timestamp].md`
```markdown
# Execution Session: [Timestamp]
## Input
[User description or Task ID]
## Context Inference
[File patterns used with rationale]
## Implementation Results
[Generated code and modifications]
## Status Updates
[Workflow integration updates]
```
## Error Handling
- **Task ID not found**: Lists available tasks
- **Pattern inference failure**: Uses generic `src/**/*` pattern
- **Execution failure**: Attempts fallback with simplified context
- **File modification errors**: Reports specific file/permission issues
## Performance Features
- **Smart caching**: Frequently used pattern mappings
- **Progressive inference**: Precise → broad pattern fallback
- **Parallel execution**: When multiple contexts needed
- **Directory optimization**: Switches to optimal execution path
## Integration Workflow
**Typical sequence:**
1. `workflow:plan` → Creates tasks
2. `/gemini:execute IMPL-001` → Executes with YOLO permissions
3. Auto-updates workflow status and generates summaries
4. `workflow:review` → Final validation
**vs. `/gemini:analyze`**: Execute performs analysis **and implementation**, analyze is read-only.

114
.claude/commands/cli/mode/bug-index.md Normal file
View File

@@ -0,0 +1,114 @@
---
name: bug-index
description: Bug analysis and fix suggestions using CLI tools
usage: /cli:mode:bug-index [--tool <codex|gemini|qwen>] [--enhance] [--cd "path"] "bug description"
argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
examples:
- /cli:mode:bug-index "authentication null pointer error"
- /cli:mode:bug-index --tool qwen --enhance "login not working"
- /cli:mode:bug-index --tool codex --cd "src/auth" "token validation fails"
allowed-tools: SlashCommand(*), Bash(*)
model: sonnet
---
# CLI Mode: Bug Index (/cli:mode:bug-index)
## Purpose
Execute systematic bug analysis and fix suggestions using CLI tools with diagnostic template.
**Supported Tools**: codex, gemini (default), qwen
## Execution Flow
1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
2. **If `--enhance` flag present**: Execute `/enhance-prompt "[bug-description]"` first
3. Parse bug description (original or enhanced)
4. Detect target directory (from `--cd` or auto-infer)
5. Build command for selected tool with bug-fix template
6. Execute analysis
7. Save to session (if active)
## Core Rules
1. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis
2. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
3. **Template Required**: Always use bug-fix template
4. **Session Output**: Save to `.workflow/WFS-[id]/.chat/bug-index-[timestamp].md`
## Command Template
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
```bash
cd [directory] && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: [bug analysis goal]
TASK: Systematic bug analysis and fix recommendations
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
EXPECTED: Root cause analysis, code path tracing, targeted fixes
RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [description]
"
```
## Examples
**Basic Bug Analysis**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: Debug authentication null pointer error
TASK: Identify root cause and provide fix
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Root cause, code path, minimal fix, impact assessment
RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: null pointer in login flow
"
```
**Directory-Specific**:
```bash
cd src/auth && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: Fix token validation failure
TASK: Analyze token validation bug in auth module
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Validation logic analysis, fix recommendation
RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: token validation fails intermittently
"
```
**With Enhancement**:
```bash
# User: /gemini:mode:bug-index --enhance "login broken"
# Step 1: Enhance
/enhance-prompt "login broken"
# Returns:
# INTENT: Debug login authentication failure
# CONTEXT: Known session state issue
# ACTION: Check session management → verify token → test flow
# Step 2: Analyze with enhanced context
cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: Debug login authentication failure
TASK: Analyze session management, token handling, auth flow
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} Known: session state issue
EXPECTED: Root cause in session/token, targeted fix
RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Focus on session management
"
```
## Analysis Focus
**Template provides**:
- **Root Cause Analysis**: Systematic investigation
- **Code Path Tracing**: Execution flow analysis
- **Targeted Solutions**: Minimal, specific fixes
- **Impact Assessment**: Side effect evaluation
## Session Output
**Location**: `.workflow/WFS-[topic]/.chat/bug-index-[timestamp].md`
**Includes**:
- Bug description
- Template used
- Analysis results
- Recommended actions

204
.claude/commands/cli/mode/code-analysis.md Normal file
View File

@@ -0,0 +1,204 @@
---
name: code-analysis
description: Deep code analysis and debugging using CLI tools with specialized template
usage: /cli:mode:code-analysis [--tool <codex|gemini|qwen>] [--enhance] [--cd "path"] "analysis target"
argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target"
examples:
- /cli:mode:code-analysis "analyze authentication flow logic"
- /cli:mode:code-analysis --tool qwen --enhance "explain data transformation pipeline"
- /cli:mode:code-analysis --tool codex --cd "src/core" "trace execution path for user registration"
allowed-tools: SlashCommand(*), Bash(*)
model: sonnet
---
# CLI Mode: Code Analysis (/cli:mode:code-analysis)
## Purpose
Execute systematic code analysis and debugging using CLI tools with specialized code analysis template.
**Supported Tools**: codex, gemini (default), qwen
## Execution Flow
1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
2. **If `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` first
3. Parse analysis target (original or enhanced)
4. Detect target directory (from `--cd` or auto-infer)
5. Build command for selected tool with code-analysis template
6. Execute deep analysis
7. Save to session (if active)
## Core Rules
1. **Tool Selection**: Use `--tool` value or default to gemini
2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis
3. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
4. **Template Required**: Always use code-analysis template
5. **Session Output**: Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
## Analysis Capabilities
The code-analysis template provides:
- **Systematic Code Analysis**: Break down complex code into manageable parts
- **Execution Path Tracing**: Track variable states and call stacks
- **Control & Data Flow**: Understand code logic and data transformations
- **Call Flow Visualization**: Diagram function calling sequences
- **Logical Reasoning**: Explain "why" behind code behavior
- **Debugging Insights**: Identify potential bugs or inefficiencies
## Command Templates
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
### Gemini (Default)
```bash
cd [directory] && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: [analysis goal from target]
TASK: Deep code analysis with execution path tracing
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
EXPECTED: Systematic analysis, call flow diagram, data transformations, logical explanation
RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on [specific aspect]
"
```
### Qwen
```bash
cd [directory] && ~/.claude/scripts/qwen-wrapper --all-files -p "
PURPOSE: [analysis goal from target]
TASK: Architecture-level code analysis and pattern recognition
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
EXPECTED: Architectural insights, design patterns, code structure analysis
RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on [specific aspect]
"
```
### Codex
```bash
codex -C [directory] --full-auto exec "
PURPOSE: [analysis goal from target]
TASK: Deep code inspection with debugging insights
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
EXPECTED: Execution trace, bug identification, optimization opportunities
RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on [specific aspect]
" --skip-git-repo-check -s danger-full-access
```
## Examples
**Basic Code Analysis (Gemini)**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: Analyze authentication flow logic
TASK: Trace authentication execution path and identify key functions
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Step-by-step flow, call diagram, data passing between functions
RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on control flow and security
"
```
**Architecture Analysis (Qwen)**:
```bash
# User: /cli:mode:code-analysis --tool qwen "explain data transformation pipeline"
cd . && ~/.claude/scripts/qwen-wrapper --all-files -p "
PURPOSE: Explain data transformation pipeline architecture
TASK: Analyze data flow and transformation patterns
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Pipeline structure, transformation stages, data format changes
RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on data flow and patterns
"
```
**Deep Debugging (Codex)**:
```bash
# User: /cli:mode:code-analysis --tool codex --cd "src/core" "trace execution path for user registration"
codex -C src/core --full-auto exec "
PURPOSE: Trace execution path for user registration
TASK: Deep analysis of registration flow with debugging insights
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Complete execution trace, variable states, potential issues
RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on edge cases and error handling
" --skip-git-repo-check -s danger-full-access
```
**With Enhancement**:
```bash
# User: /cli:mode:code-analysis --enhance "why is login slow"
# Step 1: Enhance
/enhance-prompt "why is login slow"
# Returns:
# INTENT: Identify performance bottlenecks in login flow
# CONTEXT: Authentication module, database queries
# ACTION: Trace execution path → identify slow operations → suggest optimizations
# Step 2: Analyze with enhanced context
cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: Identify performance bottlenecks in login flow
TASK: Trace login execution path and measure operation costs
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} @{**/*auth*,**/*login*}
EXPECTED: Performance analysis, bottleneck identification, optimization recommendations
RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on performance and database queries
"
```
## Analysis Output Structure
Based on code-analysis.md template, output includes:
### 1. 思考过程 (Thinking Process)
- Analysis strategy and approach
- Key assumptions about code behavior
### 2. 对问题的理解 (Understanding)
- Restate analysis target
- Confirm understanding of requirements
### 3. 核心解答 (Core Answer)
- Direct, concise answer to analysis question
### 4. 详细分析与调用逻辑 (Detailed Analysis)
- **代码段识别**: Relevant code sections
- **执行流程**: Step-by-step execution flow
- **调用图**: Visual call flow diagram with symbols:
- `───►` Function call
- `◄───` Return
- `│` Continuation
- `├─` Intermediate step
- `└─` Last step in block
- **数据传递**: Data passing and state changes
- **逻辑解释**: Why code behaves this way
### 5. 总结 (Summary)
- Key findings and recommendations
## Session Output
**Location**: `.workflow/WFS-[topic]/.chat/code-analysis-[timestamp].md`
**Includes**:
- Analysis target
- Template used
- Complete structured analysis
- Call flow diagrams
- Debugging insights
- Recommendations
## Use Cases
| Use Case | Best Tool | Focus |
|----------|-----------|-------|
| **Understand execution flow** | gemini | Call sequences, data flow |
| **Architectural patterns** | qwen | Design patterns, structure |
| **Performance debugging** | codex | Bottlenecks, optimizations |
| **Bug investigation** | codex | Error paths, edge cases |
| **Code review** | gemini | Logic correctness, clarity |
| **Refactoring planning** | qwen | Structure improvements |
## Tool Selection Guide
- **Gemini**: Best for general code understanding and tracing
- **Qwen**: Best for architectural analysis and pattern recognition
- **Codex**: Best for deep debugging and performance analysis

104
.claude/commands/cli/mode/plan.md Normal file
View File

@@ -0,0 +1,104 @@
---
name: plan
description: Project planning and architecture analysis using CLI tools
usage: /cli:mode:plan [--tool <codex|gemini|qwen>] [--enhance] [--cd "path"] "topic"
argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
examples:
- /cli:mode:plan "design user dashboard"
- /cli:mode:plan --tool qwen --enhance "plan microservices migration"
- /cli:mode:plan --tool codex --cd "src/auth" "authentication system"
allowed-tools: SlashCommand(*), Bash(*)
model: sonnet
---
# CLI Mode: Plan (/cli:mode:plan)
## Purpose
Execute planning and architecture analysis using CLI tools with specialized template.
**Supported Tools**: codex, gemini (default), qwen
## Execution Flow
1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
2. **If `--enhance` flag present**: Execute `/enhance-prompt "[topic]"` first
3. Parse topic (original or enhanced)
4. Detect target directory (from `--cd` or auto-infer)
5. Build command for selected tool with planning template
6. Execute analysis
7. Save to session (if active)
## Core Rules
1. **Enhance First (if flagged)**: Execute `/enhance-prompt` before planning
2. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
3. **Template Required**: Always use planning template
4. **Session Output**: Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
## Command Template
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
```bash
cd [directory] && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: [planning goal from topic]
TASK: Comprehensive planning and architecture analysis
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
EXPECTED: Strategic insights, implementation roadmap, key decisions
RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on [topic area]
"
```
## Examples
**Basic Planning**:
```bash
cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: Design user dashboard feature architecture
TASK: Comprehensive architecture planning for dashboard
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Architecture design, component structure, implementation roadmap
RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on scalability and UX
"
```
**Directory-Specific**:
```bash
cd src/auth && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: Plan authentication system redesign
TASK: Analyze current auth and plan improvements
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
EXPECTED: Migration strategy, security improvements, timeline
RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on security and backward compatibility
"
```
**With Enhancement**:
```bash
# User: /gemini:mode:plan --enhance "fix auth issues"
# Step 1: Enhance
/enhance-prompt "fix auth issues"
# Returns structured planning context
# Step 2: Plan with enhanced input
cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
PURPOSE: [enhanced goal]
TASK: [enhanced task description]
CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [enhanced context]
EXPECTED: Strategic plan with enhanced requirements
RULES: $(cat ~/.claude/prompt-templates/plan.md) | [enhanced constraints]
"
```
## Session Output
**Location**: `.workflow/WFS-[topic]/.chat/plan-[timestamp].md`
**Includes**:
- Planning topic
- Template used
- Analysis results
- Implementation roadmap
- Key decisions

155
.claude/commands/codex/analyze.md
View File

@@ -1,155 +0,0 @@
---
name: analyze
description: Quick analysis of codebase patterns, architecture, and code quality using Codex CLI
usage: /codex:analyze <analysis-type>
argument-hint: "analysis target or type"
examples:
- /codex:analyze "React hooks patterns"
- /codex:analyze "authentication security"
- /codex:analyze "performance bottlenecks"
- /codex:analyze "API design patterns"
model: haiku
---
# Codex Analysis Command (/codex:analyze)
## Overview
Quick analysis tool for codebase insights using intelligent pattern detection and template-driven analysis with Codex CLI.
**Core Guidelines**: @~/.claude/workflows/tools-implementation-guide.md
⚠️ **Critical Difference**: Codex has **NO `--all-files` flag** - you MUST use `@` patterns to reference files.
## Analysis Types
| Type | Purpose | Example |
|------|---------|---------|
| **pattern** | Code pattern detection | "React hooks usage patterns" |
| **architecture** | System structure analysis | "component hierarchy structure" |
| **security** | Security vulnerabilities | "authentication vulnerabilities" |
| **performance** | Performance bottlenecks | "rendering performance issues" |
| **quality** | Code quality assessment | "testing coverage analysis" |
| **dependencies** | Third-party analysis | "outdated package dependencies" |
## Quick Usage
### Basic Analysis
```bash
/codex:analyze "authentication patterns"
```
**Executes**: `codex --full-auto exec "@{**/*auth*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt)" -s danger-full-access`
### Targeted Analysis
```bash
/codex:analyze "React component architecture"
```
**Executes**: `codex --full-auto exec "@{src/components/**/*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt)" -s danger-full-access`
### Security Focus
```bash
/codex:analyze "API security vulnerabilities"
```
**Executes**: `codex --full-auto exec "@{**/api/**/*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/analysis/security.txt)" -s danger-full-access`
## Codex-Specific Patterns
**Essential File Patterns** (Required for Codex):
```bash
@{**/*} # All files recursively
@{src/**/*} # All source files
@{*.ts,*.js} # Specific file types
@{CLAUDE.md,**/*CLAUDE.md} # Documentation hierarchy
@{package.json,*.config.*} # Configuration files
```
## Templates Used
Templates are automatically selected based on analysis type:
- **Pattern Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt`
- **Architecture Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt`
- **Security Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/security.txt`
- **Performance Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/performance.txt`
## Workflow Integration
⚠️ **Session Check**: Automatically detects active workflow session via `.workflow/.active-*` marker file.
**Analysis results saved to:**
- Active session: `.workflow/WFS-[topic]/.chat/analysis-[timestamp].md`
- No session: Temporary analysis output
## Common Patterns
### Technology Stack Analysis
```bash
/codex:analyze "project technology stack"
# Executes: codex --full-auto exec "@{package.json,*.config.*,CLAUDE.md} [analysis prompt]" -s danger-full-access
```
### Code Quality Review
```bash
/codex:analyze "code quality and standards"
# Executes: codex --full-auto exec "@{src/**/*,test/**/*,CLAUDE.md} [analysis prompt]" -s danger-full-access
```
### Migration Planning
```bash
/codex:analyze "legacy code modernization"
# Executes: codex --full-auto exec "@{**/*.{js,jsx,ts,tsx},CLAUDE.md} [analysis prompt]" -s danger-full-access
```
### Module-Specific Analysis
```bash
/codex:analyze "authentication module patterns"
# Executes: codex --full-auto exec "@{src/auth/**/*,**/*auth*,CLAUDE.md} [analysis prompt]" -s danger-full-access
```
## Output Format
Analysis results include:
- **File References**: Specific file:line locations
- **Code Examples**: Relevant code snippets
- **Patterns Found**: Common patterns and anti-patterns
- **Recommendations**: Actionable improvements
- **Integration Points**: How components connect
## Execution Templates
### Basic Analysis Template
```bash
codex --full-auto exec "@{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md}
Analysis Type: [analysis_type]
Provide:
- Pattern identification and analysis
- Code quality assessment
- Architecture insights
- Specific recommendations with file:line references" -s danger-full-access
```
### Template-Enhanced Analysis
```bash
codex --full-auto exec "@{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/analysis/[template].txt)
Focus: [analysis_type]
Context: [user_description]" -s danger-full-access
```
## Error Prevention
- **Always include @ patterns**: Commands without file references will fail
- **Test patterns first**: Validate @ patterns match existing files
- **Use comprehensive patterns**: `@{**/*}` when unsure of file structure
- **Include documentation**: Always add `@{CLAUDE.md,**/*CLAUDE.md}` for context
## Codex vs Gemini
| Feature | Codex | Gemini |
|---------|-------|--------|
| File Loading | `@` patterns **required** | `--all-files` available |
| Command Structure | `codex exec "@{patterns}"` | `gemini --all-files -p` |
| Pattern Flexibility | Must be explicit | Auto-includes with flag |
For detailed syntax, patterns, and advanced usage see:
**@~/.claude/workflows/tools-implementation-guide.md**

189
.claude/commands/codex/chat.md
View File

@@ -1,189 +0,0 @@
---
name: chat
description: Simple Codex CLI interaction command for direct codebase analysis and development
usage: /codex:chat "inquiry"
argument-hint: "your question or development request"
examples:
- /codex:chat "analyze the authentication flow"
- /codex:chat "how can I optimize this React component performance?"
- /codex:chat "implement user profile editing functionality"
allowed-tools: Bash(codex:*)
model: sonnet
---
### 🚀 **Command Overview: `/codex:chat`**
- **Type**: Basic Codex CLI Wrapper
- **Purpose**: Direct interaction with the `codex` CLI for simple codebase analysis and development
- **Core Tool**: `Bash(codex:*)` - Executes the external Codex CLI tool
⚠️ **Critical Difference**: Codex has **NO `--all-files` flag** - you MUST use `@` patterns to reference files.
### 📥 **Parameters & Usage**
- **`<inquiry>` (Required)**: Your question or development request
- **`@{patterns}` (Required)**: File patterns must be explicitly specified
- **`--save-session` (Optional)**: Saves the interaction to current workflow session directory
- **`--full-auto` (Optional)**: Enable autonomous development mode
### 🔄 **Execution Workflow**
`Parse Input` **->** `Infer File Patterns` **->** `Construct Prompt` **->** `Execute Codex CLI` **->** `(Optional) Save Session`
### 📚 **Context Assembly**
Context is gathered from:
1. **Project Guidelines**: Always includes `@{CLAUDE.md,**/*CLAUDE.md}`
2. **Inferred Patterns**: Auto-detects relevant files based on inquiry keywords
3. **Comprehensive Fallback**: Uses `@{**/*}` when pattern inference unclear
### 📝 **Prompt Format**
```
=== CONTEXT ===
@{CLAUDE.md,**/*CLAUDE.md} [Project guidelines]
@{inferred_patterns} [Auto-detected or comprehensive patterns]
=== USER INPUT ===
[The user inquiry text]
```
### ⚙️ **Execution Implementation**
```pseudo
FUNCTION execute_codex_chat(user_inquiry, flags):
// Always include project guidelines
patterns = "@{CLAUDE.md,**/*CLAUDE.md}"
// Infer relevant file patterns from inquiry keywords
inferred_patterns = infer_file_patterns(user_inquiry)
IF inferred_patterns:
patterns += "," + inferred_patterns
ELSE:
patterns += ",@{**/*}" // Fallback to all files
// Construct prompt
prompt = "=== CONTEXT ===\n" + patterns + "\n"
prompt += "\n=== USER INPUT ===\n" + user_inquiry
// Execute codex CLI
IF flags contain "--full-auto":
result = execute_tool("Bash(codex:*)", "--full-auto", prompt)
ELSE:
result = execute_tool("Bash(codex:*)", "exec", prompt)
// Save session if requested
IF flags contain "--save-session":
save_chat_session(user_inquiry, patterns, result)
RETURN result
END FUNCTION
```
### 🎯 **Pattern Inference Logic**
**Auto-detects file patterns based on keywords:**
| Keywords | Inferred Pattern | Purpose |
|----------|-----------------|---------|
| "auth", "login", "user" | `@{**/*auth*,**/*user*}` | Authentication code |
| "React", "component" | `@{src/**/*.{jsx,tsx}}` | React components |
| "API", "endpoint", "route" | `@{**/api/**/*,**/routes/**/*}` | API code |
| "test", "spec" | `@{test/**/*,**/*.test.*,**/*.spec.*}` | Test files |
| "config", "setup" | `@{*.config.*,package.json}` | Configuration |
| "database", "db", "model" | `@{**/models/**/*,**/db/**/*}` | Database code |
| "style", "css" | `@{**/*.{css,scss,sass}}` | Styling files |
**Fallback**: If no keywords match, uses `@{**/*}` for comprehensive analysis.
### 💾 **Session Persistence**
When `--save-session` flag is used:
- Check for existing active session (`.workflow/.active-*` markers)
- Save to existing session's `.chat/` directory or create new session
- File format: `chat-YYYYMMDD-HHMMSS.md`
- Include query, context patterns, and response in saved file
**Session Template:**
```markdown
# Chat Session: [Timestamp]
## Query
[Original user inquiry]
## Context Patterns
[File patterns used in analysis]
## Codex Response
[Complete response from Codex CLI]
## Pattern Inference
[How file patterns were determined]
```
### 🔧 **Usage Examples**
#### Basic Development Chat
```bash
/codex:chat "implement password reset functionality"
# Executes: codex --full-auto exec "@{CLAUDE.md,**/*CLAUDE.md,**/*auth*,**/*user*} implement password reset functionality" -s danger-full-access
```
#### Architecture Discussion
```bash
/codex:chat "how should I structure the user management module?"
# Executes: codex --full-auto exec "@{CLAUDE.md,**/*CLAUDE.md,**/*user*,src/**/*} how should I structure the user management module?" -s danger-full-access
```
#### Performance Optimization
```bash
/codex:chat "optimize React component rendering performance"
# Executes: codex --full-auto exec "@{CLAUDE.md,**/*CLAUDE.md,src/**/*.{jsx,tsx}} optimize React component rendering performance" -s danger-full-access
```
#### Full Auto Mode
```bash
/codex:chat "create a complete user dashboard with charts" --full-auto
# Executes: codex --full-auto exec "@{CLAUDE.md,**/*CLAUDE.md,**/*user*,**/*dashboard*} create a complete user dashboard with charts" -s danger-full-access
```
### ⚠️ **Error Prevention**
- **Pattern validation**: Ensures @ patterns match existing files
- **Fallback patterns**: Uses comprehensive `@{**/*}` when inference fails
- **Context verification**: Always includes project guidelines
- **Session handling**: Graceful handling of missing workflow directories
### 📊 **Codex vs Gemini Chat**
| Feature | Codex Chat | Gemini Chat |
|---------|------------|-------------|
| File Loading | `@` patterns **required** | `--all-files` available |
| Pattern Inference | Automatic keyword-based | Manual or --all-files |
| Development Focus | Code generation & implementation | Analysis & exploration |
| Automation | `--full-auto` mode available | Interactive only |
| Command Structure | `codex exec "@{patterns}"` | `gemini --all-files -p` |
### 🚀 **Advanced Features**
#### Multi-Pattern Inference
```bash
/codex:chat "implement React authentication with API integration"
# Infers: @{CLAUDE.md,**/*CLAUDE.md,src/**/*.{jsx,tsx},**/*auth*,**/api/**/*}
```
#### Context-Aware Development
```bash
/codex:chat "add unit tests for the payment processing module"
# Infers: @{CLAUDE.md,**/*CLAUDE.md,**/*payment*,test/**/*,**/*.test.*}
```
#### Configuration Analysis
```bash
/codex:chat "review and optimize build configuration"
# Infers: @{CLAUDE.md,**/*CLAUDE.md,*.config.*,package.json,webpack.*,vite.*}
```
For detailed syntax, patterns, and advanced usage see:
**@~/.claude/workflows/tools-implementation-guide.md**

223
.claude/commands/codex/execute.md
View File

@@ -1,223 +0,0 @@
---
name: execute
description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference using Codex CLI
usage: /codex:execute <description|task-id>
argument-hint: "implementation description or task-id"
examples:
- /codex:execute "implement user authentication system"
- /codex:execute "optimize React component performance"
- /codex:execute IMPL-001
- /codex:execute "fix API performance issues"
allowed-tools: Bash(codex:*)
model: sonnet
---
# Codex Execute Command (/codex:execute)
## Overview
**⚡ YOLO-enabled execution**: Auto-approves all confirmations for streamlined implementation workflow.
**Purpose**: Execute implementation tasks using intelligent context inference and Codex CLI with full permissions.
**Core Guidelines**: @~/.claude/workflows/tools-implementation-guide.md
⚠️ **Critical Difference**: Codex has **NO `--all-files` flag** - you MUST use `@` patterns to reference files.
## 🚨 YOLO Permissions
**All confirmations auto-approved by default:**
- ✅ File pattern inference confirmation
- ✅ Codex execution confirmation
- ✅ File modification confirmation
- ✅ Implementation summary generation
## Execution Modes
### 1. Description Mode
**Input**: Natural language description
```bash
/codex:execute "implement JWT authentication with middleware"
```
**Process**: Keyword analysis → Pattern inference → Context collection → Execution
### 2. Task ID Mode
**Input**: Workflow task identifier
```bash
/codex:execute IMPL-001
```
**Process**: Task JSON parsing → Scope analysis → Context integration → Execution
### 3. Full Auto Mode
**Input**: Complex development tasks
```bash
/codex:execute "create complete todo application with React and TypeScript"
```
**Process**: Uses `codex --full-auto ... -s danger-full-access` for autonomous implementation
## Context Inference Logic
**Auto-selects relevant files based on:**
- **Keywords**: "auth" → `@{**/*auth*,**/*user*}`
- **Technology**: "React" → `@{src/**/*.{jsx,tsx}}`
- **Task Type**: "api" → `@{**/api/**/*,**/routes/**/*}`
- **Always includes**: `@{CLAUDE.md,**/*CLAUDE.md}`
## Essential Codex Patterns
**Required File Patterns** (No --all-files available):
```bash
@{**/*} # All files recursively (equivalent to --all-files)
@{src/**/*} # All source files
@{*.ts,*.js} # Specific file types
@{CLAUDE.md,**/*CLAUDE.md} # Documentation hierarchy
@{package.json,*.config.*} # Configuration files
```
## Command Options
| Option | Purpose |
|--------|---------|
| `--debug` | Verbose execution logging |
| `--save-session` | Save complete execution session to workflow |
| `--full-auto` | Enable autonomous development mode |
## Workflow Integration
### Session Management
⚠️ **Auto-detects active session**: Checks `.workflow/.active-*` marker file
**Session storage:**
- **Active session exists**: Saves to `.workflow/WFS-[topic]/.chat/execute-[timestamp].md`
- **No active session**: Creates new session directory
### Task Integration
```bash
# Execute specific workflow task
/codex:execute IMPL-001
# Loads from: .task/impl-001.json
# Uses: task context, brainstorming refs, scope definitions
# Updates: workflow status, generates summary
```
## Execution Templates
### User Description Template
```bash
codex --full-auto exec "@{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md}
Implementation Task: [user_description]
Provide:
- Specific implementation code
- File modification locations (file:line)
- Test cases
- Integration guidance" -s danger-full-access
```
### Task ID Template
```bash
codex --full-auto exec "@{task_files} @{brainstorming_refs} @{CLAUDE.md,**/*CLAUDE.md}
Task: [task_title] (ID: [task-id])
Type: [task_type]
Scope: [task_scope]
Execute implementation following task acceptance criteria." -s danger-full-access
```
### Full Auto Template
```bash
codex --full-auto exec "@{**/*} @{CLAUDE.md,**/*CLAUDE.md}
Development Task: [user_description]
Autonomous implementation with:
- Architecture decisions
- Code generation
- Testing
- Documentation" -s danger-full-access
```
## Auto-Generated Outputs
### 1. Implementation Summary
**Location**: `.summaries/[TASK-ID]-summary.md` or auto-generated ID
```markdown
# Task Summary: [Task-ID] [Description]
## Implementation
- **Files Modified**: [file:line references]
- **Features Added**: [specific functionality]
- **Context Used**: [inferred patterns]
## Integration
- [Links to workflow documents]
```
### 2. Execution Session
**Location**: `.chat/execute-[timestamp].md`
```markdown
# Execution Session: [Timestamp]
## Input
[User description or Task ID]
## Context Inference
[File patterns used with rationale]
## Implementation Results
[Generated code and modifications]
## Status Updates
[Workflow integration updates]
```
## Development Templates Used
Based on task type, automatically selects:
- **Feature Development**: `~/.claude/workflows/cli-templates/prompts/development/feature.txt`
- **Component Creation**: `~/.claude/workflows/cli-templates/prompts/development/component.txt`
- **Code Refactoring**: `~/.claude/workflows/cli-templates/prompts/development/refactor.txt`
- **Bug Fixing**: `~/.claude/workflows/cli-templates/prompts/development/debugging.txt`
- **Test Generation**: `~/.claude/workflows/cli-templates/prompts/development/testing.txt`
## Error Handling
- **Task ID not found**: Lists available tasks
- **Pattern inference failure**: Uses generic `@{src/**/*}` pattern
- **Execution failure**: Attempts fallback with simplified context
- **File modification errors**: Reports specific file/permission issues
- **Missing @ patterns**: Auto-adds `@{**/*}` for comprehensive context
## Performance Features
- **Smart caching**: Frequently used pattern mappings
- **Progressive inference**: Precise → broad pattern fallback
- **Parallel execution**: When multiple contexts needed
- **Directory optimization**: Uses `--cd` flag when beneficial
## Integration Workflow
**Typical sequence:**
1. `workflow:plan` → Creates tasks
2. `/codex:execute IMPL-001` → Executes with YOLO permissions
3. Auto-updates workflow status and generates summaries
4. `workflow:review` → Final validation
**vs. `/codex:analyze`**: Execute performs analysis **and implementation**, analyze is read-only.
## Codex vs Gemini Execution
| Feature | Codex | Gemini |
|---------|-------|--------|
| File Loading | `@` patterns **required** | `--all-files` available |
| Automation Level | Full autonomous with `--full-auto` | Manual implementation |
| Command Structure | `codex exec "@{patterns}"` | `gemini --all-files -p` |
| Development Focus | Code generation & implementation | Analysis & planning |
For detailed patterns, syntax, and templates see:
**@~/.claude/workflows/tools-implementation-guide.md**

285
.claude/commands/codex/mode/auto.md
View File

@@ -1,285 +0,0 @@
---
name: auto
description: Full autonomous development mode with intelligent template selection and execution
usage: /codex:mode:auto "description of development task"
argument-hint: "description of what you want to develop or implement"
examples:
- /codex:mode:auto "create user authentication system with JWT"
- /codex:mode:auto "build real-time chat application with React"
- /codex:mode:auto "implement payment processing with Stripe integration"
- /codex:mode:auto "develop REST API with user management features"
allowed-tools: Bash(ls:*), Bash(codex:*)
model: sonnet
---
# Full Auto Development Mode (/codex:mode:auto)
## Overview
Leverages Codex's `--full-auto` mode for autonomous development with intelligent template selection and comprehensive context gathering.
**Process**: Analyze Input → Select Templates → Gather Context → Execute Autonomous Development
⚠️ **Critical Feature**: Uses `codex --full-auto ... -s danger-full-access` for maximum autonomous capability with mandatory `@` pattern requirements.
## Usage
### Autonomous Development Examples
```bash
# Complete application development
/codex:mode:auto "create todo application with React and TypeScript"
# Feature implementation
/codex:mode:auto "implement user authentication with JWT and refresh tokens"
# System integration
/codex:mode:auto "add payment processing with Stripe to existing e-commerce system"
# Architecture implementation
/codex:mode:auto "build microservices API with user management and notification system"
```
## Template Selection Logic
### Dynamic Template Discovery
**Templates auto-discovered from**: `~/.claude/workflows/cli-templates/prompts/`
Templates are dynamically read from development-focused directories:
- `development/` - Feature implementation, component creation, refactoring
- `automation/` - Project scaffolding, migration, deployment
- `analysis/` - Architecture analysis, pattern detection
- `integration/` - API design, database operations
### Template Metadata Parsing
Each template contains YAML frontmatter with:
```yaml
---
name: template-name
description: Template purpose description
category: development|automation|analysis|integration
keywords: [keyword1, keyword2, keyword3]
development_type: feature|component|refactor|debug|testing
---
```
**Auto-selection based on:**
- **Development keywords**: Matches user input against development-specific keywords
- **Template type**: Direct matching for development types
- **Architecture patterns**: Semantic matching for system design
- **Technology stack**: Framework and library detection
## Command Execution
### Step 1: Template Discovery
```bash
# Dynamically discover development templates
cd "~/.claude/workflows/cli-templates/prompts" && echo "Discovering development templates..." && for dir in development automation analysis integration; do if [ -d "$dir" ]; then echo "=== $dir templates ==="; for template_file in "$dir"/*.txt; do if [ -f "$template_file" ]; then echo "Template: $(basename "$template_file")"; head -10 "$template_file" 2>/dev/null | grep -E "^(name|description|keywords):" || echo "No metadata"; echo; fi; done; fi; done
```
### Step 2: Dynamic Template Analysis & Selection
```pseudo
FUNCTION select_development_template(user_input):
template_dirs = ["development", "automation", "analysis", "integration"]
template_metadata = {}
# Parse all development templates for metadata
FOR each dir in template_dirs:
templates = list_files("~/.claude/workflows/cli-templates/prompts/" + dir + "/*.txt")
FOR each template_file in templates:
content = read_file(template_file)
yaml_front = extract_yaml_frontmatter(content)
template_metadata[template_file] = {
"name": yaml_front.name,
"description": yaml_front.description,
"keywords": yaml_front.keywords || [],
"category": yaml_front.category || dir,
"development_type": yaml_front.development_type || "general"
}
input_lower = user_input.toLowerCase()
best_match = null
highest_score = 0
# Score each template against user input
FOR each template, metadata in template_metadata:
score = 0
# Development keyword matching (highest weight)
development_keywords = ["implement", "create", "build", "develop", "add", "generate"]
FOR each dev_keyword in development_keywords:
IF input_lower.contains(dev_keyword):
score += 5
# Template-specific keyword matching
FOR each keyword in metadata.keywords:
IF input_lower.contains(keyword.toLowerCase()):
score += 3
# Development type matching
IF input_lower.contains(metadata.development_type.toLowerCase()):
score += 4
# Technology stack detection
tech_keywords = ["react", "vue", "angular", "node", "express", "api", "database", "auth"]
FOR each tech in tech_keywords:
IF input_lower.contains(tech):
score += 2
IF score > highest_score:
highest_score = score
best_match = template
# Default to feature.txt for development tasks
RETURN best_match || "development/feature.txt"
END FUNCTION
```
### Step 3: Execute with Full Auto Mode
```bash
# Autonomous development execution with comprehensive context
codex --full-auto "@{**/*} @{CLAUDE.md,**/*CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/[selected_template])
Development Task: [user_input]
Autonomous Implementation Requirements:
- Complete feature development
- Code generation with best practices
- Automatic testing integration
- Documentation updates
- Error handling and validation" -s danger-full-access
```
## Essential Codex Auto Patterns
**Required File Patterns** (Comprehensive context for autonomous development):
```bash
@{**/*} # All files for full context understanding
@{src/**/*} # Source code for pattern detection
@{package.json,*.config.*} # Configuration and dependencies
@{CLAUDE.md,**/*CLAUDE.md} # Project guidelines and standards
@{test/**/*,**/*.test.*} # Existing tests for pattern matching
@{docs/**/*,README.*} # Documentation for context
```
## Development Template Categories
### Feature Development Templates
- **feature.txt**: Complete feature implementation with integration
- **component.txt**: Reusable component creation with props and state
- **refactor.txt**: Code improvement and optimization
### Automation Templates
- **scaffold.txt**: Project structure and boilerplate generation
- **migration.txt**: System upgrades and data migrations
- **deployment.txt**: CI/CD and deployment automation
### Analysis Templates (for context)
- **architecture.txt**: System structure understanding
- **pattern.txt**: Code pattern detection for consistency
- **security.txt**: Security analysis for safe development
### Integration Templates
- **api-design.txt**: RESTful API development
- **database.txt**: Database schema and operations
## Options
| Option | Purpose |
|--------|---------|
| `--list-templates` | Show available development templates and exit |
| `--template <name>` | Force specific template (overrides auto-selection) |
| `--debug` | Show template selection reasoning and context patterns |
| `--save-session` | Save complete development session to workflow |
| `--no-auto` | Use `codex exec` instead of `--full-auto` mode |
### Manual Template Override
```bash
# Force specific development template
/codex:mode:auto "user authentication" --template component.txt
/codex:mode:auto "fix login issues" --template debugging.txt
```
### Development Template Listing
```bash
# List all available development templates
/codex:mode:auto --list-templates
# Output:
# Development templates in ~/.claude/workflows/cli-templates/prompts/:
# - development/feature.txt (Complete feature implementation) [Keywords: implement, feature, integration]
# - development/component.txt (Reusable component creation) [Keywords: component, react, vue]
# - automation/scaffold.txt (Project structure generation) [Keywords: scaffold, setup, boilerplate]
# - [any-new-template].txt (Auto-discovered from any category)
```
## Auto-Selection Examples
### Development Task Detection
```bash
# Feature development → development/feature.txt
"implement user dashboard with analytics charts"
# Component creation → development/component.txt
"create reusable button component with multiple variants"
# System architecture → automation/scaffold.txt
"build complete e-commerce platform with React and Node.js"
# API development → integration/api-design.txt
"develop REST API for user management with authentication"
# Performance optimization → development/refactor.txt
"optimize React application performance and bundle size"
```
## Autonomous Development Workflow
### Full Context Gathering
1. **Project Analysis**: `@{**/*}` provides complete codebase context
2. **Pattern Detection**: Understands existing code patterns and conventions
3. **Dependency Analysis**: Reviews package.json and configuration files
4. **Test Pattern Recognition**: Follows existing test structures
### Intelligent Implementation
1. **Architecture Decisions**: Makes informed choices based on existing patterns
2. **Code Generation**: Creates code matching project style and conventions
3. **Integration**: Ensures new code integrates seamlessly with existing system
4. **Quality Assurance**: Includes error handling, validation, and testing
### Autonomous Features
- **Smart File Creation**: Creates necessary files and directories
- **Dependency Management**: Adds required packages automatically
- **Test Generation**: Creates comprehensive test suites
- **Documentation Updates**: Updates relevant documentation files
- **Configuration Updates**: Modifies config files as needed
## Session Integration
When `--save-session` used, saves to:
`.workflow/WFS-[topic]/.chat/auto-[template]-[timestamp].md`
**Session includes:**
- Original development request
- Template selection reasoning
- Complete context patterns used
- Autonomous development results
- Files created/modified
- Integration guidance
## Performance Features
- **Parallel Context Loading**: Loads multiple file patterns simultaneously
- **Smart Caching**: Caches template selections for similar requests
- **Progressive Development**: Builds features incrementally with validation
- **Rollback Capability**: Can revert changes if issues detected
## Codex vs Gemini Auto Mode
| Feature | Codex Auto | Gemini Auto |
|---------|------------|-------------|
| Primary Purpose | Autonomous development | Analysis and planning |
| File Loading | `@{**/*}` required | `--all-files` available |
| Output | Complete implementations | Analysis and recommendations |
| Template Focus | Development-oriented | Analysis-oriented |
| Execution Mode | `--full-auto` autonomous | Interactive guidance |
This command maximizes Codex's autonomous development capabilities while ensuring comprehensive context and intelligent template selection for optimal results.

269
.claude/commands/codex/mode/bug-index.md
View File

@@ -1,269 +0,0 @@
---
name: bug-index
description: Bug analysis, debugging, and automated fix implementation using Codex
usage: /codex:mode:bug-index "bug description"
argument-hint: "description of the bug or error you're experiencing"
examples:
- /codex:mode:bug-index "authentication null pointer error in login flow"
- /codex:mode:bug-index "React component not re-rendering after state change"
- /codex:mode:bug-index "database connection timeout in production"
- /codex:mode:bug-index "API endpoints returning 500 errors randomly"
allowed-tools: Bash(codex:*)
model: sonnet
---
# Bug Analysis & Fix Command (/codex:mode:bug-index)
## Overview
Systematic bug analysis, debugging, and automated fix implementation using expert diagnostic templates with Codex CLI.
**Core Guidelines**: @~/.claude/workflows/tools-implementation-guide.md
⚠️ **Critical Difference**: Codex has **NO `--all-files` flag** - you MUST use `@` patterns to reference files.
**Enhancement over Gemini**: Codex can **analyze AND implement fixes**, not just provide recommendations.
## Usage
### Basic Bug Analysis & Fix
```bash
/codex:mode:bug-index "authentication error during login"
```
**Executes**: `codex --full-auto exec "@{**/*auth*,**/*login*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/development/debugging.txt)" -s danger-full-access`
### Comprehensive Bug Investigation
```bash
/codex:mode:bug-index "React state not updating in dashboard"
```
**Executes**: `codex --full-auto exec "@{src/**/*.{jsx,tsx},**/*dashboard*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/development/debugging.txt)" -s danger-full-access`
### Production Error Analysis
```bash
/codex:mode:bug-index "API timeout issues in production environment"
```
**Executes**: `codex --full-auto exec "@{**/api/**/*,*.config.*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/development/debugging.txt)" -s danger-full-access`
## Codex-Specific Debugging Patterns
**Essential File Patterns** (Required for effective debugging):
```bash
@{**/*error*,**/*bug*} # Error-related files
@{src/**/*} # Source code for bug analysis
@{**/logs/**/*} # Log files for error traces
@{test/**/*,**/*.test.*} # Tests to understand expected behavior
@{CLAUDE.md,**/*CLAUDE.md} # Project guidelines
@{*.config.*,package.json} # Configuration for environment issues
```
## Command Execution
**Debugging Template Used**: `~/.claude/workflows/cli-templates/prompts/development/debugging.txt`
**Executes**:
```bash
codex exec "@{inferred_bug_patterns} @{CLAUDE.md,**/*CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/development/debugging.txt)
Context: Comprehensive codebase analysis for bug investigation
Bug Description: [user_description]
Fix Implementation: Provide working code solutions" -s danger-full-access
```
## Bug Pattern Inference
**Auto-detects relevant files based on bug description:**
| Bug Keywords | Inferred Patterns | Focus Area |
|-------------|------------------|------------|
| "auth", "login", "token" | `@{**/*auth*,**/*user*,**/*login*}` | Authentication code |
| "React", "component", "render" | `@{src/**/*.{jsx,tsx}}` | React components |
| "API", "endpoint", "server" | `@{**/api/**/*,**/routes/**/*}` | Backend code |
| "database", "db", "query" | `@{**/models/**/*,**/db/**/*}` | Database code |
| "timeout", "connection" | `@{*.config.*,**/*config*}` | Configuration issues |
| "test", "spec" | `@{test/**/*,**/*.test.*}` | Test-related bugs |
| "build", "compile" | `@{*.config.*,package.json,webpack.*}` | Build issues |
| "style", "css", "layout" | `@{**/*.{css,scss,sass}}` | Styling bugs |
## Analysis & Fix Focus
### Comprehensive Bug Analysis Provides:
- **Root Cause Analysis**: Systematic investigation with file:line references
- **Code Path Tracing**: Following execution flow through the codebase
- **Error Pattern Detection**: Identifying similar issues across the codebase
- **Context Understanding**: Leveraging existing code patterns
- **Impact Assessment**: Understanding potential side effects of fixes
### Codex Enhancement - Automated Fixes:
- **Working Code Solutions**: Actual implementation fixes
- **Multiple Fix Options**: Different approaches with trade-offs
- **Test Case Generation**: Tests to prevent regression
- **Configuration Updates**: Environment and config fixes
- **Documentation Updates**: Updated comments and documentation
## Debugging Templates & Approaches
### Error Investigation
```bash
# Uses: debugging.txt template for systematic analysis
/codex:mode:bug-index "null pointer exception in user service"
# Provides: Stack trace analysis, variable state inspection, fix implementation
```
### Performance Bug Analysis
```bash
# Uses: debugging.txt + performance.txt combination
/codex:mode:bug-index "slow database queries causing timeout"
# Provides: Query optimization, indexing suggestions, connection pool fixes
```
### Integration Bug Fixes
```bash
# Uses: debugging.txt + integration/api-design.txt
/codex:mode:bug-index "third-party API integration failing randomly"
# Provides: Error handling, retry logic, fallback implementations
```
## Options
| Option | Purpose |
|--------|---------|
| `--comprehensive` | Use `@{**/*}` for complete codebase analysis |
| `--save-session` | Save bug analysis and fixes to workflow session |
| `--implement-fix` | Auto-implement the recommended fix (default in Codex) |
| `--generate-tests` | Create tests to prevent regression |
| `--debug-mode` | Verbose debugging output with pattern explanations |
### Comprehensive Debugging
```bash
/codex:mode:bug-index "intermittent authentication failures" --comprehensive
# Uses: @{**/*} for complete system analysis
```
### Bug Fix with Testing
```bash
/codex:mode:bug-index "user registration validation errors" --generate-tests
# Provides: Bug fix + comprehensive test suite
```
## Session Output
When `--save-session` used, saves to:
`.workflow/WFS-[topic]/.chat/bug-index-[timestamp].md`
**Session includes:**
- Bug description and symptoms
- File patterns used for analysis
- Root cause analysis with evidence
- Implemented fix with code changes
- Test cases to prevent regression
- Monitoring and prevention recommendations
## Debugging Output Structure
### Bug Analysis Template Output:
```markdown
# Bug Analysis: [Description]
## Problem Investigation
- Symptoms and error messages
- Affected components and files
- Reproduction steps
## Root Cause Analysis
- Code path analysis with file:line references
- Variable states and data flow
- Configuration and environment factors
## Implemented Fixes
- Primary solution with code changes
- Alternative approaches considered
- Trade-offs and design decisions
## Testing & Validation
- Test cases to verify fix
- Regression prevention tests
- Performance impact assessment
## Monitoring & Prevention
- Error handling improvements
- Logging enhancements
- Code quality improvements
```
## Context-Aware Bug Fixing
### Existing Pattern Integration
```bash
/codex:mode:bug-index "authentication middleware not working"
# Analyzes existing auth patterns in codebase
# Implements fix consistent with current architecture
# Updates related middleware to match patterns
```
### Technology Stack Compatibility
```bash
/codex:mode:bug-index "React hooks causing infinite renders"
# Reviews current React version and patterns
# Implements fix using appropriate hooks API
# Updates other components with similar issues
```
## Advanced Debugging Features
### Multi-File Bug Tracking
```bash
/codex:mode:bug-index "user data inconsistency between frontend and backend"
# Analyzes both frontend and backend code
# Identifies data flow discrepancies
# Implements synchronized fixes across stack
```
### Production Issue Investigation
```bash
/codex:mode:bug-index "memory leak in production server"
# Reviews server code and configuration
# Analyzes log patterns and resource usage
# Implements monitoring and leak prevention
```
### Error Handling Enhancement
```bash
/codex:mode:bug-index "unhandled promise rejections causing crashes"
# Identifies all async operations without error handling
# Implements comprehensive error handling strategy
# Adds logging and monitoring for similar issues
```
## Bug Prevention Features
- **Pattern Analysis**: Identifies similar bugs across codebase
- **Code Quality Improvements**: Suggests structural improvements
- **Error Handling Enhancement**: Adds robust error handling
- **Test Coverage**: Creates tests to prevent similar issues
- **Documentation Updates**: Improves code documentation
## Codex vs Gemini Bug Analysis
| Feature | Codex Bug-Index | Gemini Bug-Index |
|---------|-----------------|------------------|
| File Context | `@` patterns **required** | `--all-files` available |
| Output | Analysis + working fixes | Analysis + recommendations |
| Implementation | Automatic code changes | Manual implementation needed |
| Testing | Auto-generates test cases | Suggests testing approach |
| Integration | Updates related code | Focuses on specific bug |
## Workflow Integration
### Bug Fixing Workflow
```bash
# 1. Analyze and fix the bug
/codex:mode:bug-index "user login failing with token errors"
# 2. Review the implemented changes
/workflow:review
# 3. Execute any additional tasks identified
/codex:execute "implement additional error handling for edge cases"
```
For detailed syntax, patterns, and advanced usage see:
**@~/.claude/workflows/tools-implementation-guide.md**

260
.claude/commands/codex/mode/plan.md
View File

@@ -1,260 +0,0 @@
---
name: plan
description: Development planning and implementation strategy using specialized templates with Codex
usage: /codex:mode:plan "planning topic"
argument-hint: "development planning topic or implementation challenge"
examples:
- /codex:mode:plan "design user dashboard feature architecture"
- /codex:mode:plan "plan microservices migration with implementation"
- /codex:mode:plan "implement real-time notification system with React"
allowed-tools: Bash(codex:*)
model: sonnet
---
# Development Planning Command (/codex:mode:plan)
## Overview
Comprehensive development planning and implementation strategy using expert planning templates with Codex CLI.
- **Directory Analysis Rule**: When user intends to analyze specific directory (cd XXX), use: `codex --cd XXX --full-auto exec "prompt" -s danger-full-access` or `cd "XXX" && codex --full-auto exec "@{**/*} prompt" -s danger-full-access`
- **Default Mode**: `--full-auto exec` autonomous development mode (RECOMMENDED for all tasks).
⚠️ **Critical Difference**: Codex has **NO `--all-files` flag** - you MUST use `@` patterns to reference files.
## Usage
### Basic Development Planning
```bash
/codex:mode:plan "design authentication system with implementation"
```
**Executes**: `codex --full-auto exec "@{**/*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.txt) design authentication system with implementation" -s danger-full-access`
### Architecture Planning with Context
```bash
/codex:mode:plan "microservices migration strategy"
```
**Executes**: `codex --full-auto exec "@{src/**/*,*.config.*,CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/planning/migration.txt) microservices migration strategy" -s danger-full-access`
### Feature Implementation Planning
```bash
/codex:mode:plan "real-time notifications with WebSocket integration"
```
**Executes**: `codex --full-auto exec "@{**/*} @{CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/development/feature.txt) Additional Planning Context:$(cat ~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.txt) real-time notifications with WebSocket integration" -s danger-full-access`
## Codex-Specific Planning Patterns
**Essential File Patterns** (Required for comprehensive planning):
```bash
@{**/*} # All files for complete context
@{src/**/*} # Source code architecture
@{*.config.*,package.json} # Configuration and dependencies
@{CLAUDE.md,**/*CLAUDE.md} # Project guidelines
@{docs/**/*,README.*} # Documentation for context
@{test/**/*} # Testing patterns
```
## Command Execution
**Planning Templates Used**:
- Primary: `~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.txt`
- Migration: `~/.claude/workflows/cli-templates/prompts/planning/migration.txt`
- Combined with development templates for implementation guidance
**Executes**:
```bash
codex exec "@{**/*} @{CLAUDE.md,**/*CLAUDE.md} $(cat ~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.txt)
Context: Complete codebase analysis for informed planning
Planning Topic: [user_description]
Implementation Focus: Development strategy with code generation guidance"
```
## Planning Focus Areas
### Development Planning Provides:
- **Requirements Analysis**: Functional and technical requirements
- **Architecture Design**: System structure with implementation details
- **Implementation Strategy**: Step-by-step development approach with code examples
- **Technology Selection**: Framework and library recommendations
- **Task Decomposition**: Detailed task breakdown with dependencies
- **Code Structure Planning**: File organization and module design
- **Testing Strategy**: Test planning and coverage approach
- **Integration Planning**: API design and data flow
### Codex Enhancement:
- **Implementation Guidance**: Actual code patterns and examples
- **Automated Scaffolding**: Template generation for planned components
- **Dependency Analysis**: Required packages and configurations
- **Pattern Detection**: Leverages existing codebase patterns
## Planning Templates
### Task Breakdown Planning
```bash
# Uses: planning/task-breakdown.txt
/codex:mode:plan "implement user authentication system"
# Provides: Detailed task list, dependencies, implementation order
```
### Migration Planning
```bash
# Uses: planning/migration.txt
/codex:mode:plan "migrate from REST to GraphQL API"
# Provides: Migration strategy, compatibility planning, rollout approach
```
### Feature Planning with Implementation
```bash
# Uses: development/feature.txt + planning/task-breakdown.txt
/codex:mode:plan "build real-time chat application"
# Provides: Architecture + implementation roadmap + code examples
```
## Options
| Option | Purpose |
|--------|---------|
| `--comprehensive` | Use `@{**/*}` for complete codebase context |
| `--save-session` | Save planning analysis to workflow session |
| `--with-implementation` | Include code generation in planning |
| `--template <name>` | Force specific planning template |
### Comprehensive Planning
```bash
/codex:mode:plan "design payment system architecture" --comprehensive
# Uses: @{**/*} pattern for maximum context
```
### Planning with Implementation
```bash
/codex:mode:plan "implement user dashboard" --with-implementation
# Combines planning templates with development templates for actionable output
```
## Session Output
When `--save-session` used, saves to:
`.workflow/WFS-[topic]/.chat/plan-[timestamp].md`
**Session includes:**
- Planning topic and requirements
- Template combination used
- Complete architecture analysis
- Implementation roadmap with tasks
- Code structure recommendations
- Technology stack decisions
- Integration strategies
- Next steps and action items
## Planning Template Structure
### Task Breakdown Template Output:
```markdown
# Development Plan: [Topic]
## Requirements Analysis
- Functional requirements
- Technical requirements
- Constraints and dependencies
## Architecture Design
- System components
- Data flow
- Integration points
## Implementation Strategy
- Development phases
- Task breakdown
- Dependencies and blockers
- Estimated effort
## Code Structure
- File organization
- Module design
- Component hierarchy
## Technology Decisions
- Framework selection
- Library recommendations
- Configuration requirements
## Testing Approach
- Testing strategy
- Coverage requirements
- Test automation
## Action Items
- [ ] Detailed task list with priorities
- [ ] Implementation order
- [ ] Review checkpoints
```
## Context-Aware Planning
### Existing Codebase Integration
```bash
/codex:mode:plan "add user roles and permissions system"
# Analyzes existing authentication patterns
# Plans integration with current user management
# Suggests compatible implementation approach
```
### Technology Stack Analysis
```bash
/codex:mode:plan "implement real-time features"
# Reviews current tech stack (React, Node.js, etc.)
# Recommends compatible WebSocket/SSE solutions
# Plans integration with existing architecture
```
## Planning Workflow Integration
### Pre-Development Planning
1. **Architecture Analysis**: Understand current system structure
2. **Requirement Planning**: Define scope and objectives
3. **Implementation Strategy**: Create detailed development plan
4. **Task Creation**: Generate actionable tasks for execution
### Planning to Execution Flow
```bash
# 1. Plan the implementation
/codex:mode:plan "implement user dashboard with analytics"
# 2. Execute the plan
/codex:execute "implement user dashboard based on planning analysis"
# 3. Review and iterate
/workflow:review
```
## Codex vs Gemini Planning
| Feature | Codex Planning | Gemini Planning |
|---------|----------------|-----------------|
| File Context | `@` patterns **required** | `--all-files` available |
| Output Focus | Implementation-ready plans | Analysis and strategy |
| Code Examples | Includes actual code patterns | Conceptual guidance |
| Integration | Direct execution pathway | Planning only |
| Templates | Development + planning combined | Planning focused |
## Advanced Planning Features
### Multi-Phase Planning
```bash
/codex:mode:plan "modernize legacy application architecture"
# Provides: Phase-by-phase migration strategy
# Includes: Compatibility planning, risk assessment
# Generates: Implementation timeline with milestones
```
### Cross-System Integration Planning
```bash
/codex:mode:plan "integrate third-party payment system with existing e-commerce"
# Analyzes: Current system architecture
# Plans: Integration approach and data flow
# Recommends: Security and error handling strategies
```
For detailed syntax, patterns, and advanced usage see:
**@~/.claude/workflows/intelligent-tools-strategy.md**

96
.claude/commands/gemini/analyze.md
View File

@@ -1,96 +0,0 @@
---
name: analyze
description: Quick analysis of codebase patterns, architecture, and code quality using Gemini CLI
usage: /gemini:analyze <analysis-type>
argument-hint: "analysis target or type"
examples:
- /gemini:analyze "React hooks patterns"
- /gemini:analyze "authentication security"
- /gemini:analyze "performance bottlenecks"
- /gemini:analyze "API design patterns"
model: haiku
---
# Gemini Analysis Command (/gemini:analyze)
## Overview
Quick analysis tool for codebase insights using intelligent pattern detection and template-driven analysis.
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
## Analysis Types
| Type | Purpose | Example |
|------|---------|---------|
| **pattern** | Code pattern detection | "React hooks usage patterns" |
| **architecture** | System structure analysis | "component hierarchy structure" |
| **security** | Security vulnerabilities | "authentication vulnerabilities" |
| **performance** | Performance bottlenecks | "rendering performance issues" |
| **quality** | Code quality assessment | "testing coverage analysis" |
| **dependencies** | Third-party analysis | "outdated package dependencies" |
## Quick Usage
### Basic Analysis
```bash
/gemini:analyze "authentication patterns"
```
**Executes**: `gemini -p -a "@{**/*auth*} @{CLAUDE.md} $(template:analysis/pattern.txt)"`
### Targeted Analysis
```bash
/gemini:analyze "React component architecture"
```
**Executes**: `gemini -p -a "@{src/components/**/*} @{CLAUDE.md} $(template:analysis/architecture.txt)"`
### Security Focus
```bash
/gemini:analyze "API security vulnerabilities"
```
**Executes**: `gemini -p -a "@{**/api/**/*} @{CLAUDE.md} $(template:analysis/security.txt)"`
## Templates Used
Templates are automatically selected based on analysis type:
- **Pattern Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt`
- **Architecture Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt`
- **Security Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/security.txt`
- **Performance Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/performance.txt`
## Workflow Integration
⚠️ **Session Check**: Automatically detects active workflow session via `.workflow/.active-*` marker file.
**Analysis results saved to:**
- Active session: `.workflow/WFS-[topic]/.chat/analysis-[timestamp].md`
- No session: Temporary analysis output
## Common Patterns
### Technology Stack Analysis
```bash
/gemini:analyze "project technology stack"
# Auto-detects: package.json, config files, dependencies
```
### Code Quality Review
```bash
/gemini:analyze "code quality and standards"
# Auto-targets: source files, test files, CLAUDE.md
```
### Migration Planning
```bash
/gemini:analyze "legacy code modernization"
# Focuses: older patterns, deprecated APIs, upgrade paths
```
## Output Format
Analysis results include:
- **File References**: Specific file:line locations
- **Code Examples**: Relevant code snippets
- **Patterns Found**: Common patterns and anti-patterns
- **Recommendations**: Actionable improvements
- **Integration Points**: How components connect

93
.claude/commands/gemini/chat.md
View File

@@ -1,93 +0,0 @@
---
name: chat
description: Simple Gemini CLI interaction command for direct codebase analysis
usage: /gemini:chat "inquiry"
argument-hint: "your question or analysis request"
examples:
- /gemini:chat "analyze the authentication flow"
- /gemini:chat "how can I optimize this React component performance?"
- /gemini:chat "review security vulnerabilities in src/auth/"
allowed-tools: Bash(gemini:*)
model: sonnet
---
### 🚀 **Command Overview: `/gemini:chat`**
- **Type**: Basic Gemini CLI Wrapper
- **Purpose**: Direct interaction with the `gemini` CLI for simple codebase analysis
- **Core Tool**: `Bash(gemini:*)` - Executes the external Gemini CLI tool
### 📥 **Parameters & Usage**
- **`<inquiry>` (Required)**: Your question or analysis request
- **`--all-files` (Optional)**: Includes the entire codebase in the analysis context
- **`--save-session` (Optional)**: Saves the interaction to current workflow session directory
- **File References**: Specify files or patterns using `@{path/to/file}` syntax
### 🔄 **Execution Workflow**
`Parse Input` **->** `Assemble Context` **->** `Construct Prompt` **->** `Execute Gemini CLI` **->** `(Optional) Save Session`
### 📚 **Context Assembly**
Context is gathered from:
1. **Project Guidelines**: Always includes `@{CLAUDE.md,**/*CLAUDE.md}`
2. **User-Explicit Files**: Files specified by the user (e.g., `@{src/auth/*.js}`)
3. **All Files Flag**: The `--all-files` flag includes the entire codebase
### 📝 **Prompt Format**
```
=== CONTEXT ===
@{CLAUDE.md,**/*CLAUDE.md} [Project guidelines]
@{target_files} [User-specified files or all files if --all-files is used]
=== USER INPUT ===
[The user inquiry text]
```
### ⚙️ **Execution Implementation**
```pseudo
FUNCTION execute_gemini_chat(user_inquiry, flags):
// Construct basic prompt
prompt = "=== CONTEXT ===\n"
prompt += "@{CLAUDE.md,**/*CLAUDE.md}\n"
// Add user-specified files or all files
IF flags contain "--all-files":
result = execute_tool("Bash(gemini:*)", "--all-files", "-p", prompt + user_inquiry)
ELSE:
prompt += "\n=== USER INPUT ===\n" + user_inquiry
result = execute_tool("Bash(gemini:*)", "-p", prompt)
// Save session if requested
IF flags contain "--save-session":
save_chat_session(user_inquiry, result)
RETURN result
END FUNCTION
```
### 💾 **Session Persistence**
When `--save-session` flag is used:
- Check for existing active session (`.workflow/.active-*` markers)
- Save to existing session's `.chat/` directory or create new session
- File format: `chat-YYYYMMDD-HHMMSS.md`
- Include query, context, and response in saved file
**Session Template:**
```markdown
# Chat Session: [Timestamp]
## Query
[Original user inquiry]
## Context
[Files and patterns included in analysis]
## Gemini Response
[Complete response from Gemini CLI]
```

168
.claude/commands/gemini/execute.md
View File

@@ -1,168 +0,0 @@
---
name: execute
description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference
usage: /gemini:execute <description|task-id>
argument-hint: "implementation description or task-id"
examples:
- /gemini:execute "implement user authentication system"
- /gemini:execute "optimize React component performance"
- /gemini:execute IMPL-001
- /gemini:execute "fix API performance issues"
allowed-tools: Bash(gemini:*)
model: sonnet
---
# Gemini Execute Command (/gemini:execute)
## Overview
**⚡ YOLO-enabled execution**: Auto-approves all confirmations for streamlined implementation workflow.
**Purpose**: Execute implementation tasks using intelligent context inference and Gemini CLI with full permissions.
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
## 🚨 YOLO Permissions
**All confirmations auto-approved by default:**
- ✅ File pattern inference confirmation
- ✅ Gemini execution confirmation
- ✅ File modification confirmation
- ✅ Implementation summary generation
## Execution Modes
### 1. Description Mode
**Input**: Natural language description
```bash
/gemini:execute "implement JWT authentication with middleware"
```
**Process**: Keyword analysis → Pattern inference → Context collection → Execution
### 2. Task ID Mode
**Input**: Workflow task identifier
```bash
/gemini:execute IMPL-001
```
**Process**: Task JSON parsing → Scope analysis → Context integration → Execution
## Context Inference Logic
**Auto-selects relevant files based on:**
- **Keywords**: "auth" → `@{**/*auth*,**/*user*}`
- **Technology**: "React" → `@{src/**/*.{jsx,tsx}}`
- **Task Type**: "api" → `@{**/api/**/*,**/routes/**/*}`
- **Always includes**: `@{CLAUDE.md,**/*CLAUDE.md}`
## Command Options
| Option | Purpose |
|--------|---------|
| `--debug` | Verbose execution logging |
| `--save-session` | Save complete execution session to workflow |
## Workflow Integration
### Session Management
⚠️ **Auto-detects active session**: Checks `.workflow/.active-*` marker file
**Session storage:**
- **Active session exists**: Saves to `.workflow/WFS-[topic]/.chat/execute-[timestamp].md`
- **No active session**: Creates new session directory
### Task Integration
```bash
# Execute specific workflow task
/gemini:execute IMPL-001
# Loads from: .task/IMPL-001.json
# Uses: task context, brainstorming refs, scope definitions
# Updates: workflow status, generates summary
```
## Execution Templates
### User Description Template
```bash
gemini --all-files -p "@{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md}
Implementation Task: [user_description]
Provide:
- Specific implementation code
- File modification locations (file:line)
- Test cases
- Integration guidance"
```
### Task ID Template
```bash
gemini --all-files -p "@{task_files} @{brainstorming_refs} @{CLAUDE.md,**/*CLAUDE.md}
Task: [task_title] (ID: [task-id])
Type: [task_type]
Scope: [task_scope]
Execute implementation following task acceptance criteria."
```
## Auto-Generated Outputs
### 1. Implementation Summary
**Location**: `.summaries/[TASK-ID]-summary.md` or auto-generated ID
```markdown
# Task Summary: [Task-ID] [Description]
## Implementation
- **Files Modified**: [file:line references]
- **Features Added**: [specific functionality]
- **Context Used**: [inferred patterns]
## Integration
- [Links to workflow documents]
```
### 2. Execution Session
**Location**: `.chat/execute-[timestamp].md`
```markdown
# Execution Session: [Timestamp]
## Input
[User description or Task ID]
## Context Inference
[File patterns used with rationale]
## Implementation Results
[Generated code and modifications]
## Status Updates
[Workflow integration updates]
```
## Error Handling
- **Task ID not found**: Lists available tasks
- **Pattern inference failure**: Uses generic `src/**/*` pattern
- **Execution failure**: Attempts fallback with simplified context
- **File modification errors**: Reports specific file/permission issues
## Performance Features
- **Smart caching**: Frequently used pattern mappings
- **Progressive inference**: Precise → broad pattern fallback
- **Parallel execution**: When multiple contexts needed
- **Directory optimization**: Switches to optimal execution path
## Integration Workflow
**Typical sequence:**
1. `workflow:plan` → Creates tasks
2. `/gemini:execute IMPL-001` → Executes with YOLO permissions
3. Auto-updates workflow status and generates summaries
4. `workflow:review` → Final validation
**vs. `/gemini:analyze`**: Execute performs analysis **and implementation**, analyze is read-only.

76
.claude/commands/gemini/mode/bug-index.md
View File

@@ -1,76 +0,0 @@
---
name: bug-index
description: Bug analysis and fix suggestions using specialized template
usage: /gemini:mode:bug-index "bug description"
argument-hint: "description of the bug or error you're experiencing"
examples:
- /gemini:mode:bug-index "authentication null pointer error in login flow"
- /gemini:mode:bug-index "React component not re-rendering after state change"
- /gemini:mode:bug-index "database connection timeout in production"
allowed-tools: Bash(gemini:*)
model: sonnet
---
# Bug Analysis Command (/gemini:mode:bug-index)
## Overview
Systematic bug analysis and fix suggestions using expert diagnostic template.
**Directory Analysis Rule**: Intelligent detection of directory context intent - automatically navigate to target directory when analysis scope is directory-specific.
**--cd Parameter Rule**: When `--cd` parameter is provided, always execute `cd "[path]" && gemini --all-files -p "prompt"` to ensure analysis occurs in the specified directory context.
## Usage
### Basic Bug Analysis
```bash
/gemini:mode:bug-index "authentication null pointer error"
```
### Bug Analysis with Directory Context
```bash
/gemini:mode:bug-index "authentication error" --cd "src/auth"
```
### Save to Workflow Session
```bash
/gemini:mode:bug-index "API timeout issues" --save-session
```
## Command Execution
**Template Used**: `~/.claude/prompt-templates/bug-fix.md`
**Executes**:
```bash
# Basic usage
gemini --all-files -p "$(cat ~/.claude/prompt-templates/bug-fix.md)
Bug Description: [user_description]"
# With --cd parameter
cd "[specified_directory]" && gemini --all-files -p "$(cat ~/.claude/prompt-templates/bug-fix.md)
Bug Description: [user_description]"
```
## Analysis Focus
The bug-fix template provides:
- **Root Cause Analysis**: Systematic investigation
- **Code Path Tracing**: Following execution flow
- **Targeted Solutions**: Specific, minimal fixes
- **Impact Assessment**: Understanding side effects
## Session Output
saves to:
`.workflow/WFS-[topic]/.chat/bug-index-[timestamp].md`
**Includes:**
- Bug description
- Template used
- Analysis results
- Recommended actions

62
.claude/commands/gemini/mode/plan.md
View File

@@ -1,62 +0,0 @@
---
name: plan
description: Project planning and architecture analysis using Gemini CLI with specialized template
usage: /gemini:mode:plan "planning topic"
argument-hint: "planning topic or architectural challenge to analyze"
examples:
- /gemini:mode:plan "design user dashboard feature architecture"
- /gemini:mode:plan "plan microservices migration strategy"
- /gemini:mode:plan "implement real-time notification system"
allowed-tools: Bash(gemini:*)
model: sonnet
---
# Planning Analysis Command (/gemini:mode:plan)
## Overview
**This command uses Gemini CLI for comprehensive project planning and architecture analysis.** It leverages Gemini CLI's powerful codebase analysis capabilities combined with expert planning templates to provide strategic insights and implementation roadmaps.
### Key Features
- **Gemini CLI Integration**: Utilizes Gemini CLI's deep codebase analysis for informed planning decisions
**--cd Parameter Rule**: When `--cd` parameter is provided, always execute `cd "[path]" && gemini --all-files -p "prompt"` to ensure analysis occurs in the specified directory context.
## Usage
### Basic Usage
```bash
/gemini:mode:plan "design authentication system"
```
### Directory-Specific Analysis
```bash
/gemini:mode:plan "design authentication system" --cd "src/auth"
```
## Command Execution
**Smart Directory Detection**: Auto-detects relevant directories based on topic keywords
**Executes**:
```bash
# Project-wide analysis
gemini --all-files -p "$(cat ~/.claude/prompt-templates/plan.md)
Planning Topic: [user_description]"
# Directory-specific analysis
cd "[directory]" && gemini --all-files -p "$(cat ~/.claude/prompt-templates/plan.md)
Planning Topic: [user_description]"
```
## Session Output
saves to:
`.workflow/WFS-[topic]/.chat/plan-[timestamp].md`
**Includes:**
- Planning topic
- Template used
- Analysis results
- Implementation roadmap
- Key decisions

96
.claude/commands/qwen/analyze.md
View File

@@ -1,96 +0,0 @@
---
name: analyze
description: Quick analysis of codebase patterns, architecture, and code quality using qwen CLI
usage: /qwen:analyze <analysis-type>
argument-hint: "analysis target or type"
examples:
- /qwen:analyze "React hooks patterns"
- /qwen:analyze "authentication security"
- /qwen:analyze "performance bottlenecks"
- /qwen:analyze "API design patterns"
model: haiku
---
# qwen Analysis Command (/qwen:analyze)
## Overview
Quick analysis tool for codebase insights using intelligent pattern detection and template-driven analysis.
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
## Analysis Types
| Type | Purpose | Example |
|------|---------|---------|
| **pattern** | Code pattern detection | "React hooks usage patterns" |
| **architecture** | System structure analysis | "component hierarchy structure" |
| **security** | Security vulnerabilities | "authentication vulnerabilities" |
| **performance** | Performance bottlenecks | "rendering performance issues" |
| **quality** | Code quality assessment | "testing coverage analysis" |
| **dependencies** | Third-party analysis | "outdated package dependencies" |
## Quick Usage
### Basic Analysis
```bash
/qwen:analyze "authentication patterns"
```
**Executes**: `qwen -p -a "@{**/*auth*} @{CLAUDE.md} $(template:analysis/pattern.txt)"`
### Targeted Analysis
```bash
/qwen:analyze "React component architecture"
```
**Executes**: `qwen -p -a "@{src/components/**/*} @{CLAUDE.md} $(template:analysis/architecture.txt)"`
### Security Focus
```bash
/qwen:analyze "API security vulnerabilities"
```
**Executes**: `qwen -p -a "@{**/api/**/*} @{CLAUDE.md} $(template:analysis/security.txt)"`
## Templates Used
Templates are automatically selected based on analysis type:
- **Pattern Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt`
- **Architecture Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/architecture.txt`
- **Security Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/security.txt`
- **Performance Analysis**: `~/.claude/workflows/cli-templates/prompts/analysis/performance.txt`
## Workflow Integration
⚠️ **Session Check**: Automatically detects active workflow session via `.workflow/.active-*` marker file.
**Analysis results saved to:**
- Active session: `.workflow/WFS-[topic]/.chat/analysis-[timestamp].md`
- No session: Temporary analysis output
## Common Patterns
### Technology Stack Analysis
```bash
/qwen:analyze "project technology stack"
# Auto-detects: package.json, config files, dependencies
```
### Code Quality Review
```bash
/qwen:analyze "code quality and standards"
# Auto-targets: source files, test files, CLAUDE.md
```
### Migration Planning
```bash
/qwen:analyze "legacy code modernization"
# Focuses: older patterns, deprecated APIs, upgrade paths
```
## Output Format
Analysis results include:
- **File References**: Specific file:line locations
- **Code Examples**: Relevant code snippets
- **Patterns Found**: Common patterns and anti-patterns
- **Recommendations**: Actionable improvements
- **Integration Points**: How components connect

93
.claude/commands/qwen/chat.md
View File

@@ -1,93 +0,0 @@
---
name: chat
description: Simple qwen CLI interaction command for direct codebase analysis
usage: /qwen:chat "inquiry"
argument-hint: "your question or analysis request"
examples:
- /qwen:chat "analyze the authentication flow"
- /qwen:chat "how can I optimize this React component performance?"
- /qwen:chat "review security vulnerabilities in src/auth/"
allowed-tools: Bash(qwen:*)
model: sonnet
---
### 🚀 **Command Overview: `/qwen:chat`**
- **Type**: Basic qwen CLI Wrapper
- **Purpose**: Direct interaction with the `qwen` CLI for simple codebase analysis
- **Core Tool**: `Bash(qwen:*)` - Executes the external qwen CLI tool
### 📥 **Parameters & Usage**
- **`<inquiry>` (Required)**: Your question or analysis request
- **`--all-files` (Optional)**: Includes the entire codebase in the analysis context
- **`--save-session` (Optional)**: Saves the interaction to current workflow session directory
- **File References**: Specify files or patterns using `@{path/to/file}` syntax
### 🔄 **Execution Workflow**
`Parse Input` **->** `Assemble Context` **->** `Construct Prompt` **->** `Execute qwen CLI` **->** `(Optional) Save Session`
### 📚 **Context Assembly**
Context is gathered from:
1. **Project Guidelines**: Always includes `@{CLAUDE.md,**/*CLAUDE.md}`
2. **User-Explicit Files**: Files specified by the user (e.g., `@{src/auth/*.js}`)
3. **All Files Flag**: The `--all-files` flag includes the entire codebase
### 📝 **Prompt Format**
```
=== CONTEXT ===
@{CLAUDE.md,**/*CLAUDE.md} [Project guidelines]
@{target_files} [User-specified files or all files if --all-files is used]
=== USER INPUT ===
[The user inquiry text]
```
### ⚙️ **Execution Implementation**
```pseudo
FUNCTION execute_qwen_chat(user_inquiry, flags):
// Construct basic prompt
prompt = "=== CONTEXT ===\n"
prompt += "@{CLAUDE.md,**/*CLAUDE.md}\n"
// Add user-specified files or all files
IF flags contain "--all-files":
result = execute_tool("Bash(qwen:*)", "--all-files", "-p", prompt + user_inquiry)
ELSE:
prompt += "\n=== USER INPUT ===\n" + user_inquiry
result = execute_tool("Bash(qwen:*)", "-p", prompt)
// Save session if requested
IF flags contain "--save-session":
save_chat_session(user_inquiry, result)
RETURN result
END FUNCTION
```
### 💾 **Session Persistence**
When `--save-session` flag is used:
- Check for existing active session (`.workflow/.active-*` markers)
- Save to existing session's `.chat/` directory or create new session
- File format: `chat-YYYYMMDD-HHMMSS.md`
- Include query, context, and response in saved file
**Session Template:**
```markdown
# Chat Session: [Timestamp]
## Query
[Original user inquiry]
## Context
[Files and patterns included in analysis]
## qwen Response
[Complete response from qwen CLI]
```

168
.claude/commands/qwen/execute.md
View File

@@ -1,168 +0,0 @@
---
name: execute
description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference
usage: /qwen:execute <description|task-id>
argument-hint: "implementation description or task-id"
examples:
- /qwen:execute "implement user authentication system"
- /qwen:execute "optimize React component performance"
- /qwen:execute IMPL-001
- /qwen:execute "fix API performance issues"
allowed-tools: Bash(qwen:*)
model: sonnet
---
# qwen Execute Command (/qwen:execute)
## Overview
**⚡ YOLO-enabled execution**: Auto-approves all confirmations for streamlined implementation workflow.
**Purpose**: Execute implementation tasks using intelligent context inference and qwen CLI with full permissions.
**Core Guidelines**: @~/.claude/workflows/intelligent-tools-strategy.md
## 🚨 YOLO Permissions
**All confirmations auto-approved by default:**
- ✅ File pattern inference confirmation
- ✅ qwen execution confirmation
- ✅ File modification confirmation
- ✅ Implementation summary generation
## Execution Modes
### 1. Description Mode
**Input**: Natural language description
```bash
/qwen:execute "implement JWT authentication with middleware"
```
**Process**: Keyword analysis → Pattern inference → Context collection → Execution
### 2. Task ID Mode
**Input**: Workflow task identifier
```bash
/qwen:execute IMPL-001
```
**Process**: Task JSON parsing → Scope analysis → Context integration → Execution
## Context Inference Logic
**Auto-selects relevant files based on:**
- **Keywords**: "auth" → `@{**/*auth*,**/*user*}`
- **Technology**: "React" → `@{src/**/*.{jsx,tsx}}`
- **Task Type**: "api" → `@{**/api/**/*,**/routes/**/*}`
- **Always includes**: `@{CLAUDE.md,**/*CLAUDE.md}`
## Command Options
| Option | Purpose |
|--------|---------|
| `--debug` | Verbose execution logging |
| `--save-session` | Save complete execution session to workflow |
## Workflow Integration
### Session Management
⚠️ **Auto-detects active session**: Checks `.workflow/.active-*` marker file
**Session storage:**
- **Active session exists**: Saves to `.workflow/WFS-[topic]/.chat/execute-[timestamp].md`
- **No active session**: Creates new session directory
### Task Integration
```bash
# Execute specific workflow task
/qwen:execute IMPL-001
# Loads from: .task/IMPL-001.json
# Uses: task context, brainstorming refs, scope definitions
# Updates: workflow status, generates summary
```
## Execution Templates
### User Description Template
```bash
qwen --all-files -p "@{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md}
Implementation Task: [user_description]
Provide:
- Specific implementation code
- File modification locations (file:line)
- Test cases
- Integration guidance"
```
### Task ID Template
```bash
qwen --all-files -p "@{task_files} @{brainstorming_refs} @{CLAUDE.md,**/*CLAUDE.md}
Task: [task_title] (ID: [task-id])
Type: [task_type]
Scope: [task_scope]
Execute implementation following task acceptance criteria."
```
## Auto-Generated Outputs
### 1. Implementation Summary
**Location**: `.summaries/[TASK-ID]-summary.md` or auto-generated ID
```markdown
# Task Summary: [Task-ID] [Description]
## Implementation
- **Files Modified**: [file:line references]
- **Features Added**: [specific functionality]
- **Context Used**: [inferred patterns]
## Integration
- [Links to workflow documents]
```
### 2. Execution Session
**Location**: `.chat/execute-[timestamp].md`
```markdown
# Execution Session: [Timestamp]
## Input
[User description or Task ID]
## Context Inference
[File patterns used with rationale]
## Implementation Results
[Generated code and modifications]
## Status Updates
[Workflow integration updates]
```
## Error Handling
- **Task ID not found**: Lists available tasks
- **Pattern inference failure**: Uses generic `src/**/*` pattern
- **Execution failure**: Attempts fallback with simplified context
- **File modification errors**: Reports specific file/permission issues
## Performance Features
- **Smart caching**: Frequently used pattern mappings
- **Progressive inference**: Precise → broad pattern fallback
- **Parallel execution**: When multiple contexts needed
- **Directory optimization**: Switches to optimal execution path
## Integration Workflow
**Typical sequence:**
1. `workflow:plan` → Creates tasks
2. `/qwen:execute IMPL-001` → Executes with YOLO permissions
3. Auto-updates workflow status and generates summaries
4. `workflow:review` → Final validation
**vs. `/qwen:analyze`**: Execute performs analysis **and implementation**, analyze is read-only.

76
.claude/commands/qwen/mode/bug-index.md
View File

@@ -1,76 +0,0 @@
---
name: bug-index
description: Bug analysis and fix suggestions using specialized template
usage: /qwen:mode:bug-index "bug description"
argument-hint: "description of the bug or error you're experiencing"
examples:
- /qwen:mode:bug-index "authentication null pointer error in login flow"
- /qwen:mode:bug-index "React component not re-rendering after state change"
- /qwen:mode:bug-index "database connection timeout in production"
allowed-tools: Bash(qwen:*)
model: sonnet
---
# Bug Analysis Command (/qwen:mode:bug-index)
## Overview
Systematic bug analysis and fix suggestions using expert diagnostic template.
**Directory Analysis Rule**: Intelligent detection of directory context intent - automatically navigate to target directory when analysis scope is directory-specific.
**--cd Parameter Rule**: When `--cd` parameter is provided, always execute `cd "[path]" && qwen --all-files -p "prompt"` to ensure analysis occurs in the specified directory context.
## Usage
### Basic Bug Analysis
```bash
/qwen:mode:bug-index "authentication null pointer error"
```
### Bug Analysis with Directory Context
```bash
/qwen:mode:bug-index "authentication error" --cd "src/auth"
```
### Save to Workflow Session
```bash
/qwen:mode:bug-index "API timeout issues" --save-session
```
## Command Execution
**Template Used**: `~/.claude/prompt-templates/bug-fix.md`
**Executes**:
```bash
# Basic usage
qwen --all-files -p "$(cat ~/.claude/prompt-templates/bug-fix.md)
Bug Description: [user_description]"
# With --cd parameter
cd "[specified_directory]" && qwen --all-files -p "$(cat ~/.claude/prompt-templates/bug-fix.md)
Bug Description: [user_description]"
```
## Analysis Focus
The bug-fix template provides:
- **Root Cause Analysis**: Systematic investigation
- **Code Path Tracing**: Following execution flow
- **Targeted Solutions**: Specific, minimal fixes
- **Impact Assessment**: Understanding side effects
## Session Output
saves to:
`.workflow/WFS-[topic]/.chat/bug-index-[timestamp].md`
**Includes:**
- Bug description
- Template used
- Analysis results
- Recommended actions

62
.claude/commands/qwen/mode/plan.md
View File

@@ -1,62 +0,0 @@
---
name: plan
description: Project planning and architecture analysis using qwen CLI with specialized template
usage: /qwen:mode:plan "planning topic"
argument-hint: "planning topic or architectural challenge to analyze"
examples:
- /qwen:mode:plan "design user dashboard feature architecture"
- /qwen:mode:plan "plan microservices migration strategy"
- /qwen:mode:plan "implement real-time notification system"
allowed-tools: Bash(qwen:*)
model: sonnet
---
# Planning Analysis Command (/qwen:mode:plan)
## Overview
**This command uses qwen CLI for comprehensive project planning and architecture analysis.** It leverages qwen CLI's powerful codebase analysis capabilities combined with expert planning templates to provide strategic insights and implementation roadmaps.
### Key Features
- **qwen CLI Integration**: Utilizes qwen CLI's deep codebase analysis for informed planning decisions
**--cd Parameter Rule**: When `--cd` parameter is provided, always execute `cd "[path]" && qwen --all-files -p "prompt"` to ensure analysis occurs in the specified directory context.
## Usage
### Basic Usage
```bash
/qwen:mode:plan "design authentication system"
```
### Directory-Specific Analysis
```bash
/qwen:mode:plan "design authentication system" --cd "src/auth"
```
## Command Execution
**Smart Directory Detection**: Auto-detects relevant directories based on topic keywords
**Executes**:
```bash
# Project-wide analysis
qwen --all-files -p "$(cat ~/.claude/prompt-templates/plan.md)
Planning Topic: [user_description]"
# Directory-specific analysis
cd "[directory]" && qwen --all-files -p "$(cat ~/.claude/prompt-templates/plan.md)
Planning Topic: [user_description]"
```
## Session Output
saves to:
`.workflow/WFS-[topic]/.chat/plan-[timestamp].md`
**Includes:**
- Planning topic
- Template used
- Analysis results
- Implementation roadmap
- Key decisions

2
.claude/commands/workflow/tools/context-gather.md
View File

@@ -296,6 +296,6 @@ rg -A 2 -B 2 "{keywords}" --type-add 'source:*.{ts,js,py,go}' -t source --max-co
- File relevance accuracy rate >80%
## Related Commands
- `/analysis:run` - Consumes output of this command for analysis
- `/workflow:tools:concept-enhanced` - Consumes output of this command for analysis
- `/workflow:plan` - Calls this command to gather context
- `/workflow:status` - Can display context collection status