mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-12 02:37:45 +08:00
feat: Add task-generate-agent and task-generate commands for autonomous task generation and manual task creation
- Implemented task-generate-agent for autonomous task generation using action-planning-agent with discovery and output phases. - Introduced task-generate command to generate task JSON files and IMPL_PLAN.md from analysis results with automatic artifact detection and integration. - Enhanced documentation for both commands, detailing execution lifecycle, phases, and output structures. - Established clear integration points and error handling for improved user experience.
This commit is contained in:
catlog22
@@ -11,26 +11,28 @@ examples:
|
||||
# Enhanced Analysis 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.
|
||||
Advanced solution design and feasibility analysis engine with parallel CLI execution that processes standardized context packages and produces comprehensive technical analysis focused on solution improvements, key design decisions, and critical insights.
|
||||
|
||||
**Independent Usage**: This command can be called directly by users or as part of the `/workflow:plan` command. It accepts context packages and provides comprehensive analysis results that can be used for planning or standalone analysis.
|
||||
**Analysis Focus**: Produces ANALYSIS_RESULTS.md with solution design, architectural rationale, feasibility assessment, and optimization strategies. Does NOT generate task breakdowns or implementation plans.
|
||||
|
||||
**Independent Usage**: This command can be called directly by users or as part of the `/workflow:plan` command. It accepts context packages and provides solution-focused technical analysis.
|
||||
|
||||
## Core Philosophy
|
||||
- **Context-Driven**: Precise analysis based on comprehensive context
|
||||
- **Intelligent Tool Selection**: Choose optimal analysis tools based on task characteristics
|
||||
- **Solution-Focused**: Emphasize design decisions, architectural rationale, and critical insights
|
||||
- **Context-Driven**: Precise analysis based on comprehensive context packages
|
||||
- **Intelligent Tool Selection**: Choose optimal tools based on task complexity (Gemini for design, Codex for validation)
|
||||
- **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
|
||||
- **No Task Planning**: Exclude implementation steps, task breakdowns, and project planning
|
||||
- **Single Output**: Generate only ANALYSIS_RESULTS.md with technical analysis
|
||||
|
||||
## 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
|
||||
- **Parallel CLI Orchestration**: Execute Gemini (solution design) and optionally Codex (feasibility validation)
|
||||
- **Solution Design Analysis**: Evaluate architecture, identify key design decisions with rationale
|
||||
- **Feasibility Assessment**: Analyze technical complexity, risks, and implementation readiness
|
||||
- **Optimization Recommendations**: Propose performance, security, and code quality improvements
|
||||
- **Perspective Synthesis**: Integrate Gemini and Codex insights into unified solution assessment
|
||||
- **Technical Analysis Report**: Generate ANALYSIS_RESULTS.md focused on design decisions and critical insights (NO task planning)
|
||||
|
||||
## Analysis Strategy Selection
|
||||
|
||||
@@ -114,41 +116,42 @@ Advanced intelligent planning engine with parallel CLI execution that processes
|
||||
- Prepare error handling and recovery mechanisms
|
||||
|
||||
### Phase 3: Parallel Analysis Execution
|
||||
1. **Gemini Comprehensive Analysis & Documentation**
|
||||
1. **Gemini Solution Design & Architecture Analysis**
|
||||
- **Tool Configuration**:
|
||||
```bash
|
||||
cd .workflow/{session_id}/.process && ~/.claude/scripts/gemini-wrapper -p "
|
||||
PURPOSE: Generate comprehensive analysis and documentation for {task_description}
|
||||
TASK: Analyze codebase, create implementation blueprints, and generate supporting documentation
|
||||
PURPOSE: Analyze and design optimal solution for {task_description}
|
||||
TASK: Evaluate current architecture, propose solution design, and identify key design decisions
|
||||
CONTEXT: {context_package_assets}
|
||||
EXPECTED:
|
||||
1. Current State Analysis: Architecture patterns, code quality, technical debt, performance bottlenecks
|
||||
2. Enhanced Suggestions: Implementation blueprints, code organization, API specifications, security guidelines
|
||||
3. Implementation Roadmap: Phase-by-phase plans, CI/CD blueprints, testing strategies
|
||||
4. Actionable Examples: Code templates, configuration scripts, integration patterns
|
||||
5. Documentation Generation: Technical documentation, API docs, user guides, and README files
|
||||
6. Generate .workflow/{session_id}/.process/gemini-enhanced-analysis.md with all analysis results
|
||||
RULES: Create both analysis blueprints AND user-facing documentation. Generate actual documentation files, not just analysis of documentation needs. Focus on planning documents, architectural designs, and specifications - do NOT generate specific code implementations.
|
||||
1. CURRENT STATE: Existing patterns, code structure, integration points, technical debt
|
||||
2. SOLUTION DESIGN: Core architecture principles, system design, key design decisions with rationale
|
||||
3. CRITICAL INSIGHTS: What works well, identified gaps, technical risks, architectural tradeoffs
|
||||
4. OPTIMIZATION STRATEGIES: Performance improvements, security enhancements, code quality recommendations
|
||||
5. FEASIBILITY ASSESSMENT: Complexity analysis, compatibility evaluation, implementation readiness
|
||||
6. Generate .workflow/{session_id}/.process/gemini-solution-design.md with complete analysis
|
||||
RULES: Focus on SOLUTION IMPROVEMENTS and KEY DESIGN DECISIONS, not task planning. Provide architectural rationale, evaluate alternatives, assess tradeoffs. Do NOT create task lists or implementation plans. Output ONLY ANALYSIS_RESULTS.md.
|
||||
" --approval-mode yolo
|
||||
```
|
||||
- **Output Location**: `.workflow/{session_id}/.process/gemini-enhanced-analysis.md` + generated docs
|
||||
- **Output Location**: `.workflow/{session_id}/.process/gemini-solution-design.md`
|
||||
|
||||
2. **Codex Implementation Validation** (Complex Tasks Only)
|
||||
2. **Codex Technical Feasibility Validation** (Complex Tasks Only)
|
||||
- **Tool Configuration**:
|
||||
```bash
|
||||
codex -C .workflow/{session_id}/.process --full-auto exec "
|
||||
PURPOSE: Technical feasibility validation with write-enabled blueprint generation
|
||||
TASK: Validate implementation feasibility and generate comprehensive blueprints
|
||||
CONTEXT: {context_package_assets} and {gemini_analysis_results}
|
||||
PURPOSE: Validate technical feasibility and identify implementation risks for {task_description}
|
||||
TASK: Assess implementation complexity, validate technology choices, evaluate performance and security implications
|
||||
CONTEXT: {context_package_assets} and {gemini_solution_design}
|
||||
EXPECTED:
|
||||
1. Feasibility Assessment: Complexity analysis, resource requirements, technology compatibility
|
||||
2. Implementation Validation: Quality recommendations, security assessments, testing frameworks
|
||||
3. Implementation Guides: Step-by-step procedures, configuration management, monitoring setup
|
||||
4. Generate .workflow/{session_id}/.process/codex-validation-analysis.md with all validation results
|
||||
RULES: Focus on technical validation, security assessments, and implementation planning examples. Create comprehensive validation documentation with architectural guidance and specifications - do NOT generate specific code implementations.
|
||||
1. FEASIBILITY ASSESSMENT: Technical complexity rating, resource requirements, technology compatibility
|
||||
2. RISK ANALYSIS: Implementation risks, integration challenges, performance concerns, security vulnerabilities
|
||||
3. TECHNICAL VALIDATION: Development approach validation, quality standards assessment, maintenance implications
|
||||
4. CRITICAL RECOMMENDATIONS: Must-have requirements, optimization opportunities, security controls
|
||||
5. Generate .workflow/{session_id}/.process/codex-feasibility-validation.md with validation results
|
||||
RULES: Focus on TECHNICAL FEASIBILITY and RISK ASSESSMENT, not implementation planning. Validate architectural decisions, identify potential issues, recommend optimizations. Do NOT create task breakdowns or step-by-step guides. Output ONLY feasibility analysis.
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
- **Output Location**: `.workflow/{session_id}/.process/codex-validation-analysis.md`
|
||||
- **Output Location**: `.workflow/{session_id}/.process/codex-feasibility-validation.md`
|
||||
|
||||
3. **Parallel Execution Management**
|
||||
- Launch both tools simultaneously for complex tasks
|
||||
@@ -156,179 +159,209 @@ Advanced intelligent planning engine with parallel CLI execution that processes
|
||||
- Handle process completion and error scenarios
|
||||
- Maintain execution logs for debugging and recovery
|
||||
|
||||
### Phase 4: Results Collection & Validation
|
||||
### Phase 4: Results Collection & Synthesis
|
||||
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
|
||||
- **Gemini Results**: Validate `gemini-solution-design.md` contains complete solution analysis
|
||||
- **Codex Results**: For complex tasks, validate `codex-feasibility-validation.md` with technical assessment
|
||||
- **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
|
||||
- **Design Quality**: Verify architectural decisions have clear rationale and alternatives analysis
|
||||
- **Insight Depth**: Assess quality of critical insights and risk identification
|
||||
- **Feasibility Rigor**: Validate completeness of technical feasibility assessment
|
||||
- **Optimization Value**: Check actionability of optimization recommendations
|
||||
|
||||
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
|
||||
3. **Analysis Synthesis Strategy**
|
||||
- **Simple/Medium Tasks**: Direct integration of Gemini solution design
|
||||
- **Complex Tasks**: Synthesis of Gemini design with Codex feasibility validation
|
||||
- **Conflict Resolution**: Identify architectural disagreements and provide balanced resolution
|
||||
- **Confidence Scoring**: Assess overall solution confidence based on multi-tool consensus
|
||||
|
||||
### 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
|
||||
- **Executive Summary**: Analysis focus, overall assessment, recommendation status
|
||||
- **Current State Analysis**: Architecture overview, compatibility, critical findings
|
||||
- **Proposed Solution Design**: Core principles, system design, key design decisions with rationale
|
||||
- **Implementation Strategy**: Development approach, feasibility assessment, risk mitigation
|
||||
- **Solution Optimization**: Performance, security, code quality recommendations
|
||||
- **Critical Success Factors**: Technical requirements, quality metrics, success validation
|
||||
- **Confidence & Recommendations**: Assessment scores, final recommendation with rationale
|
||||
|
||||
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
|
||||
2. **Report Generation Guidelines**
|
||||
- **Focus**: Solution improvements, key design decisions, critical insights
|
||||
- **Exclude**: Task breakdowns, implementation steps, project planning
|
||||
- **Emphasize**: Architectural rationale, tradeoff analysis, risk assessment
|
||||
- **Structure**: Clear sections with decision justification and feasibility scoring
|
||||
|
||||
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
|
||||
3. **Final Output**
|
||||
- **Primary Output**: `ANALYSIS_RESULTS.md` - comprehensive solution design and technical analysis
|
||||
- **Single File Policy**: Only generate ANALYSIS_RESULTS.md, no supplementary files
|
||||
- **Report Location**: `.workflow/{session_id}/.process/ANALYSIS_RESULTS.md`
|
||||
- **Content Focus**: Technical insights, design decisions, optimization strategies
|
||||
|
||||
## Analysis Results Format
|
||||
|
||||
Generated ANALYSIS_RESULTS.md format (Multi-Tool Perspective Analysis):
|
||||
Generated ANALYSIS_RESULTS.md focuses on **solution improvements, key design decisions, and critical insights** (NOT task planning):
|
||||
|
||||
```markdown
|
||||
# Multi-Tool Analysis Results
|
||||
# Technical Analysis & Solution Design
|
||||
|
||||
## Task Overview
|
||||
- **Description**: {task_description}
|
||||
- **Context Package**: {context_package_path}
|
||||
- **Analysis Tools**: {tools_used}
|
||||
## Executive Summary
|
||||
- **Analysis Focus**: {core_problem_or_improvement_area}
|
||||
- **Analysis Timestamp**: {timestamp}
|
||||
- **Tools Used**: {analysis_tools}
|
||||
- **Overall Assessment**: {feasibility_score}/5 - {recommendation_status}
|
||||
|
||||
## 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
|
||||
## 1. Current State Analysis
|
||||
|
||||
#### Current Architecture Assessment
|
||||
- **Existing Patterns**: {identified_patterns}
|
||||
- **Code Structure**: {current_structure}
|
||||
- **Integration Points**: {integration_analysis}
|
||||
- **Technical Debt**: {debt_assessment}
|
||||
### Architecture Overview
|
||||
- **Existing Patterns**: {key_architectural_patterns}
|
||||
- **Code Structure**: {current_codebase_organization}
|
||||
- **Integration Points**: {system_integration_touchpoints}
|
||||
- **Technical Debt Areas**: {identified_debt_with_impact}
|
||||
|
||||
#### Compatibility Analysis
|
||||
- **Framework Compatibility**: {framework_analysis}
|
||||
- **Dependency Impact**: {dependency_analysis}
|
||||
- **Migration Considerations**: {migration_notes}
|
||||
### Compatibility & Dependencies
|
||||
- **Framework Alignment**: {framework_compatibility_assessment}
|
||||
- **Dependency Analysis**: {critical_dependencies_and_risks}
|
||||
- **Migration Considerations**: {backward_compatibility_concerns}
|
||||
|
||||
#### Proposed Architecture
|
||||
- **System Design**: {architectural_design}
|
||||
- **Component Structure**: {component_design}
|
||||
- **Data Flow**: {data_flow_design}
|
||||
- **Interface Design**: {api_interface_design}
|
||||
### Critical Findings
|
||||
- **Strengths**: {what_works_well}
|
||||
- **Gaps**: {missing_capabilities_or_issues}
|
||||
- **Risks**: {identified_technical_and_business_risks}
|
||||
|
||||
#### 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
|
||||
## 2. Proposed Solution Design
|
||||
|
||||
#### Feasibility Assessment
|
||||
- **Technical Risks**: {implementation_risks}
|
||||
- **Performance Impact**: {performance_analysis}
|
||||
- **Resource Requirements**: {resource_assessment}
|
||||
- **Maintenance Complexity**: {maintenance_analysis}
|
||||
### Core Architecture Principles
|
||||
- **Design Philosophy**: {key_design_principles}
|
||||
- **Architectural Approach**: {chosen_architectural_pattern_with_rationale}
|
||||
- **Scalability Strategy**: {how_solution_scales}
|
||||
|
||||
#### 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}
|
||||
### System Design
|
||||
- **Component Architecture**: {high_level_component_design}
|
||||
- **Data Flow**: {data_flow_patterns_and_state_management}
|
||||
- **API Design**: {interface_contracts_and_specifications}
|
||||
- **Integration Strategy**: {how_components_integrate}
|
||||
|
||||
### Key Design Decisions
|
||||
1. **Decision**: {critical_design_choice}
|
||||
- **Rationale**: {why_this_approach}
|
||||
- **Alternatives Considered**: {other_options_and_tradeoffs}
|
||||
- **Impact**: {implications_on_architecture}
|
||||
|
||||
## Synthesis & Consensus
|
||||
2. **Decision**: {another_critical_choice}
|
||||
- **Rationale**: {reasoning}
|
||||
- **Alternatives Considered**: {tradeoffs}
|
||||
- **Impact**: {consequences}
|
||||
|
||||
### 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}
|
||||
### Technical Specifications
|
||||
- **Technology Stack**: {chosen_technologies_with_justification}
|
||||
- **Code Organization**: {module_structure_and_patterns}
|
||||
- **Testing Strategy**: {testing_approach_and_coverage}
|
||||
- **Performance Targets**: {performance_requirements_and_benchmarks}
|
||||
|
||||
## Implementation Roadmap
|
||||
---
|
||||
|
||||
### Phase 1: Foundation Setup
|
||||
- **Infrastructure**: {infrastructure_setup_blueprint}
|
||||
- **Development Environment**: {dev_env_configuration}
|
||||
- **Initial Architecture**: {foundational_architecture}
|
||||
## 3. Implementation Strategy
|
||||
|
||||
### Phase 2: Core Implementation
|
||||
- **Priority Features**: {core_feature_implementation}
|
||||
- **Testing Framework**: {testing_implementation_strategy}
|
||||
- **Quality Gates**: {quality_assurance_checkpoints}
|
||||
### Development Approach
|
||||
- **Core Implementation Pattern**: {primary_implementation_strategy}
|
||||
- **Module Dependencies**: {dependency_graph_and_order}
|
||||
- **Quality Assurance**: {qa_approach_and_validation}
|
||||
|
||||
### Phase 3: Enhancement & Optimization
|
||||
- **Performance Tuning**: {performance_enhancement_plan}
|
||||
- **Security Hardening**: {security_implementation_steps}
|
||||
- **Scalability Improvements**: {scalability_enhancement_strategy}
|
||||
### Feasibility Assessment
|
||||
- **Technical Complexity**: {complexity_rating_and_analysis}
|
||||
- **Performance Impact**: {expected_performance_characteristics}
|
||||
- **Resource Requirements**: {development_resources_needed}
|
||||
- **Maintenance Burden**: {ongoing_maintenance_considerations}
|
||||
|
||||
## Enhanced Quality Assurance Strategy
|
||||
### Risk Mitigation
|
||||
- **Technical Risks**: {implementation_risks_and_mitigation}
|
||||
- **Integration Risks**: {compatibility_challenges_and_solutions}
|
||||
- **Performance Risks**: {performance_concerns_and_strategies}
|
||||
- **Security Risks**: {security_vulnerabilities_and_controls}
|
||||
|
||||
### 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}
|
||||
## 4. Solution Optimization
|
||||
|
||||
### Tool Agreement Analysis
|
||||
- **Consensus Points**: {agreed_recommendations}
|
||||
- **Conflicting Views**: {conflicting_opinions}
|
||||
- **Resolution Strategy**: {conflict_resolution}
|
||||
### Performance Optimization
|
||||
- **Optimization Strategies**: {key_performance_improvements}
|
||||
- **Caching Strategy**: {caching_approach_and_invalidation}
|
||||
- **Resource Management**: {resource_utilization_optimization}
|
||||
- **Bottleneck Mitigation**: {identified_bottlenecks_and_solutions}
|
||||
|
||||
### Task Decomposition Suggestions
|
||||
1. **Primary Tasks**: {major_task_suggestions}
|
||||
2. **Task Dependencies**: {dependency_mapping}
|
||||
3. **Complexity Assessment**: {complexity_evaluation}
|
||||
### Security Enhancements
|
||||
- **Security Model**: {authentication_authorization_approach}
|
||||
- **Data Protection**: {data_security_and_encryption}
|
||||
- **Vulnerability Mitigation**: {known_vulnerabilities_and_controls}
|
||||
- **Compliance**: {regulatory_and_compliance_considerations}
|
||||
|
||||
## 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}
|
||||
### Code Quality
|
||||
- **Code Standards**: {coding_conventions_and_patterns}
|
||||
- **Testing Coverage**: {test_strategy_and_coverage_goals}
|
||||
- **Documentation**: {documentation_requirements}
|
||||
- **Maintainability**: {maintainability_practices}
|
||||
|
||||
## 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}
|
||||
## 5. Critical Success Factors
|
||||
|
||||
### Technical Requirements
|
||||
- **Must Have**: {essential_technical_capabilities}
|
||||
- **Should Have**: {important_but_not_critical_features}
|
||||
- **Nice to Have**: {optional_enhancements}
|
||||
|
||||
### Quality Metrics
|
||||
- **Performance Benchmarks**: {measurable_performance_targets}
|
||||
- **Code Quality Standards**: {quality_metrics_and_thresholds}
|
||||
- **Test Coverage Goals**: {testing_coverage_requirements}
|
||||
- **Security Standards**: {security_compliance_requirements}
|
||||
|
||||
### Success Validation
|
||||
- **Acceptance Criteria**: {how_to_validate_success}
|
||||
- **Testing Strategy**: {validation_testing_approach}
|
||||
- **Monitoring Plan**: {production_monitoring_strategy}
|
||||
- **Rollback Plan**: {failure_recovery_strategy}
|
||||
|
||||
---
|
||||
|
||||
## 6. Analysis Confidence & Recommendations
|
||||
|
||||
### Assessment Scores
|
||||
- **Conceptual Integrity**: {score}/5 - {brief_assessment}
|
||||
- **Architectural Soundness**: {score}/5 - {brief_assessment}
|
||||
- **Technical Feasibility**: {score}/5 - {brief_assessment}
|
||||
- **Implementation Readiness**: {score}/5 - {brief_assessment}
|
||||
- **Overall Confidence**: {overall_score}/5
|
||||
|
||||
### Final Recommendation
|
||||
**Status**: {PROCEED|PROCEED_WITH_MODIFICATIONS|RECONSIDER|REJECT}
|
||||
|
||||
**Rationale**: {clear_explanation_of_recommendation}
|
||||
|
||||
**Critical Prerequisites**: {what_must_be_resolved_before_proceeding}
|
||||
|
||||
---
|
||||
|
||||
## 7. Reference Information
|
||||
|
||||
### Tool Analysis Summary
|
||||
- **Gemini Insights**: {key_architectural_and_pattern_insights}
|
||||
- **Codex Validation**: {technical_feasibility_and_implementation_notes}
|
||||
- **Consensus Points**: {agreements_between_tools}
|
||||
- **Conflicting Views**: {disagreements_and_resolution}
|
||||
|
||||
### Context & Resources
|
||||
- **Analysis Context**: {context_package_reference}
|
||||
- **Documentation References**: {relevant_documentation}
|
||||
- **Related Patterns**: {similar_implementations_in_codebase}
|
||||
- **External Resources**: {external_references_and_best_practices}
|
||||
```
|
||||
|
||||
## Error Handling & Fallbacks
|
||||
@@ -397,11 +430,10 @@ fi
|
||||
- **Optional**: `--focus` specify analysis focus areas
|
||||
|
||||
### Output Interface
|
||||
- **Primary**: Enhanced ANALYSIS_RESULTS.md file with implementation blueprints
|
||||
- **Primary**: ANALYSIS_RESULTS.md - solution design and technical analysis
|
||||
- **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)
|
||||
- **Single Output Policy**: Only ANALYSIS_RESULTS.md is generated
|
||||
- **No Supplementary Files**: No additional JSON, roadmap, or template files
|
||||
|
||||
## Quality Assurance
|
||||
|
||||
@@ -411,15 +443,15 @@ fi
|
||||
- **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 (exec ... --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
|
||||
- ✅ **Solution-Focused Analysis**: ANALYSIS_RESULTS.md emphasizes solution improvements, design decisions, and critical insights
|
||||
- ✅ **Single Output File**: Only ANALYSIS_RESULTS.md generated, no supplementary files
|
||||
- ✅ **Design Decision Depth**: Clear rationale for architectural choices with alternatives and tradeoffs
|
||||
- ✅ **Feasibility Assessment**: Technical complexity, risk analysis, and implementation readiness evaluation
|
||||
- ✅ **Optimization Strategies**: Performance, security, and code quality recommendations
|
||||
- ✅ **Parallel Execution**: Efficient concurrent tool execution (Gemini + Codex for complex tasks)
|
||||
- ✅ **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
|
||||
- ✅ **Confidence Scoring**: Multi-dimensional assessment with clear recommendation status
|
||||
- ✅ **No Task Planning**: Exclude task breakdowns, implementation steps, and project planning details
|
||||
|
||||
## Related Commands
|
||||
- `/context:gather` - Generate context packages required by this command
|
||||
|
||||
420
.claude/commands/workflow/tools/task-generate-agent.md
Normal file
420
.claude/commands/workflow/tools/task-generate-agent.md
Normal file
@@ -0,0 +1,420 @@
|
||||
---
|
||||
name: task-generate-agent
|
||||
description: Autonomous task generation using action-planning-agent with discovery and output phases
|
||||
usage: /workflow:tools:task-generate-agent --session <session_id>
|
||||
argument-hint: "--session WFS-session-id"
|
||||
examples:
|
||||
- /workflow:tools:task-generate-agent --session WFS-auth
|
||||
---
|
||||
|
||||
# Autonomous Task Generation Command
|
||||
|
||||
## Overview
|
||||
Autonomous task JSON and IMPL_PLAN.md generation using action-planning-agent with two-phase execution: discovery and document generation.
|
||||
|
||||
## Core Philosophy
|
||||
- **Agent-Driven**: Delegate execution to action-planning-agent for autonomous operation
|
||||
- **Two-Phase Flow**: Discovery (context gathering) → Output (document generation)
|
||||
- **Memory-First**: Reuse loaded documents from conversation memory
|
||||
- **MCP-Enhanced**: Use MCP tools for advanced code analysis and research
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Phase 1: Discovery & Context Loading
|
||||
**⚡ Memory-First Rule**: Skip file loading if documents already in conversation memory
|
||||
|
||||
**Agent Context Package**:
|
||||
```javascript
|
||||
{
|
||||
"session_id": "WFS-[session-id]",
|
||||
"session_metadata": {
|
||||
// If in memory: use cached content
|
||||
// Else: Load from .workflow/{session-id}/workflow-session.json
|
||||
},
|
||||
"analysis_results": {
|
||||
// If in memory: use cached content
|
||||
// Else: Load from .workflow/{session-id}/.process/ANALYSIS_RESULTS.md
|
||||
},
|
||||
"artifacts_inventory": {
|
||||
// If in memory: use cached list
|
||||
// Else: Scan .workflow/{session-id}/.brainstorming/ directory
|
||||
"synthesis_specification": "path or null",
|
||||
"topic_framework": "path or null",
|
||||
"role_analyses": ["paths"]
|
||||
},
|
||||
"context_package": {
|
||||
// If in memory: use cached content
|
||||
// Else: Load from .workflow/{session-id}/.process/context-package.json
|
||||
},
|
||||
"mcp_capabilities": {
|
||||
"code_index": true,
|
||||
"exa_code": true,
|
||||
"exa_web": true
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Discovery Actions**:
|
||||
1. **Load Session Context** (if not in memory)
|
||||
```javascript
|
||||
if (!memory.has("workflow-session.json")) {
|
||||
Read(.workflow/{session-id}/workflow-session.json)
|
||||
}
|
||||
```
|
||||
|
||||
2. **Load Analysis Results** (if not in memory)
|
||||
```javascript
|
||||
if (!memory.has("ANALYSIS_RESULTS.md")) {
|
||||
Read(.workflow/{session-id}/.process/ANALYSIS_RESULTS.md)
|
||||
}
|
||||
```
|
||||
|
||||
3. **Discover Artifacts** (if not in memory)
|
||||
```javascript
|
||||
if (!memory.has("artifacts_inventory")) {
|
||||
bash(find .workflow/{session-id}/.brainstorming/ -name "*.md" -type f)
|
||||
}
|
||||
```
|
||||
|
||||
4. **MCP Code Analysis** (optional - enhance understanding)
|
||||
```javascript
|
||||
// Find relevant files for task context
|
||||
mcp__code-index__find_files(pattern="*auth*")
|
||||
mcp__code-index__search_code_advanced(
|
||||
pattern="authentication|oauth",
|
||||
file_pattern="*.ts"
|
||||
)
|
||||
```
|
||||
|
||||
5. **MCP External Research** (optional - gather best practices)
|
||||
```javascript
|
||||
// Get external examples for implementation
|
||||
mcp__exa__get_code_context_exa(
|
||||
query="TypeScript JWT authentication best practices",
|
||||
tokensNum="dynamic"
|
||||
)
|
||||
```
|
||||
|
||||
### Phase 2: Agent Execution (Document Generation)
|
||||
|
||||
**Agent Invocation**:
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="action-planning-agent",
|
||||
description="Generate task JSON and implementation plan",
|
||||
prompt=`
|
||||
## Execution Context
|
||||
|
||||
**Session ID**: WFS-{session-id}
|
||||
**Mode**: Two-Phase Autonomous Task Generation
|
||||
|
||||
## Phase 1: Discovery Results (Provided Context)
|
||||
|
||||
### Session Metadata
|
||||
{session_metadata_content}
|
||||
|
||||
### Analysis Results
|
||||
{analysis_results_content}
|
||||
|
||||
### Artifacts Inventory
|
||||
- **Synthesis Specification**: {synthesis_spec_path}
|
||||
- **Topic Framework**: {topic_framework_path}
|
||||
- **Role Analyses**: {role_analyses_list}
|
||||
|
||||
### Context Package
|
||||
{context_package_summary}
|
||||
|
||||
### MCP Analysis Results (Optional)
|
||||
**Code Structure**: {mcp_code_index_results}
|
||||
**External Research**: {mcp_exa_research_results}
|
||||
|
||||
## Phase 2: Document Generation Task
|
||||
|
||||
### Task Decomposition Standards
|
||||
**Core Principle**: Task Merging Over Decomposition
|
||||
- **Merge Rule**: Execute together when possible
|
||||
- **Decompose Only When**:
|
||||
- Excessive workload (>2500 lines or >6 files)
|
||||
- Different tech stacks or domains
|
||||
- Sequential dependency blocking
|
||||
- Parallel execution needed
|
||||
|
||||
**Task Limits**:
|
||||
- **Maximum 10 tasks** (hard limit)
|
||||
- **Function-based**: Complete units (logic + UI + tests + config)
|
||||
- **Hierarchy**: Flat (≤5) | Two-level (6-10) | Re-scope (>10)
|
||||
|
||||
### Required Outputs
|
||||
|
||||
#### 1. Task JSON Files (.task/IMPL-*.json)
|
||||
**Location**: .workflow/{session-id}/.task/
|
||||
**Schema**: 5-field enhanced schema with artifacts
|
||||
|
||||
**Required Fields**:
|
||||
\`\`\`json
|
||||
{
|
||||
"id": "IMPL-N[.M]",
|
||||
"title": "Descriptive task name",
|
||||
"status": "pending",
|
||||
"meta": {
|
||||
"type": "feature|bugfix|refactor|test|docs",
|
||||
"agent": "@code-developer|@code-review-test-agent"
|
||||
},
|
||||
"context": {
|
||||
"requirements": ["extracted from analysis"],
|
||||
"focus_paths": ["src/paths"],
|
||||
"acceptance": ["measurable criteria"],
|
||||
"depends_on": ["IMPL-N"],
|
||||
"artifacts": [
|
||||
{
|
||||
"type": "synthesis_specification",
|
||||
"path": "{synthesis_spec_path}",
|
||||
"priority": "highest"
|
||||
}
|
||||
]
|
||||
},
|
||||
"flow_control": {
|
||||
"pre_analysis": [
|
||||
{
|
||||
"step": "load_synthesis_specification",
|
||||
"action": "Load consolidated synthesis specification",
|
||||
"commands": [
|
||||
"bash(ls {synthesis_spec_path} 2>/dev/null || echo 'not found')",
|
||||
"Read({synthesis_spec_path})"
|
||||
],
|
||||
"output_to": "synthesis_specification",
|
||||
"on_error": "skip_optional"
|
||||
},
|
||||
{
|
||||
"step": "mcp_codebase_exploration",
|
||||
"action": "Explore codebase using MCP",
|
||||
"command": "mcp__code-index__find_files(pattern=\\"[patterns]\\") && mcp__code-index__search_code_advanced(pattern=\\"[patterns]\\")",
|
||||
"output_to": "codebase_structure"
|
||||
},
|
||||
{
|
||||
"step": "analyze_task_patterns",
|
||||
"action": "Analyze existing code patterns",
|
||||
"commands": [
|
||||
"bash(cd \\"[focus_paths]\\")",
|
||||
"bash(~/.claude/scripts/gemini-wrapper -p \\"PURPOSE: Analyze patterns TASK: Review '[title]' CONTEXT: [synthesis_specification] EXPECTED: Pattern analysis RULES: Prioritize synthesis-specification.md\\")"
|
||||
],
|
||||
"output_to": "task_context",
|
||||
"on_error": "fail"
|
||||
}
|
||||
],
|
||||
"implementation_approach": {
|
||||
"task_description": "Implement '[title]' following synthesis specification",
|
||||
"modification_points": ["Apply requirements from synthesis"],
|
||||
"logic_flow": [
|
||||
"Load synthesis specification",
|
||||
"Analyze existing patterns",
|
||||
"Implement following specification",
|
||||
"Validate against acceptance criteria"
|
||||
]
|
||||
},
|
||||
"target_files": ["file:function:lines"]
|
||||
}
|
||||
}
|
||||
\`\`\`
|
||||
|
||||
#### 2. IMPL_PLAN.md
|
||||
**Location**: .workflow/{session-id}/IMPL_PLAN.md
|
||||
**Structure**:
|
||||
\`\`\`markdown
|
||||
---
|
||||
identifier: WFS-{session-id}
|
||||
source: "User requirements"
|
||||
analysis: .workflow/{session-id}/.process/ANALYSIS_RESULTS.md
|
||||
---
|
||||
|
||||
# Implementation Plan: {Project Title}
|
||||
|
||||
## Summary
|
||||
Core requirements, objectives, and technical approach.
|
||||
|
||||
## Context Analysis
|
||||
- **Project**: Type, patterns, tech stack
|
||||
- **Modules**: Components and integration points
|
||||
- **Dependencies**: External libraries and constraints
|
||||
- **Patterns**: Code conventions and guidelines
|
||||
|
||||
## Brainstorming Artifacts
|
||||
- synthesis-specification.md (Highest priority)
|
||||
- topic-framework.md (Medium priority)
|
||||
- Role analyses: ui-designer, system-architect, etc.
|
||||
|
||||
## Task Breakdown
|
||||
- **Task Count**: N tasks, complexity level
|
||||
- **Hierarchy**: Flat/Two-level structure
|
||||
- **Dependencies**: Task dependency graph
|
||||
|
||||
## Implementation Plan
|
||||
- **Execution Strategy**: Sequential/Parallel approach
|
||||
- **Resource Requirements**: Tools, dependencies, artifacts
|
||||
- **Success Criteria**: Metrics and acceptance conditions
|
||||
\`\`\`
|
||||
|
||||
#### 3. TODO_LIST.md
|
||||
**Location**: .workflow/{session-id}/TODO_LIST.md
|
||||
**Structure**:
|
||||
\`\`\`markdown
|
||||
# Tasks: {Session Topic}
|
||||
|
||||
## Task Progress
|
||||
▸ **IMPL-001**: [Main Task Group] → [📋](./.task/IMPL-001.json)
|
||||
- [ ] **IMPL-001.1**: [Subtask] → [📋](./.task/IMPL-001.1.json)
|
||||
- [ ] **IMPL-001.2**: [Subtask] → [📋](./.task/IMPL-001.2.json)
|
||||
|
||||
- [ ] **IMPL-002**: [Simple Task] → [📋](./.task/IMPL-002.json)
|
||||
|
||||
## Status Legend
|
||||
- \`▸\` = Container task (has subtasks)
|
||||
- \`- [ ]\` = Pending leaf task
|
||||
- \`- [x]\` = Completed leaf task
|
||||
\`\`\`
|
||||
|
||||
### Execution Instructions
|
||||
|
||||
**Step 1: Extract Task Definitions**
|
||||
- Parse analysis results for task recommendations
|
||||
- Extract task ID, title, requirements, complexity
|
||||
- Map artifacts to relevant tasks based on type
|
||||
|
||||
**Step 2: Generate Task JSON Files**
|
||||
- Create individual .task/IMPL-*.json files
|
||||
- Embed artifacts array with detected brainstorming outputs
|
||||
- Generate flow_control with artifact loading steps
|
||||
- Add MCP tool integration for codebase exploration
|
||||
|
||||
**Step 3: Create IMPL_PLAN.md**
|
||||
- Summarize requirements and technical approach
|
||||
- List detected artifacts with priorities
|
||||
- Document task breakdown and dependencies
|
||||
- Define execution strategy and success criteria
|
||||
|
||||
**Step 4: Generate TODO_LIST.md**
|
||||
- List all tasks with container/leaf structure
|
||||
- Link to task JSON files
|
||||
- Use proper status indicators (▸, [ ], [x])
|
||||
|
||||
**Step 5: Update Session State**
|
||||
- Update .workflow/{session-id}/workflow-session.json
|
||||
- Mark session as ready for execution
|
||||
- Record task count and artifact inventory
|
||||
|
||||
### MCP Enhancement Examples
|
||||
|
||||
**Code Index Usage**:
|
||||
\`\`\`javascript
|
||||
// Discover authentication-related files
|
||||
mcp__code-index__find_files(pattern="*auth*")
|
||||
|
||||
// Search for OAuth patterns
|
||||
mcp__code-index__search_code_advanced(
|
||||
pattern="oauth|jwt|authentication",
|
||||
file_pattern="*.{ts,js}"
|
||||
)
|
||||
|
||||
// Get file summary for key components
|
||||
mcp__code-index__get_file_summary(
|
||||
file_path="src/auth/index.ts"
|
||||
)
|
||||
\`\`\`
|
||||
|
||||
**Exa Research Usage**:
|
||||
\`\`\`javascript
|
||||
// Get best practices for task implementation
|
||||
mcp__exa__get_code_context_exa(
|
||||
query="TypeScript OAuth2 implementation patterns",
|
||||
tokensNum="dynamic"
|
||||
)
|
||||
|
||||
// Research specific API usage
|
||||
mcp__exa__get_code_context_exa(
|
||||
query="Express.js JWT middleware examples",
|
||||
tokensNum=5000
|
||||
)
|
||||
\`\`\`
|
||||
|
||||
### Quality Validation
|
||||
|
||||
Before completion, verify:
|
||||
- [ ] All task JSON files created in .task/ directory
|
||||
- [ ] Each task JSON has 5 required fields
|
||||
- [ ] Artifact references correctly mapped
|
||||
- [ ] Flow control includes artifact loading steps
|
||||
- [ ] MCP tool integration added where appropriate
|
||||
- [ ] IMPL_PLAN.md follows required structure
|
||||
- [ ] TODO_LIST.md matches task JSONs
|
||||
- [ ] Dependency graph is acyclic
|
||||
- [ ] Task count within limits (≤10)
|
||||
- [ ] Session state updated
|
||||
|
||||
## Output
|
||||
|
||||
Generate all three documents and report completion status:
|
||||
- Task JSON files created: N files
|
||||
- Artifacts integrated: synthesis-spec, topic-framework, N role analyses
|
||||
- MCP enhancements: code-index, exa-research
|
||||
- Session ready for execution: /workflow:execute
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Command Integration
|
||||
|
||||
### Usage
|
||||
```bash
|
||||
# Basic usage
|
||||
/workflow:tools:task-generate-agent --session WFS-auth
|
||||
|
||||
# Called by /workflow:plan
|
||||
SlashCommand(command="/workflow:tools:task-generate-agent --session WFS-[id]")
|
||||
```
|
||||
|
||||
### Agent Context Passing
|
||||
|
||||
**Memory-Aware Context Assembly**:
|
||||
```javascript
|
||||
// Assemble context package for agent
|
||||
const agentContext = {
|
||||
session_id: "WFS-[id]",
|
||||
|
||||
// Use memory if available, else load
|
||||
session_metadata: memory.has("workflow-session.json")
|
||||
? memory.get("workflow-session.json")
|
||||
: Read(.workflow/WFS-[id]/workflow-session.json),
|
||||
|
||||
analysis_results: memory.has("ANALYSIS_RESULTS.md")
|
||||
? memory.get("ANALYSIS_RESULTS.md")
|
||||
: Read(.workflow/WFS-[id]/.process/ANALYSIS_RESULTS.md),
|
||||
|
||||
artifacts_inventory: memory.has("artifacts_inventory")
|
||||
? memory.get("artifacts_inventory")
|
||||
: discoverArtifacts(),
|
||||
|
||||
context_package: memory.has("context-package.json")
|
||||
? memory.get("context-package.json")
|
||||
: Read(.workflow/WFS-[id]/.process/context-package.json),
|
||||
|
||||
// Optional MCP enhancements
|
||||
mcp_analysis: executeMcpDiscovery()
|
||||
}
|
||||
```
|
||||
|
||||
## Related Commands
|
||||
- `/workflow:plan` - Orchestrates planning and calls this command
|
||||
- `/workflow:tools:task-generate` - Manual version without agent
|
||||
- `/workflow:tools:context-gather` - Provides context package
|
||||
- `/workflow:tools:concept-enhanced` - Provides analysis results
|
||||
- `/workflow:execute` - Executes generated tasks
|
||||
|
||||
## Key Differences from task-generate
|
||||
|
||||
| Feature | task-generate | task-generate-agent |
|
||||
|---------|--------------|-------------------|
|
||||
| Execution | Manual/scripted | Agent-driven |
|
||||
| Phases | 6 phases | 2 phases (discovery + output) |
|
||||
| MCP Integration | Optional | Enhanced with examples |
|
||||
| Decision Logic | Command-driven | Agent-autonomous |
|
||||
| Complexity | Higher control | Simpler delegation |
|
||||
314
.claude/commands/workflow/tools/task-generate.md
Normal file
314
.claude/commands/workflow/tools/task-generate.md
Normal file
@@ -0,0 +1,314 @@
|
||||
---
|
||||
name: task-generate
|
||||
description: Generate task JSON files and IMPL_PLAN.md from analysis results with artifacts integration
|
||||
usage: /workflow:tools:task-generate --session <session_id>
|
||||
argument-hint: "--session WFS-session-id"
|
||||
examples:
|
||||
- /workflow:tools:task-generate --session WFS-auth
|
||||
---
|
||||
|
||||
# Task Generation Command
|
||||
|
||||
## Overview
|
||||
Generate task JSON files and IMPL_PLAN.md from analysis results with automatic artifact detection and integration.
|
||||
|
||||
## Core Philosophy
|
||||
- **Analysis-Driven**: Generate from ANALYSIS_RESULTS.md
|
||||
- **Artifact-Aware**: Auto-detect brainstorming outputs
|
||||
- **Context-Rich**: Embed comprehensive context in task JSON
|
||||
- **Flow-Control Ready**: Pre-define implementation steps
|
||||
- **Memory-First**: Reuse loaded documents from memory
|
||||
|
||||
## Core Responsibilities
|
||||
- Parse analysis results and extract tasks
|
||||
- Detect and integrate brainstorming artifacts
|
||||
- Generate enhanced task JSON files (5-field schema)
|
||||
- Create IMPL_PLAN.md and TODO_LIST.md
|
||||
- Update session state for execution
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Phase 1: Input Validation & Discovery
|
||||
**⚡ Memory-First Rule**: Skip file loading if documents already in conversation memory
|
||||
|
||||
1. **Session Validation**
|
||||
- If session metadata in memory → Skip loading
|
||||
- Else: Load `.workflow/{session_id}/workflow-session.json`
|
||||
|
||||
2. **Analysis Results Loading**
|
||||
- If ANALYSIS_RESULTS.md in memory → Skip loading
|
||||
- Else: Read `.workflow/{session_id}/.process/ANALYSIS_RESULTS.md`
|
||||
|
||||
3. **Artifact Discovery**
|
||||
- If artifact inventory in memory → Skip scanning
|
||||
- Else: Scan `.workflow/{session_id}/.brainstorming/` directory
|
||||
- Detect: synthesis-specification.md, topic-framework.md, role analyses
|
||||
|
||||
### Phase 2: Task JSON Generation
|
||||
|
||||
#### Task Decomposition Standards
|
||||
**Core Principle: Task Merging Over Decomposition**
|
||||
- **Merge Rule**: Execute together when possible
|
||||
- **Decompose Only When**:
|
||||
- Excessive workload (>2500 lines or >6 files)
|
||||
- Different tech stacks or domains
|
||||
- Sequential dependency blocking
|
||||
- Parallel execution needed
|
||||
|
||||
**Task Limits**:
|
||||
- **Maximum 10 tasks** (hard limit)
|
||||
- **Function-based**: Complete units (logic + UI + tests + config)
|
||||
- **Hierarchy**: Flat (≤5) | Two-level (6-10) | Re-scope (>10)
|
||||
|
||||
#### Enhanced Task JSON Schema (5-Field + Artifacts)
|
||||
```json
|
||||
{
|
||||
"id": "IMPL-N[.M]",
|
||||
"title": "Descriptive task name",
|
||||
"status": "pending|active|completed|blocked|container",
|
||||
"meta": {
|
||||
"type": "feature|bugfix|refactor|test|docs",
|
||||
"agent": "@code-developer|@planning-agent|@code-review-test-agent"
|
||||
},
|
||||
"context": {
|
||||
"requirements": ["Clear requirement from analysis"],
|
||||
"focus_paths": ["src/module/path", "tests/module/path"],
|
||||
"acceptance": ["Measurable acceptance criterion"],
|
||||
"parent": "IMPL-N",
|
||||
"depends_on": ["IMPL-N.M"],
|
||||
"inherited": {"shared_patterns": [], "common_dependencies": []},
|
||||
"shared_context": {"tech_stack": [], "conventions": []},
|
||||
"artifacts": [
|
||||
{
|
||||
"type": "synthesis_specification",
|
||||
"source": "brainstorm_synthesis",
|
||||
"path": ".workflow/WFS-[session]/.brainstorming/synthesis-specification.md",
|
||||
"priority": "highest",
|
||||
"contains": "complete_integrated_specification"
|
||||
},
|
||||
{
|
||||
"type": "topic_framework",
|
||||
"source": "brainstorm_framework",
|
||||
"path": ".workflow/WFS-[session]/.brainstorming/topic-framework.md",
|
||||
"priority": "medium",
|
||||
"contains": "discussion_framework_structure"
|
||||
},
|
||||
{
|
||||
"type": "individual_role_analysis",
|
||||
"source": "brainstorm_roles",
|
||||
"path": ".workflow/WFS-[session]/.brainstorming/[role]/analysis.md",
|
||||
"priority": "low",
|
||||
"contains": "role_specific_analysis_fallback"
|
||||
}
|
||||
]
|
||||
},
|
||||
"flow_control": {
|
||||
"pre_analysis": [
|
||||
{
|
||||
"step": "load_synthesis_specification",
|
||||
"action": "Load consolidated synthesis specification",
|
||||
"commands": [
|
||||
"bash(ls .workflow/WFS-[session]/.brainstorming/synthesis-specification.md 2>/dev/null || echo 'not found')",
|
||||
"Read(.workflow/WFS-[session]/.brainstorming/synthesis-specification.md)"
|
||||
],
|
||||
"output_to": "synthesis_specification",
|
||||
"on_error": "skip_optional"
|
||||
},
|
||||
{
|
||||
"step": "load_individual_role_artifacts",
|
||||
"action": "Load individual role analyses as fallback",
|
||||
"commands": [
|
||||
"bash(find .workflow/WFS-[session]/.brainstorming/ -name 'analysis.md' 2>/dev/null | head -8)",
|
||||
"Read(.workflow/WFS-[session]/.brainstorming/ui-designer/analysis.md)",
|
||||
"Read(.workflow/WFS-[session]/.brainstorming/system-architect/analysis.md)"
|
||||
],
|
||||
"output_to": "individual_artifacts",
|
||||
"on_error": "skip_optional"
|
||||
},
|
||||
{
|
||||
"step": "load_planning_context",
|
||||
"action": "Load plan-generated analysis",
|
||||
"commands": [
|
||||
"Read(.workflow/WFS-[session]/.process/ANALYSIS_RESULTS.md)",
|
||||
"Read(.workflow/WFS-[session]/.process/context-package.json)"
|
||||
],
|
||||
"output_to": "planning_context"
|
||||
},
|
||||
{
|
||||
"step": "mcp_codebase_exploration",
|
||||
"action": "Explore codebase using MCP tools",
|
||||
"command": "mcp__code-index__find_files(pattern=\"[patterns]\") && mcp__code-index__search_code_advanced(pattern=\"[patterns]\")",
|
||||
"output_to": "codebase_structure"
|
||||
},
|
||||
{
|
||||
"step": "analyze_task_patterns",
|
||||
"action": "Analyze existing code patterns",
|
||||
"commands": [
|
||||
"bash(cd \"[focus_paths]\")",
|
||||
"bash(~/.claude/scripts/gemini-wrapper -p \"PURPOSE: Analyze patterns TASK: Review '[title]' CONTEXT: [synthesis_specification] [individual_artifacts] EXPECTED: Pattern analysis RULES: Prioritize synthesis-specification.md\")"
|
||||
],
|
||||
"output_to": "task_context",
|
||||
"on_error": "fail"
|
||||
}
|
||||
],
|
||||
"implementation_approach": {
|
||||
"task_description": "Implement '[title]' following synthesis specification",
|
||||
"modification_points": [
|
||||
"Apply consolidated requirements from synthesis-specification.md",
|
||||
"Follow technical guidelines from synthesis",
|
||||
"Integrate with existing patterns"
|
||||
],
|
||||
"logic_flow": [
|
||||
"Load synthesis specification",
|
||||
"Extract requirements and design",
|
||||
"Analyze existing patterns",
|
||||
"Implement following specification",
|
||||
"Validate against acceptance criteria"
|
||||
]
|
||||
},
|
||||
"target_files": ["file:function:lines"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Task Generation Process
|
||||
1. Parse analysis results and extract task definitions
|
||||
2. Detect brainstorming artifacts with priority scoring
|
||||
3. Generate task context (requirements, focus_paths, acceptance)
|
||||
4. Build flow_control with artifact loading steps
|
||||
5. Create individual task JSON files in `.task/`
|
||||
|
||||
### Phase 3: Artifact Detection & Integration
|
||||
|
||||
#### Artifact Priority
|
||||
1. **synthesis-specification.md** (highest) - Complete integrated spec
|
||||
2. **topic-framework.md** (medium) - Discussion framework
|
||||
3. **role/analysis.md** (low) - Individual perspectives
|
||||
|
||||
#### Artifact-Task Mapping
|
||||
- **synthesis-specification.md** → All tasks
|
||||
- **ui-designer/analysis.md** → UI/Frontend tasks
|
||||
- **system-architect/analysis.md** → Architecture/Backend tasks
|
||||
- **security-expert/analysis.md** → Security tasks
|
||||
- **data-architect/analysis.md** → Data/API tasks
|
||||
|
||||
### Phase 4: IMPL_PLAN.md Generation
|
||||
|
||||
#### Document Structure
|
||||
```markdown
|
||||
---
|
||||
identifier: WFS-{session-id}
|
||||
source: "User requirements" | "File: path" | "Issue: ISS-001"
|
||||
analysis: .workflow/{session-id}/.process/ANALYSIS_RESULTS.md
|
||||
---
|
||||
|
||||
# Implementation Plan: {Project Title}
|
||||
|
||||
## Summary
|
||||
Core requirements, objectives, and technical approach.
|
||||
|
||||
## Context Analysis
|
||||
- **Project**: Type, patterns, tech stack
|
||||
- **Modules**: Components and integration points
|
||||
- **Dependencies**: External libraries and constraints
|
||||
- **Patterns**: Code conventions and guidelines
|
||||
|
||||
## Brainstorming Artifacts
|
||||
- synthesis-specification.md (Highest priority)
|
||||
- topic-framework.md (Medium priority)
|
||||
- Role analyses: ui-designer, system-architect, etc.
|
||||
|
||||
## Task Breakdown
|
||||
- **Task Count**: N tasks, complexity level
|
||||
- **Hierarchy**: Flat/Two-level structure
|
||||
- **Dependencies**: Task dependency graph
|
||||
|
||||
## Implementation Plan
|
||||
- **Execution Strategy**: Sequential/Parallel approach
|
||||
- **Resource Requirements**: Tools, dependencies, artifacts
|
||||
- **Success Criteria**: Metrics and acceptance conditions
|
||||
```
|
||||
|
||||
### Phase 5: TODO_LIST.md Generation
|
||||
|
||||
#### Document Structure
|
||||
```markdown
|
||||
# Tasks: [Session Topic]
|
||||
|
||||
## Task Progress
|
||||
▸ **IMPL-001**: [Main Task Group] → [📋](./.task/IMPL-001.json)
|
||||
- [ ] **IMPL-001.1**: [Subtask] → [📋](./.task/IMPL-001.1.json)
|
||||
- [x] **IMPL-001.2**: [Subtask] → [📋](./.task/IMPL-001.2.json) | [✅](./.summaries/IMPL-001.2-summary.md)
|
||||
|
||||
- [x] **IMPL-002**: [Simple Task] → [📋](./.task/IMPL-002.json) | [✅](./.summaries/IMPL-002-summary.md)
|
||||
|
||||
## Status Legend
|
||||
- `▸` = Container task (has subtasks)
|
||||
- `- [ ]` = Pending leaf task
|
||||
- `- [x]` = Completed leaf task
|
||||
- Maximum 2 levels: Main tasks and subtasks only
|
||||
```
|
||||
|
||||
### Phase 6: Session State Update
|
||||
1. Update workflow-session.json with task count and artifacts
|
||||
2. Validate all output files (task JSONs, IMPL_PLAN.md, TODO_LIST.md)
|
||||
3. Generate completion report
|
||||
|
||||
## Output Files Structure
|
||||
```
|
||||
.workflow/{session-id}/
|
||||
├── IMPL_PLAN.md # Implementation plan
|
||||
├── TODO_LIST.md # Progress tracking
|
||||
├── .task/
|
||||
│ ├── IMPL-1.json # Container task
|
||||
│ ├── IMPL-1.1.json # Leaf task with flow_control
|
||||
│ └── IMPL-1.2.json # Leaf task with flow_control
|
||||
├── .brainstorming/ # Input artifacts
|
||||
│ ├── synthesis-specification.md
|
||||
│ ├── topic-framework.md
|
||||
│ └── {role}/analysis.md
|
||||
└── .process/
|
||||
├── ANALYSIS_RESULTS.md # Input from concept-enhanced
|
||||
└── context-package.json # Input from context-gather
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
### Input Validation Errors
|
||||
| Error | Cause | Resolution |
|
||||
|-------|-------|------------|
|
||||
| Session not found | Invalid session ID | Verify session exists |
|
||||
| Analysis missing | Incomplete planning | Run concept-enhanced first |
|
||||
| Invalid format | Corrupted results | Regenerate analysis |
|
||||
|
||||
### Task Generation Errors
|
||||
| Error | Cause | Resolution |
|
||||
|-------|-------|------------|
|
||||
| Count exceeds limit | >10 tasks | Re-scope requirements |
|
||||
| Invalid structure | Missing fields | Fix analysis results |
|
||||
| Dependency cycle | Circular refs | Adjust dependencies |
|
||||
|
||||
### Artifact Integration Errors
|
||||
| Error | Cause | Recovery |
|
||||
|-------|-------|----------|
|
||||
| Artifact not found | Missing output | Continue without artifacts |
|
||||
| Invalid format | Corrupted file | Skip artifact loading |
|
||||
| Path invalid | Moved/deleted | Update references |
|
||||
|
||||
## Integration & Usage
|
||||
|
||||
### Command Chain
|
||||
- **Called By**: `/workflow:plan` (Phase 4)
|
||||
- **Calls**: None (terminal command)
|
||||
- **Followed By**: `/workflow:execute`, `/workflow:status`
|
||||
|
||||
### Basic Usage
|
||||
```bash
|
||||
/workflow:tools:task-generate --session WFS-auth
|
||||
```
|
||||
|
||||
## Related Commands
|
||||
- `/workflow:plan` - Orchestrates entire planning
|
||||
- `/workflow:tools:context-gather` - Provides context package
|
||||
- `/workflow:tools:concept-enhanced` - Provides analysis results
|
||||
- `/workflow:execute` - Executes generated tasks
|
||||
Reference in New Issue
Block a user