mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-10 02:24:35 +08:00
Enhance workflows and commands for intelligent tools strategy
- Updated intelligent-tools-strategy.md to include `--skip-git-repo-check` for Codex write access and development commands. - Improved context gathering and analysis processes in mcp-tool-strategy.md with additional examples and guidelines for file searching. - Introduced new command concept-enhanced.md for enhanced intelligent analysis with parallel CLI execution and design blueprint generation. - Added context-gather.md command for intelligent collection of project context based on task descriptions, generating standardized JSON context packages.
This commit is contained in:
catlog22
421
.claude/commands/workflow/tools/concept-enhanced.md
Normal file
421
.claude/commands/workflow/tools/concept-enhanced.md
Normal file
@@ -0,0 +1,421 @@
|
||||
---
|
||||
name: plan-enchanced
|
||||
description: Enhanced intelligent analysis with parallel CLI execution and design blueprint generation
|
||||
usage: /workflow:tools:concept-enhanced --session <session_id> --context <context_package_path>
|
||||
argument-hint: "--session WFS-session-id --context path/to/context-package.json"
|
||||
examples:
|
||||
- /workflow:tools:concept-enhanced --session WFS-auth --context .workflow/WFS-auth/.process/context-package.json
|
||||
- /workflow:tools:concept-enhanced --session WFS-payment --context .workflow/WFS-payment/.process/context-package.json
|
||||
---
|
||||
|
||||
# Enhanced Planning Command (/workflow:tools:concept-enhanced)
|
||||
|
||||
## Overview
|
||||
Advanced intelligent planning engine with parallel CLI execution that processes standardized context packages, generates enhanced suggestions and design blueprints, and produces comprehensive analysis results with implementation strategies.
|
||||
|
||||
## Core Philosophy
|
||||
- **Context-Driven**: Precise analysis based on comprehensive context
|
||||
- **Intelligent Tool Selection**: Choose optimal analysis tools based on task characteristics
|
||||
- **Parallel Execution**: Execute multiple CLI tools simultaneously for efficiency
|
||||
- **Enhanced Suggestions**: Generate actionable recommendations and design blueprints
|
||||
- **Write-Enabled**: Tools have full write permissions for implementation suggestions
|
||||
- **Structured Output**: Generate standardized analysis reports with implementation roadmaps
|
||||
|
||||
## Core Responsibilities
|
||||
- **Context Package Parsing**: Read and validate context-package.json
|
||||
- **Parallel CLI Orchestration**: Execute multiple analysis tools simultaneously with write permissions
|
||||
- **Enhanced Suggestions Generation**: Create actionable recommendations and design blueprints
|
||||
- **Design Blueprint Creation**: Generate comprehensive technical implementation designs
|
||||
- **Perspective Synthesis**: Collect and organize different tool viewpoints
|
||||
- **Consensus Analysis**: Identify agreements and conflicts between tools
|
||||
- **Summary Report Generation**: Output comprehensive ANALYSIS_RESULTS.md with implementation strategies
|
||||
|
||||
## Analysis Strategy Selection
|
||||
|
||||
### Tool Selection by Task Complexity
|
||||
|
||||
**Simple Tasks (≤3 modules)**:
|
||||
- **Primary Tool**: Gemini (rapid understanding and pattern recognition)
|
||||
- **Support Tool**: Code-index (structural analysis)
|
||||
- **Execution Mode**: Single-round analysis, focus on existing patterns
|
||||
|
||||
**Medium Tasks (4-6 modules)**:
|
||||
- **Primary Tool**: Gemini (comprehensive single-round analysis and architecture design)
|
||||
- **Support Tools**: Code-index + Exa (external best practices)
|
||||
- **Execution Mode**: Single comprehensive analysis covering understanding + architecture design
|
||||
|
||||
**Complex Tasks (>6 modules)**:
|
||||
- **Primary Tools**: Gemini (single comprehensive analysis) + Codex (implementation validation)
|
||||
- **Analysis Strategy**: Gemini handles understanding + architecture in one round, Codex validates implementation
|
||||
- **Execution Mode**: Parallel execution - Gemini comprehensive analysis + Codex validation
|
||||
|
||||
### Tool Preferences by Tech Stack
|
||||
|
||||
```json
|
||||
{
|
||||
"frontend": {
|
||||
"primary": "gemini",
|
||||
"secondary": "codex",
|
||||
"focus": ["component_design", "state_management", "ui_patterns"]
|
||||
},
|
||||
"backend": {
|
||||
"primary": "codex",
|
||||
"secondary": "gemini",
|
||||
"focus": ["api_design", "data_flow", "security", "performance"]
|
||||
},
|
||||
"fullstack": {
|
||||
"primary": "gemini",
|
||||
"secondary": "codex",
|
||||
"focus": ["system_architecture", "integration", "data_consistency"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Phase 1: Validation & Preparation
|
||||
1. **Session Validation**
|
||||
- Verify session directory exists: `.workflow/{session_id}/`
|
||||
- Load session metadata from `workflow-session.json`
|
||||
- Validate session state and task context
|
||||
|
||||
2. **Context Package Validation**
|
||||
- Verify context package exists at specified path
|
||||
- Validate JSON format and structure
|
||||
- Assess context package size and complexity
|
||||
|
||||
3. **Task Analysis & Classification**
|
||||
- Parse task description and extract keywords
|
||||
- Identify technical domain and complexity level
|
||||
- Determine required analysis depth and scope
|
||||
- Load existing session context and task summaries
|
||||
|
||||
4. **Tool Selection Strategy**
|
||||
- **Simple/Medium Tasks**: Single Gemini comprehensive analysis
|
||||
- **Complex Tasks**: Gemini comprehensive + Codex validation
|
||||
- Load appropriate prompt templates and configurations
|
||||
|
||||
### Phase 2: Analysis Preparation
|
||||
1. **Workspace Setup**
|
||||
- Create analysis output directory: `.workflow/{session_id}/.process/`
|
||||
- Initialize log files and monitoring structures
|
||||
- Set process limits and resource management
|
||||
|
||||
2. **Context Optimization**
|
||||
- Filter high-priority assets from context package
|
||||
- Organize project structure and dependencies
|
||||
- Prepare template references and rule configurations
|
||||
|
||||
3. **Execution Environment**
|
||||
- Configure CLI tools with write permissions
|
||||
- Set timeout parameters and monitoring intervals
|
||||
- Prepare error handling and recovery mechanisms
|
||||
|
||||
### Phase 3: Parallel Analysis Execution
|
||||
1. **Gemini Comprehensive Analysis & Documentation**
|
||||
- **Tool Configuration**: `gemini-wrapper --approval-mode yolo` for write permissions
|
||||
- **Purpose**: Enhanced comprehensive analysis with actionable suggestions, design blueprints, and documentation generation
|
||||
- **Expected Outputs**:
|
||||
- Current State Analysis: Architecture patterns, code quality, technical debt, performance bottlenecks
|
||||
- Enhanced Suggestions: Implementation blueprints, code organization, API specifications, security guidelines
|
||||
- Implementation Roadmap: Phase-by-phase plans, CI/CD blueprints, testing strategies
|
||||
- Actionable Examples: Code templates, configuration scripts, integration patterns
|
||||
- Documentation Generation: Technical documentation, API docs, user guides, and README files
|
||||
- **Prompt Template**:
|
||||
```
|
||||
PURPOSE: Generate comprehensive analysis and documentation for {task_description}
|
||||
TASK: Analyze codebase, create implementation blueprints, and generate supporting documentation
|
||||
CONTEXT: {context_package_assets}
|
||||
EXPECTED:
|
||||
1. Complete technical analysis with implementation strategy
|
||||
2. Generated documentation files (README.md, API.md, GUIDE.md as needed)
|
||||
3. Code examples and configuration templates
|
||||
4. Implementation roadmap with phase-by-phase plans
|
||||
RULES: Create both analysis blueprints AND user-facing documentation. Generate actual documentation files, not just analysis of documentation needs.
|
||||
```
|
||||
- **Output Location**: `.workflow/{session_id}/.process/gemini-enhanced-analysis.md` + generated docs
|
||||
|
||||
2. **Codex Implementation Validation** (Complex Tasks Only)
|
||||
- **Tool Configuration**: `codex --skip-git-repo-check --full-auto exec -s danger-full-access` for implementation validation
|
||||
- **Purpose**: Technical feasibility validation with write-enabled blueprint generation
|
||||
- **Expected Outputs**:
|
||||
- Feasibility Assessment: Complexity analysis, resource requirements, technology compatibility
|
||||
- Implementation Validation: Quality recommendations, security assessments, testing frameworks
|
||||
- Implementation Guides: Step-by-step procedures, configuration management, monitoring setup
|
||||
- **Output Location**: `.workflow/{session_id}/.process/codex-validation-analysis.md`
|
||||
|
||||
3. **Parallel Execution Management**
|
||||
- Launch both tools simultaneously for complex tasks
|
||||
- Monitor execution progress with timeout controls
|
||||
- Handle process completion and error scenarios
|
||||
- Maintain execution logs for debugging and recovery
|
||||
|
||||
### Phase 4: Results Collection & Validation
|
||||
1. **Output Validation & Collection**
|
||||
- **Gemini Results**: Validate `gemini-enhanced-analysis.md` exists and contains complete analysis
|
||||
- **Codex Results**: For complex tasks, validate `codex-validation-analysis.md` with implementation guidance
|
||||
- **Fallback Processing**: Use execution logs if primary outputs are incomplete
|
||||
- **Status Classification**: Mark each tool as completed, partial, failed, or skipped
|
||||
|
||||
2. **Quality Assessment**
|
||||
- Verify analysis completeness against expected output structure
|
||||
- Assess actionability of recommendations and blueprints
|
||||
- Validate presence of concrete implementation examples
|
||||
- Check coverage of technical requirements and constraints
|
||||
|
||||
3. **Analysis Integration Strategy**
|
||||
- **Simple/Medium Tasks**: Direct integration of Gemini comprehensive analysis
|
||||
- **Complex Tasks**: Synthesis of Gemini understanding with Codex validation
|
||||
- **Conflict Resolution**: Identify and resolve conflicting recommendations
|
||||
- **Priority Matrix**: Organize recommendations by implementation priority
|
||||
|
||||
### Phase 5: ANALYSIS_RESULTS.md Generation
|
||||
1. **Structured Report Assembly**
|
||||
- **Executive Summary**: Task overview, timestamp, tools used, key findings
|
||||
- **Analysis Results**: Complete Gemini analysis with optional Codex validation
|
||||
- **Synthesis & Recommendations**: Consolidated implementation strategy with risk mitigation
|
||||
- **Implementation Roadmap**: Phase-by-phase development plan with timelines
|
||||
- **Quality Assurance**: Testing frameworks, monitoring strategies, success criteria
|
||||
|
||||
2. **Supplementary Outputs**
|
||||
- **Machine-Readable Summary**: `analysis-summary.json` with structured metadata
|
||||
- **Implementation Guidelines**: Phase-specific deliverables and checkpoints
|
||||
- **Next Steps Matrix**: Immediate, short-term, and long-term action items
|
||||
|
||||
3. **Final Report Generation**
|
||||
- **Primary Output**: `ANALYSIS_RESULTS.md` with comprehensive analysis and implementation blueprint
|
||||
- **Secondary Output**: `analysis-summary.json` with machine-readable metadata and status
|
||||
- **Report Structure**: Executive summary, analysis results, synthesis recommendations, implementation roadmap, quality assurance strategy
|
||||
- **Action Items**: Immediate, short-term, and long-term next steps with success criteria
|
||||
|
||||
4. **Summary Report Finalization**
|
||||
- Generate executive summary with key findings
|
||||
- Create implementation priority matrix
|
||||
- Provide next steps and action items
|
||||
- Generate quality metrics and confidence scores
|
||||
|
||||
## Analysis Results Format
|
||||
|
||||
Generated ANALYSIS_RESULTS.md format (Multi-Tool Perspective Analysis):
|
||||
|
||||
```markdown
|
||||
# Multi-Tool Analysis Results
|
||||
|
||||
## Task Overview
|
||||
- **Description**: {task_description}
|
||||
- **Context Package**: {context_package_path}
|
||||
- **Analysis Tools**: {tools_used}
|
||||
- **Analysis Timestamp**: {timestamp}
|
||||
|
||||
## Tool-Specific Analysis
|
||||
|
||||
### 🧠 Gemini Analysis (Enhanced Understanding & Architecture Blueprint)
|
||||
**Focus**: Existing codebase understanding, enhanced suggestions, and comprehensive technical architecture design with actionable improvements
|
||||
**Write Permissions**: Enabled for suggestion generation and blueprint creation
|
||||
|
||||
#### Current Architecture Assessment
|
||||
- **Existing Patterns**: {identified_patterns}
|
||||
- **Code Structure**: {current_structure}
|
||||
- **Integration Points**: {integration_analysis}
|
||||
- **Technical Debt**: {debt_assessment}
|
||||
|
||||
#### Compatibility Analysis
|
||||
- **Framework Compatibility**: {framework_analysis}
|
||||
- **Dependency Impact**: {dependency_analysis}
|
||||
- **Migration Considerations**: {migration_notes}
|
||||
|
||||
#### Proposed Architecture
|
||||
- **System Design**: {architectural_design}
|
||||
- **Component Structure**: {component_design}
|
||||
- **Data Flow**: {data_flow_design}
|
||||
- **Interface Design**: {api_interface_design}
|
||||
|
||||
#### Implementation Strategy
|
||||
- **Code Organization**: {code_structure_plan}
|
||||
- **Module Dependencies**: {module_dependencies}
|
||||
- **Testing Strategy**: {testing_approach}
|
||||
|
||||
### 🔧 Codex Analysis (Implementation Blueprints & Enhanced Validation)
|
||||
**Focus**: Implementation feasibility, write-enabled blueprints, and comprehensive technical validation with concrete examples
|
||||
**Write Permissions**: Full access for implementation suggestion generation
|
||||
|
||||
#### Feasibility Assessment
|
||||
- **Technical Risks**: {implementation_risks}
|
||||
- **Performance Impact**: {performance_analysis}
|
||||
- **Resource Requirements**: {resource_assessment}
|
||||
- **Maintenance Complexity**: {maintenance_analysis}
|
||||
|
||||
#### Enhanced Implementation Blueprints
|
||||
- **Tool Selection**: {recommended_tools_with_examples}
|
||||
- **Development Approach**: {detailed_development_strategy}
|
||||
- **Quality Assurance**: {comprehensive_qa_recommendations}
|
||||
- **Code Examples**: {implementation_code_samples}
|
||||
- **Testing Blueprints**: {automated_testing_strategies}
|
||||
- **Deployment Guidelines**: {deployment_implementation_guide}
|
||||
|
||||
|
||||
## Synthesis & Consensus
|
||||
|
||||
### Enhanced Consolidated Recommendations
|
||||
- **Architecture Approach**: {consensus_architecture_with_blueprints}
|
||||
- **Implementation Priority**: {detailed_priority_matrix}
|
||||
- **Risk Mitigation**: {comprehensive_risk_mitigation_strategy}
|
||||
- **Performance Optimization**: {optimization_recommendations}
|
||||
- **Security Enhancements**: {security_implementation_guide}
|
||||
|
||||
## Implementation Roadmap
|
||||
|
||||
### Phase 1: Foundation Setup
|
||||
- **Infrastructure**: {infrastructure_setup_blueprint}
|
||||
- **Development Environment**: {dev_env_configuration}
|
||||
- **Initial Architecture**: {foundational_architecture}
|
||||
|
||||
### Phase 2: Core Implementation
|
||||
- **Priority Features**: {core_feature_implementation}
|
||||
- **Testing Framework**: {testing_implementation_strategy}
|
||||
- **Quality Gates**: {quality_assurance_checkpoints}
|
||||
|
||||
### Phase 3: Enhancement & Optimization
|
||||
- **Performance Tuning**: {performance_enhancement_plan}
|
||||
- **Security Hardening**: {security_implementation_steps}
|
||||
- **Scalability Improvements**: {scalability_enhancement_strategy}
|
||||
|
||||
## Enhanced Quality Assurance Strategy
|
||||
|
||||
### Automated Testing Blueprint
|
||||
- **Unit Testing**: {unit_test_implementation}
|
||||
- **Integration Testing**: {integration_test_strategy}
|
||||
- **Performance Testing**: {performance_test_blueprint}
|
||||
- **Security Testing**: {security_test_framework}
|
||||
|
||||
### Continuous Quality Monitoring
|
||||
- **Code Quality Metrics**: {quality_monitoring_setup}
|
||||
- **Performance Monitoring**: {performance_tracking_implementation}
|
||||
- **Security Monitoring**: {security_monitoring_blueprint}
|
||||
|
||||
### Tool Agreement Analysis
|
||||
- **Consensus Points**: {agreed_recommendations}
|
||||
- **Conflicting Views**: {conflicting_opinions}
|
||||
- **Resolution Strategy**: {conflict_resolution}
|
||||
|
||||
### Task Decomposition Suggestions
|
||||
1. **Primary Tasks**: {major_task_suggestions}
|
||||
2. **Task Dependencies**: {dependency_mapping}
|
||||
3. **Complexity Assessment**: {complexity_evaluation}
|
||||
|
||||
## Enhanced Analysis Quality Metrics
|
||||
- **Context Coverage**: {coverage_percentage}
|
||||
- **Multi-Tool Consensus**: {three_tool_consensus_level}
|
||||
- **Analysis Depth**: {comprehensive_depth_assessment}
|
||||
- **Implementation Feasibility**: {feasibility_confidence_score}
|
||||
- **Blueprint Completeness**: {blueprint_coverage_score}
|
||||
- **Actionability Score**: {suggestion_actionability_rating}
|
||||
- **Overall Confidence**: {enhanced_confidence_score}
|
||||
|
||||
## Implementation Success Indicators
|
||||
- **Technical Feasibility**: {technical_implementation_confidence}
|
||||
- **Resource Adequacy**: {resource_requirement_assessment}
|
||||
- **Timeline Realism**: {timeline_feasibility_score}
|
||||
- **Risk Management**: {risk_mitigation_effectiveness}
|
||||
|
||||
## Next Steps & Action Items
|
||||
1. **Immediate Actions**: {immediate_implementation_steps}
|
||||
2. **Short-term Goals**: {short_term_objectives}
|
||||
3. **Long-term Strategy**: {long_term_implementation_plan}
|
||||
4. **Success Metrics**: {implementation_success_criteria}
|
||||
```
|
||||
|
||||
## Error Handling & Fallbacks
|
||||
|
||||
### Error Handling & Recovery Strategies
|
||||
|
||||
1. **Pre-execution Validation**
|
||||
- **Session Verification**: Ensure session directory and metadata exist
|
||||
- **Context Package Validation**: Verify JSON format and content structure
|
||||
- **Tool Availability**: Confirm CLI tools are accessible and configured
|
||||
- **Prerequisite Checks**: Validate all required dependencies and permissions
|
||||
|
||||
2. **Execution Monitoring & Timeout Management**
|
||||
- **Progress Monitoring**: Track analysis execution with regular status checks
|
||||
- **Timeout Controls**: 30-minute execution limit with graceful termination
|
||||
- **Process Management**: Handle parallel tool execution and resource limits
|
||||
- **Status Tracking**: Maintain real-time execution state and completion status
|
||||
|
||||
3. **Partial Results Recovery**
|
||||
- **Fallback Strategy**: Generate analysis results even with incomplete outputs
|
||||
- **Log Integration**: Use execution logs when primary outputs are unavailable
|
||||
- **Recovery Mode**: Create partial analysis reports with available data
|
||||
- **Guidance Generation**: Provide next steps and retry recommendations
|
||||
|
||||
4. **Resource Management**
|
||||
- **Disk Space Monitoring**: Check available storage and cleanup temporary files
|
||||
- **Process Limits**: Set CPU and memory constraints for analysis execution
|
||||
- **Performance Optimization**: Manage resource utilization and system load
|
||||
- **Cleanup Procedures**: Remove outdated logs and temporary files
|
||||
|
||||
5. **Comprehensive Error Recovery**
|
||||
- **Error Detection**: Automatic error identification and classification
|
||||
- **Recovery Workflows**: Structured approach to handling different failure modes
|
||||
- **Status Reporting**: Clear communication of issues and resolution attempts
|
||||
- **Graceful Degradation**: Provide useful outputs even with partial failures
|
||||
|
||||
## Performance Optimization
|
||||
|
||||
### Analysis Optimization Strategies
|
||||
- **Parallel Analysis**: Execute multiple tools in parallel to reduce total time
|
||||
- **Context Sharding**: Analyze large projects by module shards
|
||||
- **Caching Mechanism**: Reuse analysis results for similar contexts
|
||||
- **Incremental Analysis**: Perform incremental analysis based on changes
|
||||
|
||||
### Resource Management
|
||||
```bash
|
||||
# Set analysis timeout
|
||||
timeout 600s analysis_command || {
|
||||
echo "⚠️ Analysis timeout, generating partial results"
|
||||
# Generate partial results
|
||||
}
|
||||
|
||||
# Memory usage monitoring
|
||||
memory_usage=$(ps -o pid,vsz,rss,comm -p $$)
|
||||
if [ "$memory_usage" -gt "$memory_limit" ]; then
|
||||
echo "⚠️ High memory usage detected, optimizing..."
|
||||
fi
|
||||
```
|
||||
|
||||
## Integration Points
|
||||
|
||||
### Input Interface
|
||||
- **Required**: `--session` parameter specifying session ID (e.g., WFS-auth)
|
||||
- **Required**: `--context` parameter specifying context package path
|
||||
- **Optional**: `--depth` specify analysis depth (quick|full|deep)
|
||||
- **Optional**: `--focus` specify analysis focus areas
|
||||
|
||||
### Output Interface
|
||||
- **Primary**: Enhanced ANALYSIS_RESULTS.md file with implementation blueprints
|
||||
- **Location**: .workflow/{session_id}/.process/ANALYSIS_RESULTS.md
|
||||
- **Secondary**: analysis-summary.json (machine-readable format)
|
||||
- **Tertiary**: implementation-roadmap.md (detailed implementation guide)
|
||||
- **Quaternary**: blueprint-templates/ directory (code templates and examples)
|
||||
|
||||
## Quality Assurance
|
||||
|
||||
### Analysis Quality Checks
|
||||
- **Completeness Check**: Ensure all required analysis sections are completed
|
||||
- **Consistency Check**: Verify consistency of multi-tool analysis results
|
||||
- **Feasibility Validation**: Ensure recommended implementation plans are feasible
|
||||
|
||||
### Success Criteria
|
||||
- ✅ **Enhanced Output Generation**: Comprehensive ANALYSIS_RESULTS.md with implementation blueprints and machine-readable summary
|
||||
- ✅ **Write-Enabled CLI Tools**: Full write permissions for Gemini (--approval-mode yolo) and Codex (--skip-git-repo-check -s danger-full-access)
|
||||
- ✅ **Enhanced Suggestions**: Concrete implementation examples, configuration templates, and step-by-step procedures
|
||||
- ✅ **Design Blueprints**: Detailed technical architecture with component diagrams and API specifications
|
||||
- ✅ **Parallel Execution**: Efficient concurrent tool execution with proper monitoring and timeout handling
|
||||
- ✅ **Robust Error Handling**: Comprehensive validation, timeout management, and partial result recovery
|
||||
- ✅ **Actionable Results**: Implementation roadmap with phase-by-phase development strategy and success criteria
|
||||
- ✅ **Quality Assurance**: Automated testing frameworks, CI/CD blueprints, and monitoring strategies
|
||||
- ✅ **Performance Optimization**: Execution completes within 30 minutes with resource management
|
||||
|
||||
## Related Commands
|
||||
- `/context:gather` - Generate context packages required by this command
|
||||
- `/workflow:plan` - Call this command for analysis
|
||||
- `/task:create` - Create specific tasks based on analysis results
|
||||
@@ -1,407 +0,0 @@
|
||||
---
|
||||
name: concept-eval
|
||||
description: Evaluate concept planning before implementation with intelligent tool analysis
|
||||
usage: /workflow:concept-eval [--tool gemini|codex|both] <input>
|
||||
argument-hint: [--tool gemini|codex|both] "concept description"|file.md|ISS-001
|
||||
examples:
|
||||
- /workflow:concept-eval "Build microservices architecture"
|
||||
- /workflow:concept-eval --tool gemini requirements.md
|
||||
- /workflow:concept-eval --tool both ISS-001
|
||||
allowed-tools: Task(*), TodoWrite(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*)
|
||||
---
|
||||
|
||||
# Workflow Concept Evaluation Command
|
||||
|
||||
## Overview
|
||||
Pre-planning evaluation command that assesses concept feasibility, identifies potential issues, and provides optimization recommendations before formal planning begins. **Works before `/workflow:plan`** to catch conceptual problems early and improve initial design quality.
|
||||
|
||||
## Core Responsibilities
|
||||
- **Concept Analysis**: Evaluate design concepts for architectural soundness
|
||||
- **Feasibility Assessment**: Technical and resource feasibility evaluation
|
||||
- **Risk Identification**: Early identification of potential implementation risks
|
||||
- **Optimization Suggestions**: Generate actionable improvement recommendations
|
||||
- **Context Integration**: Leverage existing codebase patterns and documentation
|
||||
- **Tool Selection**: Use gemini for strategic analysis, codex for technical assessment
|
||||
|
||||
## Usage
|
||||
```bash
|
||||
/workflow:concept-eval [--tool gemini|codex|both] <input>
|
||||
```
|
||||
|
||||
## Parameters
|
||||
- **--tool**: Specify evaluation tool (default: both)
|
||||
- `gemini`: Strategic and architectural evaluation
|
||||
- `codex`: Technical feasibility and implementation assessment
|
||||
- `both`: Comprehensive dual-perspective analysis
|
||||
- **input**: Concept description, file path, or issue reference
|
||||
|
||||
## Input Detection
|
||||
- **Files**: `.md/.txt/.json/.yaml/.yml` → Reads content and extracts concept requirements
|
||||
- **Issues**: `ISS-*`, `ISSUE-*`, `*-request-*` → Loads issue data and requirement specifications
|
||||
- **Text**: Everything else → Parses natural language concept descriptions
|
||||
|
||||
## Core Workflow
|
||||
|
||||
### Evaluation Process
|
||||
The command performs comprehensive concept evaluation through:
|
||||
|
||||
**0. Context Preparation** ⚠️ FIRST STEP
|
||||
- **MCP Tools Integration**: Use Code Index for codebase exploration, Exa for external context
|
||||
- **Documentation loading**: Automatic context gathering based on concept scope
|
||||
- **Always check**: `CLAUDE.md`, `README.md` - Project context and conventions
|
||||
- **For architecture concepts**: `.workflow/docs/architecture/`, existing system patterns
|
||||
- **For specific modules**: `.workflow/docs/modules/[relevant-module]/` documentation
|
||||
- **For API concepts**: `.workflow/docs/api/` specifications
|
||||
- **Claude Code Memory Integration**: Access conversation history and previous work context
|
||||
- **Session Memory**: Current session analysis and decisions
|
||||
- **Project Memory**: Previous implementations and lessons learned
|
||||
- **Pattern Memory**: Successful approaches and anti-patterns identified
|
||||
- **Context Continuity**: Reference previous concept evaluations and outcomes
|
||||
- **Context-driven selection**: Only load documentation relevant to the concept scope
|
||||
- **Pattern analysis**: Identify existing implementation patterns and conventions
|
||||
|
||||
**1. Input Processing & Context Gathering**
|
||||
- Parse input to extract concept requirements and scope
|
||||
- Automatic tool assignment based on evaluation needs:
|
||||
- **Strategic evaluation** (gemini): Architectural soundness, design patterns, business alignment
|
||||
- **Technical assessment** (codex): Implementation complexity, technical feasibility, resource requirements
|
||||
- **Comprehensive analysis** (both): Combined strategic and technical evaluation
|
||||
- Load relevant project documentation and existing patterns
|
||||
|
||||
**2. Concept Analysis** ⚠️ CRITICAL EVALUATION PHASE
|
||||
- **Conceptual integrity**: Evaluate design coherence and completeness
|
||||
- **Architectural soundness**: Assess alignment with existing system architecture
|
||||
- **Technical feasibility**: Analyze implementation complexity and resource requirements
|
||||
- **Risk assessment**: Identify potential technical and business risks
|
||||
- **Dependency analysis**: Map required dependencies and integration points
|
||||
|
||||
**3. Evaluation Execution**
|
||||
Based on tool selection, execute appropriate analysis:
|
||||
|
||||
**Gemini Strategic Analysis**:
|
||||
```bash
|
||||
~/.claude/scripts/gemini-wrapper -p "
|
||||
PURPOSE: Strategic evaluation of concept design and architecture
|
||||
TASK: Analyze concept for architectural soundness, design patterns, and strategic alignment
|
||||
CONTEXT: @{CLAUDE.md,README.md,.workflow/docs/**/*} Concept requirements and existing patterns | Previous conversation context and Claude Code session memory for continuity and pattern recognition
|
||||
EXPECTED: Strategic assessment with architectural recommendations informed by session history
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/concept-eval.txt) | Focus on strategic soundness and design quality | Reference previous evaluations and lessons learned
|
||||
"
|
||||
```
|
||||
|
||||
**Codex Technical Assessment**:
|
||||
```bash
|
||||
codex --full-auto exec "
|
||||
PURPOSE: Technical feasibility assessment of concept implementation
|
||||
TASK: Evaluate implementation complexity, technical risks, and resource requirements
|
||||
CONTEXT: @{CLAUDE.md,README.md,src/**/*} Concept requirements and existing codebase | Current session work context and previous technical decisions
|
||||
EXPECTED: Technical assessment with implementation recommendations building on session memory
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/concept-eval.txt) | Focus on technical feasibility and implementation complexity | Consider previous technical approaches and outcomes
|
||||
" -s danger-full-access
|
||||
```
|
||||
|
||||
**Combined Analysis** (when --tool both):
|
||||
Execute both analyses in parallel, then synthesize results for comprehensive evaluation.
|
||||
|
||||
**4. Optimization Recommendations**
|
||||
- **Design improvements**: Architectural and design optimization suggestions
|
||||
- **Risk mitigation**: Strategies to address identified risks
|
||||
- **Implementation approach**: Recommended technical approaches and patterns
|
||||
- **Resource optimization**: Efficient resource utilization strategies
|
||||
- **Integration suggestions**: Optimal integration with existing systems
|
||||
|
||||
## Implementation Standards
|
||||
|
||||
### Evaluation Criteria ⚠️ CRITICAL
|
||||
Concept evaluation focuses on these key dimensions:
|
||||
|
||||
**Strategic Evaluation (Gemini)**:
|
||||
1. **Architectural Soundness**: Design coherence and system integration
|
||||
2. **Business Alignment**: Concept alignment with business objectives
|
||||
3. **Scalability Considerations**: Long-term growth and expansion potential
|
||||
4. **Design Patterns**: Appropriate use of established design patterns
|
||||
5. **Risk Assessment**: Strategic and business risk identification
|
||||
|
||||
**Technical Assessment (Codex)**:
|
||||
1. **Implementation Complexity**: Technical difficulty and effort estimation
|
||||
2. **Technical Feasibility**: Availability of required technologies and skills
|
||||
3. **Resource Requirements**: Development time, infrastructure, and team resources
|
||||
4. **Integration Challenges**: Technical integration complexity and risks
|
||||
5. **Performance Implications**: System performance and scalability impact
|
||||
|
||||
### Evaluation Context Loading ⚠️ CRITICAL
|
||||
Context preparation ensures comprehensive evaluation:
|
||||
|
||||
```json
|
||||
// Context loading strategy for concept evaluation
|
||||
"context_preparation": {
|
||||
"required_docs": [
|
||||
"CLAUDE.md",
|
||||
"README.md"
|
||||
],
|
||||
"conditional_docs": {
|
||||
"architecture_concepts": [
|
||||
".workflow/docs/architecture/",
|
||||
"docs/system-design.md"
|
||||
],
|
||||
"api_concepts": [
|
||||
".workflow/docs/api/",
|
||||
"api-documentation.md"
|
||||
],
|
||||
"module_concepts": [
|
||||
".workflow/docs/modules/[relevant-module]/",
|
||||
"src/[module]/**/*.md"
|
||||
]
|
||||
},
|
||||
"pattern_analysis": {
|
||||
"existing_implementations": "src/**/*",
|
||||
"configuration_patterns": "config/",
|
||||
"test_patterns": "test/**/*"
|
||||
},
|
||||
"claude_code_memory": {
|
||||
"session_context": "Current session conversation history and decisions",
|
||||
"project_memory": "Previous implementations and lessons learned across sessions",
|
||||
"pattern_memory": "Successful approaches and anti-patterns identified",
|
||||
"evaluation_history": "Previous concept evaluations and their outcomes",
|
||||
"technical_decisions": "Past technical choices and their rationale",
|
||||
"architectural_evolution": "System architecture changes and migration patterns"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Analysis Output Structure
|
||||
|
||||
**Evaluation Categories**:
|
||||
```markdown
|
||||
## Concept Evaluation Summary
|
||||
|
||||
### ✅ Strengths Identified
|
||||
- [ ] **Design Quality**: Well-defined architectural approach
|
||||
- [ ] **Technical Approach**: Appropriate technology selection
|
||||
- [ ] **Integration**: Good fit with existing systems
|
||||
|
||||
### ⚠️ Areas for Improvement
|
||||
- [ ] **Complexity**: Reduce implementation complexity in module X
|
||||
- [ ] **Dependencies**: Simplify dependency management approach
|
||||
- [ ] **Scalability**: Address potential performance bottlenecks
|
||||
|
||||
### ❌ Critical Issues
|
||||
- [ ] **Architecture**: Conflicts with existing system design
|
||||
- [ ] **Resources**: Insufficient resources for proposed timeline
|
||||
- [ ] **Risk**: High technical risk in component Y
|
||||
|
||||
### 🎯 Optimization Recommendations
|
||||
- [ ] **Alternative Approach**: Consider microservices instead of monolithic design
|
||||
- [ ] **Technology Stack**: Use existing React patterns instead of Vue
|
||||
- [ ] **Implementation Strategy**: Phase implementation to reduce risk
|
||||
```
|
||||
|
||||
## Document Generation & Output
|
||||
|
||||
**Evaluation Workflow**: Input Processing → Context Loading → Analysis Execution → Report Generation → Recommendations
|
||||
|
||||
**Always Created**:
|
||||
- **CONCEPT_EVALUATION.md**: Complete evaluation results and recommendations
|
||||
- **evaluation-session.json**: Evaluation metadata and tool configuration
|
||||
- **OPTIMIZATION_SUGGESTIONS.md**: Actionable improvement recommendations
|
||||
|
||||
**Auto-Created (for comprehensive analysis)**:
|
||||
- **strategic-analysis.md**: Gemini strategic evaluation results
|
||||
- **technical-assessment.md**: Codex technical feasibility analysis
|
||||
- **risk-assessment-matrix.md**: Comprehensive risk evaluation
|
||||
- **implementation-roadmap.md**: Recommended implementation approach
|
||||
|
||||
**Document Structure**:
|
||||
```
|
||||
.workflow/WFS-[topic]/.evaluation/
|
||||
├── evaluation-session.json # Evaluation session metadata
|
||||
├── CONCEPT_EVALUATION.md # Complete evaluation results
|
||||
├── OPTIMIZATION_SUGGESTIONS.md # Actionable recommendations
|
||||
├── strategic-analysis.md # Gemini strategic evaluation
|
||||
├── technical-assessment.md # Codex technical assessment
|
||||
├── risk-assessment-matrix.md # Risk evaluation matrix
|
||||
└── implementation-roadmap.md # Recommended approach
|
||||
```
|
||||
|
||||
### Evaluation Implementation
|
||||
|
||||
**Session-Aware Evaluation**:
|
||||
```bash
|
||||
# Check for existing sessions and context
|
||||
active_sessions=$(find .workflow/ -name ".active-*" 2>/dev/null)
|
||||
if [ -n "$active_sessions" ]; then
|
||||
echo "Found active sessions: $active_sessions"
|
||||
echo "Concept evaluation will consider existing session context"
|
||||
fi
|
||||
|
||||
# Create evaluation session directory
|
||||
evaluation_session="CE-$(date +%Y%m%d_%H%M%S)"
|
||||
mkdir -p ".workflow/.evaluation/$evaluation_session"
|
||||
|
||||
# Store evaluation metadata
|
||||
cat > ".workflow/.evaluation/$evaluation_session/evaluation-session.json" << EOF
|
||||
{
|
||||
"session_id": "$evaluation_session",
|
||||
"timestamp": "$(date -Iseconds)",
|
||||
"concept_input": "$input_description",
|
||||
"tool_selection": "$tool_choice",
|
||||
"context_loaded": [
|
||||
"CLAUDE.md",
|
||||
"README.md"
|
||||
],
|
||||
"evaluation_scope": "$evaluation_scope"
|
||||
}
|
||||
EOF
|
||||
```
|
||||
|
||||
**Tool Execution Pattern**:
|
||||
```bash
|
||||
# Execute based on tool selection
|
||||
case "$tool_choice" in
|
||||
"gemini")
|
||||
echo "Performing strategic concept evaluation with Gemini..."
|
||||
~/.claude/scripts/gemini-wrapper -p "$gemini_prompt" > ".workflow/.evaluation/$evaluation_session/strategic-analysis.md"
|
||||
;;
|
||||
"codex")
|
||||
echo "Performing technical assessment with Codex..."
|
||||
codex --full-auto exec "$codex_prompt" -s danger-full-access > ".workflow/.evaluation/$evaluation_session/technical-assessment.md"
|
||||
;;
|
||||
"both"|*)
|
||||
echo "Performing comprehensive evaluation with both tools..."
|
||||
~/.claude/scripts/gemini-wrapper -p "$gemini_prompt" > ".workflow/.evaluation/$evaluation_session/strategic-analysis.md" &
|
||||
codex --full-auto exec "$codex_prompt" -s danger-full-access > ".workflow/.evaluation/$evaluation_session/technical-assessment.md" &
|
||||
wait # Wait for both analyses to complete
|
||||
|
||||
# Synthesize results
|
||||
~/.claude/scripts/gemini-wrapper -p "
|
||||
PURPOSE: Synthesize strategic and technical concept evaluations
|
||||
TASK: Combine analyses and generate integrated recommendations
|
||||
CONTEXT: @{.workflow/.evaluation/$evaluation_session/strategic-analysis.md,.workflow/.evaluation/$evaluation_session/technical-assessment.md}
|
||||
EXPECTED: Integrated evaluation with prioritized recommendations
|
||||
RULES: Focus on actionable insights and clear next steps
|
||||
" > ".workflow/.evaluation/$evaluation_session/CONCEPT_EVALUATION.md"
|
||||
;;
|
||||
esac
|
||||
```
|
||||
|
||||
## Integration with Workflow Commands
|
||||
|
||||
### Workflow Position
|
||||
**Pre-Planning Phase**: Use before formal planning to optimize concept quality
|
||||
```
|
||||
concept-eval → plan → plan-verify → execute
|
||||
```
|
||||
|
||||
### Usage Scenarios
|
||||
|
||||
**Early Concept Validation**:
|
||||
```bash
|
||||
# Validate initial concept before detailed planning
|
||||
/workflow:concept-eval "Build real-time notification system using WebSockets"
|
||||
```
|
||||
|
||||
**Architecture Review**:
|
||||
```bash
|
||||
# Strategic architecture evaluation
|
||||
/workflow:concept-eval --tool gemini architecture-proposal.md
|
||||
```
|
||||
|
||||
**Technical Feasibility Check**:
|
||||
```bash
|
||||
# Technical implementation assessment
|
||||
/workflow:concept-eval --tool codex "Implement ML-based recommendation engine"
|
||||
```
|
||||
|
||||
**Comprehensive Analysis**:
|
||||
```bash
|
||||
# Full strategic and technical evaluation
|
||||
/workflow:concept-eval --tool both ISS-042
|
||||
```
|
||||
|
||||
### Integration Benefits
|
||||
- **Early Risk Detection**: Identify issues before detailed planning
|
||||
- **Quality Improvement**: Optimize concepts before implementation planning
|
||||
- **Resource Efficiency**: Avoid detailed planning of infeasible concepts
|
||||
- **Decision Support**: Data-driven concept selection and refinement
|
||||
- **Team Alignment**: Clear evaluation criteria and recommendations
|
||||
|
||||
## Error Handling & Edge Cases
|
||||
|
||||
### Input Validation
|
||||
```bash
|
||||
# Validate input format and accessibility
|
||||
if [[ -z "$input" ]]; then
|
||||
echo "Error: Concept input required"
|
||||
echo "Usage: /workflow:concept-eval [--tool gemini|codex|both] <input>"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check file accessibility for file inputs
|
||||
if [[ "$input" =~ \.(md|txt|json|yaml|yml)$ ]] && [[ ! -f "$input" ]]; then
|
||||
echo "Error: File not found: $input"
|
||||
echo "Please provide a valid file path or concept description"
|
||||
exit 1
|
||||
fi
|
||||
```
|
||||
|
||||
### Tool Availability
|
||||
```bash
|
||||
# Check tool availability
|
||||
if [[ "$tool_choice" == "gemini" ]] || [[ "$tool_choice" == "both" ]]; then
|
||||
if ! command -v ~/.claude/scripts/gemini-wrapper &> /dev/null; then
|
||||
echo "Warning: Gemini wrapper not available, using codex only"
|
||||
tool_choice="codex"
|
||||
fi
|
||||
fi
|
||||
|
||||
if [[ "$tool_choice" == "codex" ]] || [[ "$tool_choice" == "both" ]]; then
|
||||
if ! command -v codex &> /dev/null; then
|
||||
echo "Warning: Codex not available, using gemini only"
|
||||
tool_choice="gemini"
|
||||
fi
|
||||
fi
|
||||
```
|
||||
|
||||
### Recovery Strategies
|
||||
```bash
|
||||
# Fallback to manual evaluation if tools fail
|
||||
if [[ "$evaluation_failed" == "true" ]]; then
|
||||
echo "Automated evaluation failed, generating manual evaluation template..."
|
||||
cat > ".workflow/.evaluation/$evaluation_session/manual-evaluation-template.md" << EOF
|
||||
# Manual Concept Evaluation
|
||||
|
||||
## Concept Description
|
||||
$input_description
|
||||
|
||||
## Evaluation Checklist
|
||||
- [ ] **Architectural Soundness**: Does the concept align with existing architecture?
|
||||
- [ ] **Technical Feasibility**: Are required technologies available and mature?
|
||||
- [ ] **Resource Requirements**: Are time and team resources realistic?
|
||||
- [ ] **Integration Complexity**: How complex is integration with existing systems?
|
||||
- [ ] **Risk Assessment**: What are the main technical and business risks?
|
||||
|
||||
## Recommendations
|
||||
[Provide manual evaluation and recommendations]
|
||||
EOF
|
||||
fi
|
||||
```
|
||||
|
||||
## Quality Standards
|
||||
|
||||
### Evaluation Excellence
|
||||
- **Comprehensive Analysis**: Consider all aspects of concept feasibility
|
||||
- **Context-Rich Assessment**: Leverage full project context and existing patterns
|
||||
- **Actionable Recommendations**: Provide specific, implementable suggestions
|
||||
- **Risk-Aware Evaluation**: Identify and assess potential implementation risks
|
||||
|
||||
### User Experience Excellence
|
||||
- **Clear Results**: Present evaluation results in actionable format
|
||||
- **Focused Recommendations**: Prioritize most critical optimization suggestions
|
||||
- **Integration Guidance**: Provide clear next steps for concept refinement
|
||||
- **Tool Transparency**: Clear indication of which tools were used and why
|
||||
|
||||
### Output Quality
|
||||
- **Structured Reports**: Consistent, well-organized evaluation documentation
|
||||
- **Evidence-Based**: All recommendations backed by analysis and reasoning
|
||||
- **Prioritized Actions**: Clear indication of critical vs. optional improvements
|
||||
- **Implementation Ready**: Evaluation results directly usable for planning phase
|
||||
301
.claude/commands/workflow/tools/context-gather.md
Normal file
301
.claude/commands/workflow/tools/context-gather.md
Normal file
@@ -0,0 +1,301 @@
|
||||
---
|
||||
name: gather
|
||||
description: Intelligently collect project context based on task description and package into standardized JSON
|
||||
usage: /workflow:tools:context-gather --session <session_id> "<task_description>"
|
||||
argument-hint: "--session WFS-session-id \"task description\""
|
||||
examples:
|
||||
- /workflow:tools:context-gather --session WFS-user-auth "Implement user authentication system"
|
||||
- /workflow:tools:context-gather --session WFS-payment "Refactor payment module API"
|
||||
- /workflow:tools:context-gather --session WFS-bugfix "Fix login validation error"
|
||||
---
|
||||
|
||||
# Context Gather Command (/workflow:tools:context-gather)
|
||||
|
||||
## Overview
|
||||
Intelligent context collector that gathers relevant information from project codebase, documentation, and dependencies based on task descriptions, generating standardized context packages.
|
||||
|
||||
## Core Philosophy
|
||||
- **Intelligent Collection**: Auto-identify relevant resources based on keyword analysis
|
||||
- **Comprehensive Coverage**: Collect code, documentation, configurations, and dependencies
|
||||
- **Standardized Output**: Generate unified format context-package.json
|
||||
- **Efficient Execution**: Optimize collection strategies to avoid irrelevant information
|
||||
|
||||
## Core Responsibilities
|
||||
- **Keyword Extraction**: Extract core keywords from task descriptions
|
||||
- **Smart Documentation Loading**: Load relevant project documentation based on keywords
|
||||
- **Code Structure Analysis**: Analyze project structure to locate relevant code files
|
||||
- **Dependency Discovery**: Identify tech stack and dependency relationships
|
||||
- **MCP Tools Integration**: Leverage code-index tools for enhanced collection
|
||||
- **Context Packaging**: Generate standardized JSON context packages
|
||||
|
||||
## Execution Process
|
||||
|
||||
### Phase 1: Task Analysis
|
||||
1. **Keyword Extraction**
|
||||
- Parse task description to extract core keywords
|
||||
- Identify technical domain (auth, API, frontend, backend, etc.)
|
||||
- Determine complexity level (simple, medium, complex)
|
||||
|
||||
2. **Scope Determination**
|
||||
- Define collection scope based on keywords
|
||||
- Identify potentially involved modules and components
|
||||
- Set file type filters
|
||||
|
||||
### Phase 2: Project Structure Exploration
|
||||
1. **Architecture Analysis**
|
||||
- Use `~/.claude/scripts/get_modules_by_depth.sh` for comprehensive project structure
|
||||
- Analyze project layout and module organization
|
||||
- Identify key directories and components
|
||||
|
||||
2. **Code File Location**
|
||||
- Use MCP tools for precise search: `mcp__code-index__find_files()` and `mcp__code-index__search_code_advanced()`
|
||||
- Search for relevant source code files based on keywords
|
||||
- Locate implementation files, interfaces, and modules
|
||||
|
||||
3. **Documentation Collection**
|
||||
- Load CLAUDE.md and README.md
|
||||
- Load relevant documentation from .workflow/docs/ based on keywords
|
||||
- Collect configuration files (package.json, requirements.txt, etc.)
|
||||
|
||||
### Phase 3: Intelligent Filtering & Association
|
||||
1. **Relevance Scoring**
|
||||
- Score based on keyword match degree
|
||||
- Score based on file path relevance
|
||||
- Score based on code content relevance
|
||||
|
||||
2. **Dependency Analysis**
|
||||
- Analyze import/require statements
|
||||
- Identify inter-module dependencies
|
||||
- Determine core and optional dependencies
|
||||
|
||||
### Phase 4: Context Packaging
|
||||
1. **Standardized Output**
|
||||
- Generate context-package.json
|
||||
- Organize resources by type and importance
|
||||
- Add relevance descriptions and usage recommendations
|
||||
|
||||
## Context Package Format
|
||||
|
||||
Generated context package format:
|
||||
|
||||
```json
|
||||
{
|
||||
"metadata": {
|
||||
"task_description": "Implement user authentication system",
|
||||
"timestamp": "2025-09-29T10:30:00Z",
|
||||
"keywords": ["user", "authentication", "JWT", "login"],
|
||||
"complexity": "medium",
|
||||
"tech_stack": ["typescript", "node.js", "express"],
|
||||
"session_id": "WFS-user-auth"
|
||||
},
|
||||
"assets": [
|
||||
{
|
||||
"type": "documentation",
|
||||
"path": "CLAUDE.md",
|
||||
"relevance": "Project development standards and conventions",
|
||||
"priority": "high"
|
||||
},
|
||||
{
|
||||
"type": "documentation",
|
||||
"path": ".workflow/docs/architecture/security.md",
|
||||
"relevance": "Security architecture design guidance",
|
||||
"priority": "high"
|
||||
},
|
||||
{
|
||||
"type": "source_code",
|
||||
"path": "src/auth/AuthService.ts",
|
||||
"relevance": "Existing authentication service implementation",
|
||||
"priority": "high"
|
||||
},
|
||||
{
|
||||
"type": "source_code",
|
||||
"path": "src/models/User.ts",
|
||||
"relevance": "User data model definition",
|
||||
"priority": "medium"
|
||||
},
|
||||
{
|
||||
"type": "config",
|
||||
"path": "package.json",
|
||||
"relevance": "Project dependencies and tech stack",
|
||||
"priority": "medium"
|
||||
},
|
||||
{
|
||||
"type": "test",
|
||||
"path": "tests/auth/*.test.ts",
|
||||
"relevance": "Authentication related test cases",
|
||||
"priority": "medium"
|
||||
}
|
||||
],
|
||||
"tech_stack": {
|
||||
"frameworks": ["express", "typescript"],
|
||||
"libraries": ["jsonwebtoken", "bcrypt"],
|
||||
"testing": ["jest", "supertest"]
|
||||
},
|
||||
"statistics": {
|
||||
"total_files": 15,
|
||||
"source_files": 8,
|
||||
"docs_files": 4,
|
||||
"config_files": 2,
|
||||
"test_files": 1
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## MCP Tools Integration
|
||||
|
||||
### Code Index Integration
|
||||
```bash
|
||||
# Set project path
|
||||
mcp__code-index__set_project_path(path="{current_project_path}")
|
||||
|
||||
# Refresh index to ensure latest
|
||||
mcp__code-index__refresh_index()
|
||||
|
||||
# Search relevant files
|
||||
mcp__code-index__find_files(pattern="*{keyword}*")
|
||||
|
||||
# Search code content
|
||||
mcp__code-index__search_code_advanced(
|
||||
pattern="{keyword_patterns}",
|
||||
file_pattern="*.{ts,js,py,go,md}",
|
||||
context_lines=3
|
||||
)
|
||||
```
|
||||
|
||||
|
||||
## Session ID Integration
|
||||
|
||||
### Session ID Usage
|
||||
- **Required Parameter**: `--session WFS-session-id`
|
||||
- **Session Context Loading**: Load existing session state and task summaries
|
||||
- **Session Continuity**: Maintain context across pipeline phases
|
||||
|
||||
### Session State Management
|
||||
```bash
|
||||
# Validate session exists
|
||||
if [ ! -d ".workflow/${session_id}" ]; then
|
||||
echo "❌ Session ${session_id} not found"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Load session metadata
|
||||
session_metadata=".workflow/${session_id}/workflow-session.json"
|
||||
```
|
||||
|
||||
## Output Location
|
||||
|
||||
Context package output location:
|
||||
```
|
||||
.workflow/{session_id}/.process/context-package.json
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
### Common Error Handling
|
||||
1. **No Active Session**: Create temporary session directory
|
||||
2. **MCP Tools Unavailable**: Fallback to traditional bash commands
|
||||
3. **Permission Errors**: Prompt user to check file permissions
|
||||
4. **Large Project Optimization**: Limit file count, prioritize high-relevance files
|
||||
|
||||
### Graceful Degradation Strategy
|
||||
```bash
|
||||
# Fallback when MCP unavailable
|
||||
if ! command -v mcp__code-index__find_files; then
|
||||
# Use find command for file discovery
|
||||
find . -name "*{keyword}*" -type f -not -path "*/node_modules/*" -not -path "*/.git/*"
|
||||
|
||||
# Alternative pattern matching
|
||||
find . -type f \( -name "*.ts" -o -name "*.js" -o -name "*.py" -o -name "*.go" \) -exec grep -l "{keyword}" {} \;
|
||||
fi
|
||||
|
||||
# Use ripgrep instead of MCP search
|
||||
rg "{keywords}" --type-add 'source:*.{ts,js,py,go}' -t source --max-count 30
|
||||
|
||||
# Content-based search with context
|
||||
rg -A 3 -B 3 "{keywords}" --type-add 'source:*.{ts,js,py,go}' -t source
|
||||
|
||||
# Quick relevance check
|
||||
grep -r --include="*.{ts,js,py,go}" -l "{keywords}" . | head -15
|
||||
|
||||
# Test files discovery
|
||||
find . -name "*test*" -o -name "*spec*" | grep -E "\.(ts|js|py|go)$" | head -10
|
||||
|
||||
# Import/dependency analysis
|
||||
rg "^(import|from|require|#include)" --type-add 'source:*.{ts,js,py,go}' -t source | head -20
|
||||
```
|
||||
|
||||
## Performance Optimization
|
||||
|
||||
### Large Project Optimization Strategy
|
||||
- **File Count Limit**: Maximum 50 files per type
|
||||
- **Size Filtering**: Skip oversized files (>10MB)
|
||||
- **Depth Limit**: Maximum search depth of 3 levels
|
||||
- **Caching Strategy**: Cache project structure analysis results
|
||||
|
||||
### Parallel Processing
|
||||
- Documentation collection and code search in parallel
|
||||
- MCP tool calls and traditional commands in parallel
|
||||
- Reduce I/O wait time
|
||||
|
||||
## Essential Bash Commands (Max 10)
|
||||
|
||||
### 1. Project Structure Analysis
|
||||
```bash
|
||||
~/.claude/scripts/get_modules_by_depth.sh
|
||||
```
|
||||
|
||||
### 2. File Discovery by Keywords
|
||||
```bash
|
||||
find . -name "*{keyword}*" -type f -not -path "*/node_modules/*" -not -path "*/.git/*"
|
||||
```
|
||||
|
||||
### 3. Content Search in Code Files
|
||||
```bash
|
||||
rg "{keyword}" --type-add 'source:*.{ts,js,py,go}' -t source --max-count 20
|
||||
```
|
||||
|
||||
### 4. Configuration Files Discovery
|
||||
```bash
|
||||
find . -maxdepth 3 \( -name "*.json" -o -name "package.json" -o -name "requirements.txt" -o -name "Cargo.toml" \) -not -path "*/node_modules/*"
|
||||
```
|
||||
|
||||
### 5. Documentation Files Collection
|
||||
```bash
|
||||
find . -name "*.md" -o -name "README*" -o -name "CLAUDE.md" | grep -v node_modules | head -10
|
||||
```
|
||||
|
||||
### 6. Test Files Location
|
||||
```bash
|
||||
find . \( -name "*test*" -o -name "*spec*" \) -type f | grep -E "\.(js|ts|py|go)$" | head -10
|
||||
```
|
||||
|
||||
### 7. Function/Class Definitions Search
|
||||
```bash
|
||||
rg "^(function|def|func|class|interface)" --type-add 'source:*.{ts,js,py,go}' -t source -n --max-count 15
|
||||
```
|
||||
|
||||
### 8. Import/Dependency Analysis
|
||||
```bash
|
||||
rg "^(import|from|require|#include)" --type-add 'source:*.{ts,js,py,go}' -t source | head -15
|
||||
```
|
||||
|
||||
### 9. Workflow Session Information
|
||||
```bash
|
||||
find .workflow/ -name "*.json" -path "*/${session_id}/*" -o -name "workflow-session.json" | head -5
|
||||
```
|
||||
|
||||
### 10. Context-Aware Content Search
|
||||
```bash
|
||||
rg -A 2 -B 2 "{keywords}" --type-add 'source:*.{ts,js,py,go}' -t source --max-count 10
|
||||
```
|
||||
|
||||
## Success Criteria
|
||||
- Generate valid context-package.json file
|
||||
- Contains sufficient relevant information for subsequent analysis
|
||||
- Execution time controlled within 30 seconds
|
||||
- File relevance accuracy rate >80%
|
||||
|
||||
## Related Commands
|
||||
- `/analysis:run` - Consumes output of this command for analysis
|
||||
- `/workflow:plan` - Calls this command to gather context
|
||||
- `/workflow:status` - Can display context collection status
|
||||
Reference in New Issue
Block a user