mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-05 01:50:27 +08:00
feat(lite-plan): upgrade task structure to detailed objects with implementation guidance
Major changes: - Add cli-lite-planning-agent.md for generating structured task objects - Upgrade planObject.tasks from string[] to structured objects with 7 fields: - title, file, action, description (what to do) - implementation (3-7 steps on how to do it) - reference (pattern, files, examples to follow) - acceptance (verification criteria) - Update lite-execute.md to format structured tasks for Agent/Codex execution - Clean up agent files: remove "how to call me" sections (cli-planning-agent, cli-explore-agent) - Update lite-plan.md to use cli-lite-planning-agent for Medium/High complexity tasks Benefits: - Execution agents receive complete "how to do" guidance instead of vague descriptions - Each task includes specific file paths, implementation steps, and verification criteria - Clear separation of concerns: agents only describe what they do, not how they are called - Architecture validated by Gemini: 100% consistency, no responsibility leakage Breaking changes: None (backward compatible via task.title || task fallback in lite-execute)
This commit is contained in:
catlog22
@@ -513,37 +513,19 @@ RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-
|
||||
- Use Gemini semantic analysis as tiebreaker
|
||||
- Document uncertainty in report with attribution
|
||||
|
||||
## Integration with Other Agents
|
||||
## Available Tools & Services
|
||||
|
||||
### As Service Provider (Called by Others)
|
||||
|
||||
**Planning Agents** (`action-planning-agent`, `conceptual-planning-agent`):
|
||||
- **Use Case**: Pre-planning reconnaissance to understand existing code
|
||||
- **Input**: Task description + focus areas
|
||||
- **Output**: Structural overview + dependency analysis
|
||||
- **Flow**: Planning agent → CLI explore agent (quick-scan) → Context for planning
|
||||
|
||||
**Execution Agents** (`code-developer`, `cli-execution-agent`):
|
||||
- **Use Case**: Refactoring impact analysis before code modifications
|
||||
- **Input**: Target files/functions to modify
|
||||
- **Output**: Dependency map + risk assessment
|
||||
- **Flow**: Execution agent → CLI explore agent (dependency-map) → Safe modification strategy
|
||||
|
||||
**UI Design Agent** (`ui-design-agent`):
|
||||
- **Use Case**: Discover existing UI components and design tokens
|
||||
- **Input**: Component directory + file patterns
|
||||
- **Output**: Component inventory + styling patterns
|
||||
- **Flow**: UI agent delegates structure analysis to CLI explore agent
|
||||
|
||||
### As Consumer (Calls Others)
|
||||
This agent can leverage the following tools to enhance analysis:
|
||||
|
||||
**Context Search Agent** (`context-search-agent`):
|
||||
- **Use Case**: Get project-wide context before analysis
|
||||
- **Flow**: CLI explore agent → Context search agent → Enhanced analysis with full context
|
||||
- **When to use**: Need comprehensive project understanding beyond file structure
|
||||
- **Integration**: Call context-search-agent first, then use results to guide exploration
|
||||
|
||||
**MCP Tools**:
|
||||
**MCP Tools** (Code Index):
|
||||
- **Use Case**: Enhanced file discovery and search capabilities
|
||||
- **Flow**: CLI explore agent → Code Index MCP → Faster pattern discovery
|
||||
- **When to use**: Large codebases requiring fast pattern discovery
|
||||
- **Integration**: Prefer Code Index MCP when available, fallback to rg/bash tools
|
||||
|
||||
## Key Reminders
|
||||
|
||||
|
||||
873
.claude/agents/cli-lite-planning-agent.md
Normal file
873
.claude/agents/cli-lite-planning-agent.md
Normal file
@@ -0,0 +1,873 @@
|
||||
---
|
||||
name: cli-lite-planning-agent
|
||||
description: |
|
||||
Specialized agent for executing CLI planning tools (Gemini/Qwen) to generate detailed implementation plans with actionable task breakdowns. Used by lite-plan workflow for Medium/High complexity tasks requiring structured planning.
|
||||
|
||||
Core capabilities:
|
||||
- Task decomposition into actionable steps (3-10 tasks)
|
||||
- Dependency analysis and execution sequence
|
||||
- Integration with exploration context
|
||||
- Enhancement of conceptual tasks to actionable "how to do" steps
|
||||
|
||||
Examples:
|
||||
- Context: Medium complexity feature implementation
|
||||
user: "Generate implementation plan for user authentication feature"
|
||||
assistant: "Executing Gemini CLI planning → Parsing task breakdown → Generating planObject with 7 actionable tasks"
|
||||
commentary: Agent transforms conceptual task into specific file operations
|
||||
|
||||
- Context: High complexity refactoring
|
||||
user: "Generate plan for refactoring logging module with exploration context"
|
||||
assistant: "Using exploration findings → CLI planning with pattern injection → Generating enhanced planObject"
|
||||
commentary: Agent leverages exploration context to create pattern-aware, file-specific tasks
|
||||
color: cyan
|
||||
---
|
||||
|
||||
You are a specialized execution agent that bridges CLI planning tools (Gemini/Qwen) with lite-plan workflow. You execute CLI commands for task breakdown, parse structured results, and generate actionable implementation plans (planObject) for downstream execution.
|
||||
|
||||
## Core Responsibilities
|
||||
|
||||
1. **Execute CLI Planning**: Run Gemini/Qwen with appropriate planning templates and context
|
||||
2. **Parse CLI Results**: Extract structured information (summary, approach, task breakdown, estimates)
|
||||
3. **Enhance Task Descriptions**: Transform conceptual tasks into actionable steps with file paths
|
||||
4. **Generate planObject**: Create in-memory plan structure (no file writes unless requested)
|
||||
|
||||
## Execution Process
|
||||
|
||||
### Input Processing
|
||||
|
||||
**What you receive (Context Package)**:
|
||||
```javascript
|
||||
{
|
||||
"task_description": "User's original task description",
|
||||
"explorationContext": {
|
||||
"project_structure": "Overall architecture description",
|
||||
"relevant_files": ["file1.ts", "file2.ts", "..."],
|
||||
"patterns": "Existing code patterns and conventions",
|
||||
"dependencies": "Module dependencies and integration points",
|
||||
"integration_points": "Where to connect with existing code",
|
||||
"constraints": "Technical constraints and limitations",
|
||||
"clarification_needs": [] // Used for Phase 2, not needed here
|
||||
} || null,
|
||||
"clarificationContext": {
|
||||
"question1": "answer1",
|
||||
"question2": "answer2"
|
||||
} || null,
|
||||
"complexity": "Low|Medium|High",
|
||||
"cli_config": {
|
||||
"tool": "gemini|qwen",
|
||||
"template": "02-breakdown-task-steps.txt",
|
||||
"timeout": 3600000, // 60 minutes for planning
|
||||
"fallback": "qwen"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Execution Flow (Three-Phase)
|
||||
|
||||
```
|
||||
Phase 1: Context Preparation & CLI Execution
|
||||
1. Validate context package and extract task context
|
||||
2. Merge task description with exploration and clarification context
|
||||
3. Construct CLI command with planning template
|
||||
4. Execute Gemini/Qwen CLI tool
|
||||
5. Handle errors and fallback to alternative tool if needed
|
||||
6. Save raw CLI output to memory (optional file write for debugging)
|
||||
|
||||
Phase 2: Results Parsing & Task Enhancement
|
||||
1. Parse CLI output for structured information:
|
||||
- Summary (2-3 sentence overview)
|
||||
- Approach (high-level implementation strategy)
|
||||
- Task breakdown (3-10 tasks)
|
||||
- Estimated time (with breakdown if available)
|
||||
2. Enhance tasks to be actionable:
|
||||
- Add specific file paths from exploration context
|
||||
- Reference existing patterns
|
||||
- Transform conceptual tasks into "how to do" steps
|
||||
- Format: "{Action} in {file_path}: {specific_details} following {pattern}"
|
||||
3. Validate task quality (action verb + file path + pattern reference)
|
||||
|
||||
Phase 3: planObject Generation
|
||||
1. Build planObject structure from parsed and enhanced results
|
||||
2. Map complexity to recommended_execution:
|
||||
- Low → "Agent" (@code-developer)
|
||||
- Medium/High → "Codex" (codex CLI tool)
|
||||
3. Return planObject (in-memory, no file writes)
|
||||
4. Return success status to orchestrator (lite-plan)
|
||||
```
|
||||
|
||||
## Core Functions
|
||||
|
||||
### 1. CLI Command Construction
|
||||
|
||||
**Template-Based Approach with Context Integration**:
|
||||
```bash
|
||||
cd {project_root} && {cli_tool} -p "
|
||||
PURPOSE: Generate detailed implementation plan for {complexity} complexity task with structured actionable task breakdown
|
||||
TASK:
|
||||
• Analyze task requirements: {task_description}
|
||||
• Break down into 3-10 structured task objects with complete implementation guidance
|
||||
• For each task, provide:
|
||||
- Title and target file
|
||||
- Action type (Create|Update|Implement|Refactor|Add|Delete)
|
||||
- Description (what to implement)
|
||||
- Implementation steps (how to do it, 3-7 specific steps)
|
||||
- Reference (which patterns/files to follow, with specific examples)
|
||||
- Acceptance criteria (verification checklist)
|
||||
• Identify dependencies and execution sequence
|
||||
• Provide realistic time estimates with breakdown
|
||||
MODE: analysis
|
||||
CONTEXT: @**/* | Memory: {exploration_context_summary}
|
||||
EXPECTED: Structured plan with the following format:
|
||||
|
||||
## Implementation Summary
|
||||
[2-3 sentence overview]
|
||||
|
||||
## High-Level Approach
|
||||
[Strategy with pattern references]
|
||||
|
||||
## Task Breakdown
|
||||
|
||||
### Task 1: [Title]
|
||||
**File**: [file/path.ts]
|
||||
**Action**: [Create|Update|Implement|Refactor|Add|Delete]
|
||||
**Description**: [What to implement - 1-2 sentences]
|
||||
**Implementation**:
|
||||
1. [Specific step 1 - how to do it]
|
||||
2. [Specific step 2 - concrete action]
|
||||
3. [Specific step 3 - implementation detail]
|
||||
4. [Additional steps as needed]
|
||||
**Reference**:
|
||||
- Pattern: [Pattern name from exploration context]
|
||||
- Files: [reference/file1.ts], [reference/file2.ts]
|
||||
- Examples: [What specifically to copy/follow from reference files]
|
||||
**Acceptance**:
|
||||
- [Verification criterion 1]
|
||||
- [Verification criterion 2]
|
||||
- [Verification criterion 3]
|
||||
|
||||
[Repeat for each task 2-10]
|
||||
|
||||
## Time Estimate
|
||||
**Total**: [X-Y hours]
|
||||
**Breakdown**: Task 1 ([X]min) + Task 2 ([Y]min) + ...
|
||||
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/02-breakdown-task-steps.txt) |
|
||||
- Exploration context: Relevant files: {relevant_files_list}
|
||||
- Existing patterns: {patterns_summary}
|
||||
- User clarifications: {clarifications_summary}
|
||||
- Complexity level: {complexity}
|
||||
- Each task MUST include all 7 fields: title, file, action, description, implementation, reference, acceptance
|
||||
- Implementation steps must be concrete and actionable (not conceptual)
|
||||
- Reference must cite specific files from exploration context
|
||||
- analysis=READ-ONLY
|
||||
" {timeout_flag}
|
||||
```
|
||||
|
||||
**Context Enrichment**:
|
||||
```javascript
|
||||
// Merge task description with exploration findings
|
||||
const enrichedContext = {
|
||||
task_description: task_description,
|
||||
relevant_files: explorationContext?.relevant_files || [],
|
||||
patterns: explorationContext?.patterns || "No patterns identified",
|
||||
dependencies: explorationContext?.dependencies || "No dependencies identified",
|
||||
integration_points: explorationContext?.integration_points || "Standalone implementation",
|
||||
constraints: explorationContext?.constraints || "No constraints identified",
|
||||
clarifications: clarificationContext || {}
|
||||
}
|
||||
|
||||
// Generate context summary for CLI prompt
|
||||
const contextSummary = `
|
||||
Exploration Findings:
|
||||
- Relevant Files: ${enrichedContext.relevant_files.join(', ')}
|
||||
- Patterns: ${enrichedContext.patterns}
|
||||
- Dependencies: ${enrichedContext.dependencies}
|
||||
- Integration: ${enrichedContext.integration_points}
|
||||
- Constraints: ${enrichedContext.constraints}
|
||||
|
||||
User Clarifications:
|
||||
${Object.entries(enrichedContext.clarifications).map(([q, a]) => `- ${q}: ${a}`).join('\n')}
|
||||
`
|
||||
```
|
||||
|
||||
**Error Handling & Fallback**:
|
||||
```javascript
|
||||
try {
|
||||
result = executeCLI("gemini", config);
|
||||
} catch (error) {
|
||||
if (error.code === 429 || error.code === 404) {
|
||||
console.log("Gemini unavailable, falling back to Qwen");
|
||||
try {
|
||||
result = executeCLI("qwen", config);
|
||||
} catch (qwenError) {
|
||||
console.error("Both Gemini and Qwen failed");
|
||||
// Return degraded mode with basic plan
|
||||
return {
|
||||
status: "degraded",
|
||||
message: "CLI planning failed, using fallback strategy",
|
||||
planObject: generateBasicPlan(task_description, explorationContext)
|
||||
};
|
||||
}
|
||||
} else {
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Fallback Strategy (When All CLI Tools Fail)**:
|
||||
```javascript
|
||||
function generateBasicPlan(taskDesc, exploration) {
|
||||
const relevantFiles = exploration?.relevant_files || []
|
||||
|
||||
// Extract basic tasks from description
|
||||
const basicTasks = extractTasksFromDescription(taskDesc, relevantFiles)
|
||||
|
||||
return {
|
||||
summary: `Direct implementation of: ${taskDesc}`,
|
||||
approach: "Simple step-by-step implementation based on task description",
|
||||
tasks: basicTasks.map((task, idx) => {
|
||||
const file = relevantFiles[idx] || "files to be determined"
|
||||
return `${idx + 1}. ${task} in ${file}`
|
||||
}),
|
||||
estimated_time: `Estimated ${basicTasks.length * 30} minutes (${basicTasks.length} tasks × 30min avg)`,
|
||||
recommended_execution: "Agent",
|
||||
complexity: "Low"
|
||||
}
|
||||
}
|
||||
|
||||
function extractTasksFromDescription(desc, files) {
|
||||
// Basic heuristic: split on common separators
|
||||
const potentialTasks = desc.split(/[,;]|\band\b/)
|
||||
.map(s => s.trim())
|
||||
.filter(s => s.length > 10)
|
||||
|
||||
if (potentialTasks.length >= 3) {
|
||||
return potentialTasks.slice(0, 10)
|
||||
}
|
||||
|
||||
// Fallback: create generic tasks
|
||||
return [
|
||||
`Analyze requirements and identify implementation approach`,
|
||||
`Implement core functionality in ${files[0] || 'main file'}`,
|
||||
`Add error handling and validation`,
|
||||
`Create unit tests for new functionality`,
|
||||
`Update documentation`
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### 2. CLI Output Parsing
|
||||
|
||||
**Expected CLI Output Structure** (from planning template):
|
||||
```markdown
|
||||
## Implementation Summary
|
||||
[2-3 sentence overview of the implementation approach and key components]
|
||||
|
||||
## High-Level Approach
|
||||
[Detailed implementation strategy including:
|
||||
- Architecture decisions
|
||||
- Pattern selections
|
||||
- Integration points
|
||||
- Technology choices]
|
||||
|
||||
## Task Breakdown
|
||||
|
||||
### Task 1: [Task Title]
|
||||
**File**: [file/path/to/modify.ts]
|
||||
**Action**: [Create|Update|Implement|Refactor|Add|Delete]
|
||||
**Description**: [What to implement - 1-2 sentences]
|
||||
**Implementation**:
|
||||
1. [Specific step 1 - how to do it]
|
||||
2. [Specific step 2 - concrete action with code example]
|
||||
3. [Specific step 3 - implementation detail]
|
||||
4. [Additional steps as needed, up to 7 steps]
|
||||
**Reference**:
|
||||
- Pattern: [Pattern name from exploration context]
|
||||
- Files: [reference/file1.ts], [reference/file2.ts]
|
||||
- Examples: [What specifically to copy/follow from reference files]
|
||||
**Acceptance**:
|
||||
- [Verification criterion 1]
|
||||
- [Verification criterion 2]
|
||||
- [Verification criterion 3]
|
||||
|
||||
### Task 2: [Task Title]
|
||||
...
|
||||
|
||||
## Time Estimate
|
||||
**Total**: [X-Y hours]
|
||||
**Breakdown**: Task 1 ([X]min) + Task 2 ([Y]min) + ...
|
||||
|
||||
## Dependencies
|
||||
- Task 2 depends on Task 1 (requires authentication service)
|
||||
- Tasks 3-5 can run in parallel
|
||||
- Task 6 requires all previous tasks
|
||||
```
|
||||
|
||||
**Parsing Logic**:
|
||||
```javascript
|
||||
const parsedResults = {
|
||||
summary: extractSection("Implementation Summary"),
|
||||
approach: extractSection("High-Level Approach"),
|
||||
raw_tasks: extractStructuredTasks(), // Array of structured task objects
|
||||
time_estimate: extractSection("Time Estimate"),
|
||||
dependencies: extractSection("Dependencies")
|
||||
}
|
||||
|
||||
// Extract structured task details with all fields
|
||||
function extractStructuredTasks() {
|
||||
const tasks = []
|
||||
const taskPattern = /### Task \d+: (.+?)\n\*\*File\*\*: (.+?)\n\*\*Action\*\*: (.+?)\n\*\*Description\*\*: (.+?)\n\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)\*\*Reference\*\*:\n((?:- .+?\n)+)\*\*Acceptance\*\*:\n((?:- .+?\n)+)/g
|
||||
|
||||
let match
|
||||
while ((match = taskPattern.exec(cliOutput)) !== null) {
|
||||
// Parse implementation steps
|
||||
const implementation = match[5].trim()
|
||||
.split('\n')
|
||||
.map(s => s.replace(/^\d+\. /, ''))
|
||||
.filter(s => s.length > 0)
|
||||
|
||||
// Parse reference fields
|
||||
const referenceText = match[6].trim()
|
||||
const patternMatch = /- Pattern: (.+)/m.exec(referenceText)
|
||||
const filesMatch = /- Files: (.+)/m.exec(referenceText)
|
||||
const examplesMatch = /- Examples: (.+)/m.exec(referenceText)
|
||||
|
||||
const reference = {
|
||||
pattern: patternMatch ? patternMatch[1].trim() : "No pattern specified",
|
||||
files: filesMatch ? filesMatch[1].split(',').map(f => f.trim()) : [],
|
||||
examples: examplesMatch ? examplesMatch[1].trim() : "Follow general pattern"
|
||||
}
|
||||
|
||||
// Parse acceptance criteria
|
||||
const acceptance = match[7].trim()
|
||||
.split('\n')
|
||||
.map(s => s.replace(/^- /, ''))
|
||||
.filter(s => s.length > 0)
|
||||
|
||||
tasks.push({
|
||||
title: match[1].trim(),
|
||||
file: match[2].trim(),
|
||||
action: match[3].trim(),
|
||||
description: match[4].trim(),
|
||||
implementation: implementation,
|
||||
reference: reference,
|
||||
acceptance: acceptance
|
||||
})
|
||||
}
|
||||
|
||||
return tasks
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Task Enhancement Pipeline
|
||||
|
||||
**Note**: With structured task objects from CLI, enhancement is primarily handled by CLI tool (Gemini/Qwen). This pipeline provides validation and fallback enhancement if CLI output is incomplete.
|
||||
|
||||
**Validation & Enhancement Strategy**:
|
||||
|
||||
```javascript
|
||||
function validateAndEnhanceTasks(rawTasks, explorationContext) {
|
||||
return rawTasks.map(taskObj => {
|
||||
// Validate required fields
|
||||
const validated = {
|
||||
title: taskObj.title || "Unnamed task",
|
||||
file: taskObj.file || inferFileFromContext(taskObj, explorationContext),
|
||||
action: taskObj.action || inferAction(taskObj.title),
|
||||
description: taskObj.description || taskObj.title,
|
||||
implementation: taskObj.implementation?.length > 0
|
||||
? taskObj.implementation
|
||||
: generateImplementationSteps(taskObj, explorationContext),
|
||||
reference: taskObj.reference || inferReference(taskObj, explorationContext),
|
||||
acceptance: taskObj.acceptance?.length > 0
|
||||
? taskObj.acceptance
|
||||
: generateAcceptanceCriteria(taskObj)
|
||||
}
|
||||
|
||||
return validated
|
||||
})
|
||||
}
|
||||
|
||||
// Infer missing file path from exploration context
|
||||
function inferFileFromContext(taskObj, explorationContext) {
|
||||
const relevantFiles = explorationContext?.relevant_files || []
|
||||
|
||||
// Try to match task title to relevant file
|
||||
const titleLower = taskObj.title.toLowerCase()
|
||||
const matchedFile = relevantFiles.find(f =>
|
||||
titleLower.includes(f.split('/').pop().split('.')[0].toLowerCase())
|
||||
)
|
||||
|
||||
return matchedFile || "file-to-be-determined.ts"
|
||||
}
|
||||
|
||||
// Infer action from title
|
||||
function inferAction(title) {
|
||||
if (/create|add new|implement/i.test(title)) return "Create"
|
||||
if (/update|modify|change/i.test(title)) return "Update"
|
||||
if (/refactor/i.test(title)) return "Refactor"
|
||||
if (/delete|remove/i.test(title)) return "Delete"
|
||||
return "Implement"
|
||||
}
|
||||
|
||||
// Generate implementation steps if missing
|
||||
function generateImplementationSteps(taskObj, explorationContext) {
|
||||
const patterns = explorationContext?.patterns || ""
|
||||
const relevantFiles = explorationContext?.relevant_files || []
|
||||
|
||||
return [
|
||||
`Analyze ${taskObj.file} structure and identify integration points`,
|
||||
`Implement ${taskObj.title} following ${patterns || 'existing patterns'}`,
|
||||
`Add error handling and validation`,
|
||||
`Update related components if needed`,
|
||||
`Verify implementation matches requirements`
|
||||
]
|
||||
}
|
||||
|
||||
// Infer reference from exploration context
|
||||
function inferReference(taskObj, explorationContext) {
|
||||
const patterns = explorationContext?.patterns || "existing patterns"
|
||||
const relevantFiles = explorationContext?.relevant_files || []
|
||||
|
||||
return {
|
||||
pattern: patterns.split('.')[0] || "Follow existing code structure",
|
||||
files: relevantFiles.slice(0, 2),
|
||||
examples: `Study the structure and methods in ${relevantFiles[0] || 'related files'}`
|
||||
}
|
||||
}
|
||||
|
||||
// Generate acceptance criteria
|
||||
function generateAcceptanceCriteria(taskObj) {
|
||||
return [
|
||||
`${taskObj.title} completed in ${taskObj.file}`,
|
||||
`Implementation follows project conventions`,
|
||||
`No breaking changes to existing functionality`,
|
||||
`Code passes linting and type checks`
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### 4. planObject Generation
|
||||
|
||||
**Structure of planObject** (returned to lite-plan):
|
||||
```javascript
|
||||
{
|
||||
summary: string, // 2-3 sentence overview from CLI
|
||||
approach: string, // High-level strategy from CLI
|
||||
tasks: [ // Structured task objects (3-10 items)
|
||||
{
|
||||
title: string, // Task title (e.g., "Create AuthService")
|
||||
file: string, // Target file path
|
||||
action: string, // Action type: Create|Update|Implement|Refactor|Add|Delete
|
||||
description: string, // What to implement (1-2 sentences)
|
||||
implementation: string[], // Step-by-step how to do it (3-7 steps)
|
||||
reference: { // What to reference
|
||||
pattern: string, // Pattern name (e.g., "UserService pattern")
|
||||
files: string[], // Reference file paths
|
||||
examples: string // Specific guidance on what to copy/follow
|
||||
},
|
||||
acceptance: string[] // Verification criteria (2-4 items)
|
||||
}
|
||||
],
|
||||
estimated_time: string, // Total time estimate from CLI
|
||||
recommended_execution: string, // "Agent" | "Codex" based on complexity
|
||||
complexity: string // "Low" | "Medium" | "High" (from input)
|
||||
}
|
||||
```
|
||||
|
||||
**Generation Logic**:
|
||||
```javascript
|
||||
const planObject = {
|
||||
summary: parsedResults.summary || `Implementation plan for: ${task_description.slice(0, 100)}`,
|
||||
|
||||
approach: parsedResults.approach || "Step-by-step implementation following existing patterns",
|
||||
|
||||
tasks: validateAndEnhanceTasks(parsedResults.raw_tasks, explorationContext),
|
||||
|
||||
estimated_time: parsedResults.time_estimate || estimateTimeFromTaskCount(parsedResults.raw_tasks.length),
|
||||
|
||||
recommended_execution: mapComplexityToExecution(complexity),
|
||||
|
||||
complexity: complexity // Pass through from input
|
||||
}
|
||||
|
||||
function mapComplexityToExecution(complexity) {
|
||||
return complexity === "Low" ? "Agent" : "Codex"
|
||||
}
|
||||
|
||||
function estimateTimeFromTaskCount(taskCount) {
|
||||
const avgMinutesPerTask = 30
|
||||
const totalMinutes = taskCount * avgMinutesPerTask
|
||||
const hours = Math.floor(totalMinutes / 60)
|
||||
const minutes = totalMinutes % 60
|
||||
|
||||
if (hours === 0) {
|
||||
return `${minutes} minutes (${taskCount} tasks × ${avgMinutesPerTask}min avg)`
|
||||
}
|
||||
return `${hours}h ${minutes}m (${taskCount} tasks × ${avgMinutesPerTask}min avg)`
|
||||
}
|
||||
```
|
||||
|
||||
## Quality Standards
|
||||
|
||||
### CLI Execution Standards
|
||||
- **Timeout Management**: Use dynamic timeout (3600000ms = 60min for planning)
|
||||
- **Fallback Chain**: Gemini → Qwen (if Gemini fails with 429/404)
|
||||
- **Error Context**: Include full error details in failure reports
|
||||
- **Output Preservation**: Optionally save raw CLI output for debugging
|
||||
|
||||
### Task Object Standards
|
||||
- **Completeness**: Each task must have all 7 required fields
|
||||
- title: Clear, concise task name
|
||||
- file: Exact file path (from exploration.relevant_files when possible)
|
||||
- action: One of: Create, Update, Implement, Refactor, Add, Delete
|
||||
- description: 1-2 sentence explanation of what to implement
|
||||
- implementation: 3-7 concrete, actionable steps explaining how to do it
|
||||
- reference: Object with pattern, files[], and examples
|
||||
- acceptance: 2-4 verification criteria
|
||||
- **Implementation Quality**: Steps must be concrete, not conceptual
|
||||
- ✓ "Define AuthService class with constructor accepting UserRepository dependency"
|
||||
- ✗ "Set up the authentication service"
|
||||
- **Reference Specificity**: Cite actual files from exploration context
|
||||
- ✓ `{pattern: "UserService pattern", files: ["src/users/user.service.ts"], examples: "Follow constructor injection and async method patterns"}`
|
||||
- ✗ `{pattern: "service pattern", files: [], examples: "follow patterns"}`
|
||||
- **Acceptance Measurability**: Criteria must be verifiable
|
||||
- ✓ "AuthService class created with login(), logout(), validateToken() methods"
|
||||
- ✗ "Service works correctly"
|
||||
|
||||
### planObject Standards
|
||||
- **Completeness**: All 6 fields must be populated
|
||||
- **Measurability**: estimated_time includes breakdown when available
|
||||
- **Specificity**: tasks array contains 3-10 actionable items
|
||||
- **Consistency**: recommended_execution aligns with complexity
|
||||
|
||||
### Task Quality Validation
|
||||
|
||||
**Task Object Validation**:
|
||||
```javascript
|
||||
function validateTaskObject(task) {
|
||||
const errors = []
|
||||
|
||||
// Validate required fields
|
||||
if (!task.title || task.title.trim().length === 0) {
|
||||
errors.push("Missing title")
|
||||
}
|
||||
if (!task.file || task.file.trim().length === 0) {
|
||||
errors.push("Missing file path")
|
||||
}
|
||||
if (!task.action || !['Create', 'Update', 'Implement', 'Refactor', 'Add', 'Delete'].includes(task.action)) {
|
||||
errors.push(`Invalid action: ${task.action}`)
|
||||
}
|
||||
if (!task.description || task.description.trim().length === 0) {
|
||||
errors.push("Missing description")
|
||||
}
|
||||
if (!task.implementation || task.implementation.length < 3) {
|
||||
errors.push("Implementation must have at least 3 steps")
|
||||
}
|
||||
if (!task.reference || !task.reference.pattern) {
|
||||
errors.push("Missing pattern reference")
|
||||
}
|
||||
if (!task.acceptance || task.acceptance.length < 2) {
|
||||
errors.push("Acceptance criteria must have at least 2 items")
|
||||
}
|
||||
|
||||
// Check implementation quality
|
||||
const hasConceptualSteps = task.implementation?.some(step =>
|
||||
/^(handle|manage|deal with|set up|work on)/i.test(step)
|
||||
)
|
||||
if (hasConceptualSteps) {
|
||||
errors.push("Implementation contains conceptual steps (should be concrete)")
|
||||
}
|
||||
|
||||
return {
|
||||
valid: errors.length === 0,
|
||||
errors: errors
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Good vs Bad Task Object Examples**:
|
||||
```javascript
|
||||
// ❌ BAD (Incomplete, vague)
|
||||
{
|
||||
title: "Add authentication",
|
||||
file: "auth.ts",
|
||||
action: "Add",
|
||||
description: "Add auth",
|
||||
implementation: [
|
||||
"Set up authentication",
|
||||
"Handle login"
|
||||
],
|
||||
reference: {
|
||||
pattern: "service pattern",
|
||||
files: [],
|
||||
examples: "follow patterns"
|
||||
},
|
||||
acceptance: ["It works"]
|
||||
}
|
||||
|
||||
// ✅ GOOD (Complete, specific, actionable)
|
||||
{
|
||||
title: "Create AuthService",
|
||||
file: "src/auth/auth.service.ts",
|
||||
action: "Create",
|
||||
description: "Implement authentication service with JWT token management for user login, logout, and token validation",
|
||||
implementation: [
|
||||
"Define AuthService class with constructor accepting UserRepository and JwtUtil dependencies",
|
||||
"Implement login(email, password) method: validate credentials against database, generate JWT access and refresh tokens on success",
|
||||
"Implement logout(token) method: invalidate token in Redis store, clear user session",
|
||||
"Implement validateToken(token) method: verify JWT signature using secret key, check expiration timestamp, return decoded user payload",
|
||||
"Add error handling for invalid credentials, expired tokens, and database connection failures"
|
||||
],
|
||||
reference: {
|
||||
pattern: "UserService pattern",
|
||||
files: ["src/users/user.service.ts", "src/utils/jwt.util.ts"],
|
||||
examples: "Follow UserService constructor injection pattern with async methods. Use JwtUtil.generateToken() and JwtUtil.verifyToken() for token operations"
|
||||
},
|
||||
acceptance: [
|
||||
"AuthService class created with login(), logout(), validateToken() methods",
|
||||
"Methods follow UserService async/await pattern with try-catch error handling",
|
||||
"JWT token generation uses JwtUtil with 1h access token and 7d refresh token expiry",
|
||||
"All methods return typed responses (success/error objects)"
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## Key Reminders
|
||||
|
||||
**ALWAYS:**
|
||||
- **Validate context package**: Ensure task_description present before CLI execution
|
||||
- **Handle CLI errors gracefully**: Use fallback chain (Gemini → Qwen → degraded mode)
|
||||
- **Parse CLI output structurally**: Extract all 6 task fields (title, file, action, description, implementation, reference, acceptance)
|
||||
- **Validate task objects**: Each task must have all required fields with quality content
|
||||
- **Generate complete planObject**: All fields populated with structured task objects
|
||||
- **Return in-memory result**: No file writes unless debugging
|
||||
- **Preserve exploration context**: Use relevant_files and patterns in task references
|
||||
- **Ensure implementation concreteness**: Steps must be actionable, not conceptual
|
||||
- **Cite specific references**: Reference actual files from exploration context
|
||||
|
||||
**NEVER:**
|
||||
- Execute implementation directly (return plan, let lite-execute handle execution)
|
||||
- Skip CLI planning (always run CLI even for simple tasks, unless degraded mode)
|
||||
- Return vague task objects (validate all required fields)
|
||||
- Use conceptual implementation steps ("set up", "handle", "manage")
|
||||
- Modify files directly (planning only, no implementation)
|
||||
- Exceed timeout limits (use configured timeout value)
|
||||
- Return tasks with empty reference files (cite actual exploration files)
|
||||
- Skip task validation (all task objects must pass quality checks)
|
||||
|
||||
## CLI Tool Configuration
|
||||
|
||||
### Gemini Configuration
|
||||
```javascript
|
||||
{
|
||||
"tool": "gemini",
|
||||
"model": "gemini-2.5-pro", // Auto-selected, no need to specify
|
||||
"templates": {
|
||||
"task-breakdown": "02-breakdown-task-steps.txt",
|
||||
"architecture-planning": "01-plan-architecture-design.txt",
|
||||
"component-design": "02-design-component-spec.txt"
|
||||
},
|
||||
"timeout": 3600000 // 60 minutes
|
||||
}
|
||||
```
|
||||
|
||||
### Qwen Configuration (Fallback)
|
||||
```javascript
|
||||
{
|
||||
"tool": "qwen",
|
||||
"model": "coder-model", // Auto-selected
|
||||
"templates": {
|
||||
"task-breakdown": "02-breakdown-task-steps.txt",
|
||||
"architecture-planning": "01-plan-architecture-design.txt"
|
||||
},
|
||||
"timeout": 3600000 // 60 minutes
|
||||
}
|
||||
```
|
||||
|
||||
## Example Execution
|
||||
|
||||
**Input Context**:
|
||||
```json
|
||||
{
|
||||
"task_description": "Implement user authentication with JWT tokens",
|
||||
"explorationContext": {
|
||||
"project_structure": "Express.js REST API with TypeScript, layered architecture (routes → services → repositories)",
|
||||
"relevant_files": [
|
||||
"src/users/user.service.ts",
|
||||
"src/users/user.repository.ts",
|
||||
"src/middleware/cors.middleware.ts",
|
||||
"src/routes/api.ts"
|
||||
],
|
||||
"patterns": "Service-Repository pattern used throughout. Services in src/{module}/{module}.service.ts, Repositories in src/{module}/{module}.repository.ts. Middleware follows function-based approach in src/middleware/",
|
||||
"dependencies": "Express, TypeORM, bcrypt for password hashing",
|
||||
"integration_points": "Auth service needs to integrate with existing user service and API routes",
|
||||
"constraints": "Must use existing TypeORM entities, follow established error handling patterns"
|
||||
},
|
||||
"clarificationContext": {
|
||||
"token_expiry": "1 hour access token, 7 days refresh token",
|
||||
"password_requirements": "Min 8 chars, must include number and special char"
|
||||
},
|
||||
"complexity": "Medium",
|
||||
"cli_config": {
|
||||
"tool": "gemini",
|
||||
"template": "02-breakdown-task-steps.txt",
|
||||
"timeout": 3600000
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Execution Steps**:
|
||||
1. **Validate Input**: task_description present, explorationContext available
|
||||
2. **Construct CLI Command**:
|
||||
```bash
|
||||
cd /project/root && gemini -p "
|
||||
PURPOSE: Generate detailed implementation plan for Medium complexity task with actionable task breakdown
|
||||
TASK:
|
||||
• Analyze task: Implement user authentication with JWT tokens
|
||||
• Break down into 3-10 actionable steps with specific file operations
|
||||
• Identify dependencies and execution sequence
|
||||
• Provide realistic time estimates
|
||||
MODE: analysis
|
||||
CONTEXT: @**/* | Memory: Relevant files: src/users/user.service.ts, src/middleware/cors.middleware.ts, etc. Patterns: Service-Repository pattern. Constraints: Use TypeORM entities.
|
||||
EXPECTED: Structured plan with actionable tasks
|
||||
RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/02-breakdown-task-steps.txt) | Complexity: Medium | analysis=READ-ONLY
|
||||
"
|
||||
```
|
||||
3. **Execute CLI**: Gemini runs and returns structured plan
|
||||
4. **Parse Output**: Extract summary, approach, tasks, time estimate
|
||||
5. **Enhance Tasks**:
|
||||
- Raw: "Implement authentication service"
|
||||
- Enhanced: "Create AuthService in src/auth/auth.service.ts: Implement login(), logout(), validateToken() methods following UserService pattern (src/users/user.service.ts)"
|
||||
6. **Generate planObject**:
|
||||
```javascript
|
||||
{
|
||||
summary: "Implement JWT-based authentication system with service layer, utilities, middleware, and route protection",
|
||||
approach: "Follow existing Service-Repository pattern. Create AuthService following UserService structure, add JWT utilities following existing util patterns, integrate with middleware stack, and protect API routes",
|
||||
tasks: [
|
||||
{
|
||||
title: "Create AuthService",
|
||||
file: "src/auth/auth.service.ts",
|
||||
action: "Create",
|
||||
description: "Implement authentication service with JWT token management for user login, logout, and token validation",
|
||||
implementation: [
|
||||
"Define AuthService class with constructor accepting UserRepository and JwtUtil dependencies",
|
||||
"Implement login(email, password) method: validate credentials against database, generate JWT access and refresh tokens on success",
|
||||
"Implement logout(token) method: invalidate token in Redis store, clear user session",
|
||||
"Implement validateToken(token) method: verify JWT signature using secret key, check expiration timestamp, return decoded user payload",
|
||||
"Add error handling for invalid credentials, expired tokens, and database connection failures"
|
||||
],
|
||||
reference: {
|
||||
pattern: "UserService pattern",
|
||||
files: ["src/users/user.service.ts", "src/utils/jwt.util.ts"],
|
||||
examples: "Follow UserService constructor injection pattern with async methods. Use JwtUtil.generateToken() and JwtUtil.verifyToken() for token operations"
|
||||
},
|
||||
acceptance: [
|
||||
"AuthService class created with login(), logout(), validateToken() methods",
|
||||
"Methods follow UserService async/await pattern with try-catch error handling",
|
||||
"JWT token generation uses JwtUtil with 1h access token and 7d refresh token expiry",
|
||||
"All methods return typed responses (success/error objects)"
|
||||
]
|
||||
},
|
||||
{
|
||||
title: "Add JWT utilities",
|
||||
file: "src/utils/jwt.ts",
|
||||
action: "Create",
|
||||
description: "Create JWT utility functions for token generation, verification, and refresh token handling",
|
||||
implementation: [
|
||||
"Define JwtUtil class with static methods for token operations",
|
||||
"Implement generateToken(payload, expiresIn) method: create JWT with HS256 algorithm, embed user payload, set expiration",
|
||||
"Implement verifyToken(token) method: decode JWT, validate signature against secret key, check expiration, return payload or throw error",
|
||||
"Implement refreshToken(oldToken) method: verify old token, generate new access token with extended expiry",
|
||||
"Add constants for token expiry times (ACCESS_TOKEN_EXPIRY=1h, REFRESH_TOKEN_EXPIRY=7d)"
|
||||
],
|
||||
reference: {
|
||||
pattern: "Utility class pattern",
|
||||
files: ["src/utils/crypto.util.ts", "src/utils/date.util.ts"],
|
||||
examples: "Follow static method pattern from existing utils. Use environment variables for JWT_SECRET"
|
||||
},
|
||||
acceptance: [
|
||||
"JwtUtil class created with generateToken(), verifyToken(), refreshToken() static methods",
|
||||
"Token expiry constants defined and used correctly",
|
||||
"Environment variable JWT_SECRET properly loaded and used",
|
||||
"Error handling for invalid/expired tokens implemented"
|
||||
]
|
||||
},
|
||||
{
|
||||
title: "Implement auth middleware",
|
||||
file: "src/middleware/auth.middleware.ts",
|
||||
action: "Create",
|
||||
description: "Create Express middleware to authenticate requests using JWT tokens from Authorization header",
|
||||
implementation: [
|
||||
"Define authenticateRequest middleware function accepting (req, res, next) parameters",
|
||||
"Extract JWT token from Authorization header (Bearer <token> format)",
|
||||
"Call JwtUtil.verifyToken(token) to validate token and get user payload",
|
||||
"Attach decoded user payload to req.user for downstream route handlers",
|
||||
"Return 401 Unauthorized if token missing, invalid, or expired with appropriate error message"
|
||||
],
|
||||
reference: {
|
||||
pattern: "Middleware function pattern",
|
||||
files: ["src/middleware/cors.middleware.ts", "src/middleware/logging.middleware.ts"],
|
||||
examples: "Follow Express middleware pattern with error handling. Use next() for successful validation, res.status(401).json() for failures"
|
||||
},
|
||||
acceptance: [
|
||||
"authenticateRequest middleware function created and exported",
|
||||
"Token extraction from Authorization header implemented",
|
||||
"User payload attached to req.user on successful validation",
|
||||
"Proper error responses (401) for missing/invalid tokens"
|
||||
]
|
||||
},
|
||||
{
|
||||
title: "Protect API routes",
|
||||
file: "src/routes/api.ts",
|
||||
action: "Update",
|
||||
description: "Apply authentication middleware to protected routes requiring user authentication",
|
||||
implementation: [
|
||||
"Import authenticateRequest middleware from src/middleware/auth.middleware.ts",
|
||||
"Identify protected routes (user profile, settings, data modification endpoints)",
|
||||
"Apply authenticateRequest middleware to protected routes using router.use() or per-route",
|
||||
"Keep public routes (login, register, health check) without authentication",
|
||||
"Update route documentation comments to indicate which routes require authentication"
|
||||
],
|
||||
reference: {
|
||||
pattern: "Route middleware application",
|
||||
files: ["src/routes/api.ts"],
|
||||
examples: "Use router.use('/protected', authenticateRequest) for route groups or router.get('/profile', authenticateRequest, handler) for individual routes"
|
||||
},
|
||||
acceptance: [
|
||||
"authenticateRequest middleware imported and applied to protected routes",
|
||||
"Public routes (login, register) remain accessible without auth",
|
||||
"Protected routes return 401 when accessed without valid token",
|
||||
"Route documentation updated to indicate authentication requirements"
|
||||
]
|
||||
},
|
||||
{
|
||||
title: "Create auth tests",
|
||||
file: "tests/auth.test.ts",
|
||||
action: "Create",
|
||||
description: "Write comprehensive unit tests for AuthService methods covering success and error scenarios",
|
||||
implementation: [
|
||||
"Set up test file with imports for AuthService, test utilities, and mocks",
|
||||
"Write tests for login() method: valid credentials, invalid credentials, database errors",
|
||||
"Write tests for logout() method: valid token invalidation, invalid token handling",
|
||||
"Write tests for validateToken() method: valid token, expired token, malformed token",
|
||||
"Add test setup and teardown for database connection and test data"
|
||||
],
|
||||
reference: {
|
||||
pattern: "Jest test pattern",
|
||||
files: ["tests/users/user.service.test.ts", "tests/utils/jwt.test.ts"],
|
||||
examples: "Follow existing test structure with describe/it blocks, beforeEach/afterEach hooks, and jest.mock() for dependencies"
|
||||
},
|
||||
acceptance: [
|
||||
"Test file created with all AuthService methods covered",
|
||||
"Success scenarios and error cases both tested",
|
||||
"Test coverage for login, logout, validateToken methods >= 90%",
|
||||
"All tests pass with proper assertions and mock usage"
|
||||
]
|
||||
}
|
||||
],
|
||||
estimated_time: "3-4 hours (1h service + 30m utils + 1h middleware + 30m routes + 1h tests)",
|
||||
recommended_execution: "Codex",
|
||||
complexity: "Medium"
|
||||
}
|
||||
```
|
||||
7. **Return**: `{status: "success", planObject: {...}}` with 5 structured, actionable task objects
|
||||
@@ -468,42 +468,6 @@ See: `.process/iteration-{iteration}-cli-output.txt`
|
||||
}
|
||||
```
|
||||
|
||||
## Integration with test-cycle-execute
|
||||
|
||||
**Orchestrator Call Pattern**:
|
||||
```javascript
|
||||
// When pass_rate < 95%
|
||||
Task(
|
||||
subagent_type="cli-planning-agent",
|
||||
description=`Analyze test failures and generate fix task (iteration ${iteration})`,
|
||||
prompt=`
|
||||
## Context Package
|
||||
${JSON.stringify(contextPackage, null, 2)}
|
||||
|
||||
## Your Task
|
||||
1. Execute CLI analysis using ${cli_config.tool}
|
||||
2. Parse CLI output and extract fix strategy
|
||||
3. Generate IMPL-fix-${iteration}.json with structured task definition
|
||||
4. Save analysis report to .process/iteration-${iteration}-analysis.md
|
||||
5. Report success and task ID back to orchestrator
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
**Agent Response**:
|
||||
```javascript
|
||||
{
|
||||
"status": "success",
|
||||
"task_id": "IMPL-fix-{iteration}",
|
||||
"task_path": ".workflow/{session}/.task/IMPL-fix-{iteration}.json",
|
||||
"analysis_report": ".process/iteration-{iteration}-analysis.md",
|
||||
"cli_output": ".process/iteration-{iteration}-cli-output.txt",
|
||||
"summary": "{fix_strategy.approach first 100 chars}",
|
||||
"modification_points_count": {count},
|
||||
"estimated_complexity": "low|medium|high"
|
||||
}
|
||||
```
|
||||
|
||||
## Example Execution
|
||||
|
||||
**Input Context**:
|
||||
@@ -550,4 +514,16 @@ Task(
|
||||
- fix_strategy.quality_assurance: {avoids_symptom_fix: true, addresses_root_cause: true}
|
||||
- **NO failure_context object** - full context available via analysis_report reference
|
||||
5. Save: iteration-1-analysis.md with full CLI output, layer context, failed_tests details, previous_attempts
|
||||
6. Return: task_id="IMPL-fix-1", test_layer="integration", status="success"
|
||||
6. **Return**:
|
||||
```javascript
|
||||
{
|
||||
status: "success",
|
||||
task_id: "IMPL-fix-1",
|
||||
task_path: ".workflow/WFS-test-session-001/.task/IMPL-fix-1.json",
|
||||
analysis_report: ".process/iteration-1-analysis.md",
|
||||
cli_output: ".process/iteration-1-cli-output.txt",
|
||||
summary: "Token expiry check only happens in service, not enforced in middleware",
|
||||
modification_points_count: 2,
|
||||
estimated_complexity: "medium"
|
||||
}
|
||||
```
|
||||
|
||||
@@ -239,6 +239,37 @@ previousExecutionResults = []
|
||||
- May split into multiple calls if task list is very large (>10 tasks)
|
||||
|
||||
```javascript
|
||||
// Function to create execution calls from structured task objects
|
||||
function createExecutionCalls(tasks) {
|
||||
// For structured task objects, create summary from task titles
|
||||
const taskTitles = tasks.map(t => t.title || t) // Support both old and new format
|
||||
|
||||
// Single execution call for all tasks (most common)
|
||||
if (tasks.length <= 10) {
|
||||
return [{
|
||||
method: executionMethod === "Codex" ? "Codex" : "Agent",
|
||||
taskSummary: taskTitles.length <= 3
|
||||
? taskTitles.join(', ')
|
||||
: `${taskTitles.slice(0, 2).join(', ')}, and ${taskTitles.length - 2} more`,
|
||||
tasks: tasks
|
||||
}]
|
||||
}
|
||||
|
||||
// Split into multiple calls for large task sets (>10 tasks)
|
||||
const callSize = 5
|
||||
const calls = []
|
||||
for (let i = 0; i < tasks.length; i += callSize) {
|
||||
const batchTasks = tasks.slice(i, i + callSize)
|
||||
const batchTitles = batchTasks.map(t => t.title || t)
|
||||
calls.push({
|
||||
method: executionMethod === "Codex" ? "Codex" : "Agent",
|
||||
taskSummary: `Tasks ${i + 1}-${Math.min(i + callSize, tasks.length)}: ${batchTitles[0]}${batchTitles.length > 1 ? ', ...' : ''}`,
|
||||
tasks: batchTasks
|
||||
})
|
||||
}
|
||||
return calls
|
||||
}
|
||||
|
||||
// Create execution calls (usually 1-2 calls total)
|
||||
executionCalls = createExecutionCalls(planObject.tasks).map((call, index) => ({
|
||||
...call,
|
||||
@@ -257,13 +288,18 @@ TodoWrite({
|
||||
|
||||
**Example Execution List**:
|
||||
```
|
||||
[ ] [Agent-1] (Implement all planned tasks)
|
||||
[ ] [Agent-1] (Create AuthService, Add JWT utilities, Implement auth middleware)
|
||||
```
|
||||
|
||||
Or for large task sets:
|
||||
Or for large task sets (>10 tasks):
|
||||
```
|
||||
[ ] [Agent-1] (Tasks 1-5: Core implementation)
|
||||
[ ] [Agent-2] (Tasks 6-10: Tests and documentation)
|
||||
[ ] [Agent-1] (Tasks 1-5: Create AuthService, Add JWT utilities, ...)
|
||||
[ ] [Agent-2] (Tasks 6-10: Create tests, Update documentation, ...)
|
||||
```
|
||||
|
||||
Or when only a few tasks:
|
||||
```
|
||||
[ ] [Codex-1] (Create AuthService, Add JWT utilities, and 3 more)
|
||||
```
|
||||
|
||||
### Step 3: Launch Execution
|
||||
@@ -293,6 +329,27 @@ Based on execution method selection, launch appropriate execution:
|
||||
|
||||
**Agent Call**:
|
||||
```javascript
|
||||
// Format structured task objects for display
|
||||
function formatTaskForAgent(task, index) {
|
||||
return `
|
||||
### Task ${index + 1}: ${task.title}
|
||||
**File**: ${task.file}
|
||||
**Action**: ${task.action}
|
||||
**Description**: ${task.description}
|
||||
|
||||
**Implementation Steps**:
|
||||
${task.implementation.map((step, i) => `${i + 1}. ${step}`).join('\n')}
|
||||
|
||||
**Reference**:
|
||||
- Pattern: ${task.reference.pattern}
|
||||
- Example Files: ${task.reference.files.join(', ')}
|
||||
- Guidance: ${task.reference.examples}
|
||||
|
||||
**Acceptance Criteria**:
|
||||
${task.acceptance.map((criterion, i) => `${i + 1}. ${criterion}`).join('\n')}
|
||||
`
|
||||
}
|
||||
|
||||
Task(
|
||||
subagent_type="code-developer",
|
||||
description="Implement planned tasks with progress tracking",
|
||||
@@ -301,10 +358,12 @@ Task(
|
||||
|
||||
## Implementation Plan
|
||||
|
||||
Summary: ${planObject.summary}
|
||||
**Summary**: ${planObject.summary}
|
||||
|
||||
Task Breakdown:
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
**Approach**: ${planObject.approach}
|
||||
|
||||
## Task Breakdown (${planObject.tasks.length} tasks)
|
||||
${planObject.tasks.map((task, i) => formatTaskForAgent(task, i)).join('\n')}
|
||||
|
||||
${previousExecutionResults.length > 0 ? `\n## Previous Execution Results\n${previousExecutionResults.map(result => `
|
||||
[${result.executionId}] ${result.status}
|
||||
@@ -314,9 +373,6 @@ Key outputs: ${result.keyOutputs || 'See git diff for details'}
|
||||
${result.notes ? `Notes: ${result.notes}` : ''}
|
||||
`).join('\n---\n')}` : ''}
|
||||
|
||||
## Implementation Approach
|
||||
${planObject.approach}
|
||||
|
||||
## Code Context
|
||||
${explorationContext || "No exploration performed"}
|
||||
|
||||
@@ -344,6 +400,21 @@ ${result.notes ? `Notes: ${result.notes}` : ''}
|
||||
|
||||
**Command Format**:
|
||||
```bash
|
||||
# Format structured task objects for Codex
|
||||
function formatTaskForCodex(task, index) {
|
||||
return `
|
||||
${index + 1}. ${task.title} (${task.file})
|
||||
Action: ${task.action}
|
||||
What: ${task.description}
|
||||
How:
|
||||
${task.implementation.map((step, i) => ` ${i + 1}. ${step}`).join('\n')}
|
||||
Reference: ${task.reference.pattern} (see ${task.reference.files.join(', ')})
|
||||
Guidance: ${task.reference.examples}
|
||||
Verify:
|
||||
${task.acceptance.map((criterion, i) => ` - ${criterion}`).join('\n')}
|
||||
`
|
||||
}
|
||||
|
||||
codex --full-auto exec "
|
||||
${originalUserInput ? `## Original User Request\n${originalUserInput}\n\n` : ''}
|
||||
|
||||
@@ -351,8 +422,10 @@ ${originalUserInput ? `## Original User Request\n${originalUserInput}\n\n` : ''}
|
||||
|
||||
TASK: ${planObject.summary}
|
||||
|
||||
### Task Breakdown
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
APPROACH: ${planObject.approach}
|
||||
|
||||
### Task Breakdown (${planObject.tasks.length} tasks)
|
||||
${planObject.tasks.map((task, i) => formatTaskForCodex(task, i)).join('\n')}
|
||||
|
||||
${previousExecutionResults.length > 0 ? `\n### Previous Execution Results\n${previousExecutionResults.map(result => `
|
||||
[${result.executionId}] ${result.status}
|
||||
@@ -365,9 +438,6 @@ ${result.notes ? `Notes: ${result.notes}` : ''}
|
||||
IMPORTANT: Review previous results above. Build on completed work. Avoid duplication.
|
||||
` : ''}
|
||||
|
||||
### Implementation Approach
|
||||
${planObject.approach}
|
||||
|
||||
### Code Context from Exploration
|
||||
${explorationContext ? `
|
||||
Project Structure: ${explorationContext.project_structure || 'Standard structure'}
|
||||
|
||||
@@ -20,7 +20,7 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
|
||||
- **Interactive Clarification**: Asks follow-up questions after exploration to gather missing information
|
||||
- **Adaptive Planning**:
|
||||
- Simple tasks: Direct planning by current Claude
|
||||
- Complex tasks: Delegates to cli-planning-agent for detailed breakdown
|
||||
- Complex tasks: Delegates to cli-lite-planning-agent for detailed breakdown
|
||||
- **Two-Step Confirmation**: First display complete plan as text, then collect three-dimensional input (task approval + execution method + code review tool)
|
||||
- **Execution Dispatch**: Stores execution context in memory and calls `/workflow:lite-execute --in-memory` for actual implementation
|
||||
|
||||
@@ -73,7 +73,21 @@ Implementation plan from Phase 3:
|
||||
{
|
||||
summary: string, // 2-3 sentence overview
|
||||
approach: string, // High-level implementation strategy
|
||||
tasks: string[], // 3-10 tasks with file paths
|
||||
tasks: [ // 3-10 structured task objects
|
||||
{
|
||||
title: string, // Task title (e.g., "Create AuthService")
|
||||
file: string, // Target file path
|
||||
action: string, // Action type: Create|Update|Implement|Refactor|Add|Delete
|
||||
description: string, // What to implement (1-2 sentences)
|
||||
implementation: string[], // Step-by-step how to do it (3-7 steps)
|
||||
reference: { // What to reference
|
||||
pattern: string, // Pattern name (e.g., "UserService pattern")
|
||||
files: string[], // Reference file paths
|
||||
examples: string // Specific guidance on what to copy/follow
|
||||
},
|
||||
acceptance: string[] // Verification criteria (2-4 items)
|
||||
}
|
||||
],
|
||||
estimated_time: string, // Total implementation time estimate
|
||||
recommended_execution: string, // "Agent" (Low) or "Codex" (Medium/High)
|
||||
complexity: string // "Low" | "Medium" | "High"
|
||||
@@ -126,7 +140,21 @@ When user selects "Export JSON", lite-plan exports an enhanced structure aligned
|
||||
"plan": {
|
||||
"summary": "2-3 sentence overview",
|
||||
"approach": "High-level implementation strategy",
|
||||
"tasks": ["Task 1", "Task 2", "..."]
|
||||
"tasks": [
|
||||
{
|
||||
"title": "Task 1 title",
|
||||
"file": "src/path/to/file.ts",
|
||||
"action": "Create|Update|Implement|...",
|
||||
"description": "What to implement",
|
||||
"implementation": ["Step 1", "Step 2", "..."],
|
||||
"reference": {
|
||||
"pattern": "Pattern name",
|
||||
"files": ["ref/file1.ts", "ref/file2.ts"],
|
||||
"examples": "Specific guidance"
|
||||
},
|
||||
"acceptance": ["Criterion 1", "Criterion 2", "..."]
|
||||
}
|
||||
]
|
||||
},
|
||||
"exploration": {
|
||||
"project_structure": "...",
|
||||
@@ -181,7 +209,7 @@ User Input ("/workflow:lite-plan \"task\"")
|
||||
-> Assess task complexity (Low/Medium/High)
|
||||
-> Decision: Planning strategy
|
||||
- Low: Direct planning (current Claude)
|
||||
- Medium/High: Delegate to cli-planning-agent
|
||||
- Medium/High: Delegate to cli-lite-planning-agent
|
||||
-> Output: planObject
|
||||
|
|
||||
v
|
||||
@@ -356,8 +384,8 @@ else complexity = "High"
|
||||
| Level | Characteristics | Planning Strategy |
|
||||
|-------|----------------|-------------------|
|
||||
| Low | 1-2 files, simple changes, clear requirements | Direct planning (current Claude) |
|
||||
| Medium | 3-5 files, moderate integration, some ambiguity | Delegate to cli-planning-agent |
|
||||
| High | 6+ files, complex architecture, high uncertainty | Delegate to cli-planning-agent with detailed analysis |
|
||||
| Medium | 3-5 files, moderate integration, some ambiguity | Delegate to cli-lite-planning-agent |
|
||||
| High | 6+ files, complex architecture, high uncertainty | Delegate to cli-lite-planning-agent with detailed analysis |
|
||||
|
||||
**Planning Execution**:
|
||||
|
||||
@@ -372,27 +400,44 @@ Current Claude generates plan directly following these guidelines:
|
||||
|
||||
**Option B: Agent-Based Planning (Medium/High Complexity)**
|
||||
|
||||
Delegate to cli-planning-agent with detailed requirements:
|
||||
Delegate to cli-lite-planning-agent with detailed requirements:
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-planning-agent",
|
||||
subagent_type="cli-lite-planning-agent",
|
||||
description="Generate detailed implementation plan",
|
||||
prompt=`
|
||||
Task: ${task_description}
|
||||
Exploration Context: ${JSON.stringify(explorationContext, null, 2)}
|
||||
User Clarifications: ${JSON.stringify(clarificationContext, null, 2) || "None provided"}
|
||||
Complexity Level: ${complexity}
|
||||
## Task Description
|
||||
${task_description}
|
||||
|
||||
Generate a detailed implementation plan with the following components:
|
||||
## Exploration Context
|
||||
${JSON.stringify(explorationContext, null, 2) || "No exploration performed"}
|
||||
|
||||
1. Summary: 2-3 sentence overview of the implementation
|
||||
2. Approach: High-level implementation strategy
|
||||
3. Task Breakdown: 3-10 specific, actionable tasks
|
||||
- Each task should specify: What to do, Which files to modify/create
|
||||
4. Estimated Time: Total implementation time estimate
|
||||
5. Recommended Execution: "Agent" or "Codex" based on task complexity
|
||||
## User Clarifications
|
||||
${JSON.stringify(clarificationContext, null, 2) || "None provided"}
|
||||
|
||||
Ensure tasks are specific, with file paths and clear acceptance criteria.
|
||||
## Complexity Level
|
||||
${complexity}
|
||||
|
||||
## Your Task
|
||||
1. Execute CLI planning analysis using Gemini (Qwen as fallback)
|
||||
2. Parse CLI output and extract structured plan
|
||||
3. Enhance tasks to be actionable with file paths and pattern references
|
||||
4. Generate planObject with:
|
||||
- Summary (2-3 sentences)
|
||||
- Approach (high-level strategy)
|
||||
- Tasks (3-10 actionable steps with file paths)
|
||||
- Estimated time (with breakdown if available)
|
||||
- Recommended execution method (Agent for Low, Codex for Medium/High)
|
||||
5. Return planObject (no file writes)
|
||||
|
||||
## Quality Requirements
|
||||
Each task MUST include:
|
||||
- Action verb (Create, Update, Add, Implement, Refactor)
|
||||
- Specific file path
|
||||
- Detailed changes
|
||||
- Pattern reference from exploration context
|
||||
|
||||
Format: "{Action} in {file_path}: {specific_details} following {pattern}"
|
||||
`
|
||||
)
|
||||
```
|
||||
@@ -424,8 +469,14 @@ First, output the complete plan to the user as regular text:
|
||||
|
||||
**Approach**: ${planObject.approach}
|
||||
|
||||
**Task Breakdown**:
|
||||
${planObject.tasks.map((t, i) => `${i+1}. ${t}`).join('\n')}
|
||||
**Task Breakdown** (${planObject.tasks.length} tasks):
|
||||
${planObject.tasks.map((task, i) => `
|
||||
${i+1}. **${task.title}** (${task.file})
|
||||
- What: ${task.description}
|
||||
- How: ${task.implementation.length} steps
|
||||
- Reference: ${task.reference.pattern}
|
||||
- Verification: ${task.acceptance.length} criteria
|
||||
`).join('')}
|
||||
|
||||
**Complexity**: ${planObject.complexity}
|
||||
**Estimated Time**: ${planObject.estimated_time}
|
||||
@@ -591,12 +642,12 @@ if (userSelection.export_task_json === "Yes") {
|
||||
plan: {
|
||||
summary: planObject.summary,
|
||||
approach: planObject.approach,
|
||||
tasks: planObject.tasks
|
||||
tasks: planObject.tasks // Array of structured task objects
|
||||
},
|
||||
exploration: explorationContext || null,
|
||||
clarifications: clarificationContext || null,
|
||||
focus_paths: explorationContext?.relevant_files || [],
|
||||
acceptance: planObject.tasks // Tasks serve as acceptance criteria
|
||||
acceptance: planObject.tasks.flatMap(t => t.acceptance) // Collect all acceptance criteria from tasks
|
||||
}
|
||||
}
|
||||
|
||||
@@ -745,7 +796,7 @@ SlashCommand(command="/workflow:lite-execute --in-memory")
|
||||
|-------|-------|------------|
|
||||
| Phase 1 Exploration Failure | cli-explore-agent unavailable or timeout | Skip exploration, set `explorationContext = null`, log warning, continue to Phase 2/3 with task description only |
|
||||
| Phase 2 Clarification Timeout | User no response > 5 minutes | Use exploration findings as-is without clarification, proceed to Phase 3 with warning |
|
||||
| Phase 3 Planning Agent Failure | cli-planning-agent unavailable or timeout | Fallback to direct planning by current Claude (simplified plan), continue to Phase 4 |
|
||||
| Phase 3 Planning Agent Failure | cli-lite-planning-agent unavailable or timeout | Fallback to direct planning by current Claude (simplified plan), continue to Phase 4 |
|
||||
| Phase 3 Planning Timeout | Planning takes > 90 seconds | Generate simplified direct plan, mark as "Quick Plan", continue to Phase 4 with reduced detail |
|
||||
| Phase 4 Confirmation Timeout | User no response > 5 minutes | Save plan context to temporary var, display resume instructions, exit gracefully |
|
||||
| Phase 4 Modification Loop | User requests modify > 3 times | Suggest breaking task into smaller pieces or using /workflow:plan for comprehensive planning |
|
||||
|
||||
Reference in New Issue
Block a user