mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-13 02:41:50 +08:00
feat: initialize monorepo with package.json for CCW workflow platform
This commit is contained in:
catlog22
@@ -3,503 +3,490 @@ description: Universal execution engine for consuming planning/brainstorm/analys
|
||||
argument-hint: "PLAN=\"<path>\" [--auto-commit] [--dry-run]"
|
||||
---
|
||||
|
||||
# Codex Unified-Execute-With-File Prompt
|
||||
# Codex Unified-Execute-With-File Workflow
|
||||
|
||||
## Overview
|
||||
## Quick Start
|
||||
|
||||
Universal execution engine consuming **any** planning output and executing tasks serially with progress tracking.
|
||||
|
||||
**Core workflow**: Load Plan → Parse Tasks → Execute Sequentially → Track Progress → Verify
|
||||
**Core workflow**: Load Plan → Parse Tasks → Validate → Execute Sequentially → Track Progress → Verify
|
||||
|
||||
## Target Plan
|
||||
**Key features**:
|
||||
- **Format-agnostic**: Supports plan.json, plan-note.md, synthesis.json, conclusions.json
|
||||
- **Serial execution**: Process tasks sequentially with dependency ordering
|
||||
- **Progress tracking**: execution.md overview + execution-events.md detailed log
|
||||
- **Auto-commit**: Optional conventional commits after each task
|
||||
- **Dry-run mode**: Simulate execution without making changes
|
||||
|
||||
**$PLAN**
|
||||
## Overview
|
||||
|
||||
**Parameters**:
|
||||
- `--auto-commit`: Auto-commit after each task (conventional commits)
|
||||
- `--dry-run`: Simulate execution without making changes
|
||||
This workflow enables reliable task execution through sequential phases:
|
||||
|
||||
## Execution Process
|
||||
1. **Plan Detection & Parsing** - Load and parse planning output in any format
|
||||
2. **Pre-Execution Analysis** - Validate feasibility and identify potential issues
|
||||
3. **Serial Task Execution** - Execute tasks one by one with dependency ordering
|
||||
4. **Progress Tracking** - Update execution logs with results and discoveries
|
||||
5. **Completion** - Generate summary and offer follow-up actions
|
||||
|
||||
```
|
||||
Session Initialization:
|
||||
├─ Detect or load plan file
|
||||
├─ Parse tasks from plan (JSON, Markdown, or other formats)
|
||||
├─ Build task dependency graph
|
||||
└─ Validate for cycles and feasibility
|
||||
|
||||
Pre-Execution:
|
||||
├─ Analyze plan structure
|
||||
├─ Identify modification targets (files)
|
||||
├─ Check file conflicts and feasibility
|
||||
└─ Generate execution strategy
|
||||
|
||||
Serial Execution (Task by Task):
|
||||
├─ For each task:
|
||||
│ ├─ Extract task context
|
||||
│ ├─ Load previous task outputs
|
||||
│ ├─ Route to Codex CLI for execution
|
||||
│ ├─ Track progress in execution.md
|
||||
│ ├─ Auto-commit if enabled
|
||||
│ └─ Next task
|
||||
└─ Complete all tasks
|
||||
|
||||
Post-Execution:
|
||||
├─ Generate execution summary
|
||||
├─ Record completion status
|
||||
├─ Identify any failures
|
||||
└─ Suggest next steps
|
||||
|
||||
Output:
|
||||
├─ .workflow/.execution/{session-id}/execution.md (overview + timeline)
|
||||
├─ .workflow/.execution/{session-id}/execution-events.md (detailed log)
|
||||
└─ Git commits (if --auto-commit enabled)
|
||||
```
|
||||
The key innovation is the **unified event log** that serves as both human-readable progress tracker and machine-parseable state store.
|
||||
|
||||
## Output Structure
|
||||
|
||||
```
|
||||
.workflow/.execution/EXEC-{slug}-{date}/
|
||||
.workflow/.execution/EXEC-{slug}-{date}-{random}/
|
||||
├── execution.md # Plan overview + task table + timeline
|
||||
└── execution-events.md # ⭐ Unified log (all executions) - SINGLE SOURCE OF TRUTH
|
||||
```
|
||||
|
||||
## Output Artifacts
|
||||
|
||||
### Phase 1: Session Initialization
|
||||
|
||||
| Artifact | Purpose |
|
||||
|----------|---------|
|
||||
| `execution.md` | Overview of plan source, task table, execution timeline |
|
||||
| Session folder | `.workflow/.execution/{sessionId}/` |
|
||||
|
||||
### Phase 2: Pre-Execution Analysis
|
||||
|
||||
| Artifact | Purpose |
|
||||
|----------|---------|
|
||||
| `execution.md` (updated) | Feasibility assessment and validation results |
|
||||
|
||||
### Phase 3-4: Serial Execution & Progress
|
||||
|
||||
| Artifact | Purpose |
|
||||
|----------|---------|
|
||||
| `execution-events.md` | Unified log: all task executions with results |
|
||||
| `execution.md` (updated) | Real-time progress updates and task status |
|
||||
|
||||
### Phase 5: Completion
|
||||
|
||||
| Artifact | Purpose |
|
||||
|----------|---------|
|
||||
| Final `execution.md` | Complete execution summary and statistics |
|
||||
| Final `execution-events.md` | Complete execution history |
|
||||
|
||||
---
|
||||
|
||||
## Implementation Details
|
||||
|
||||
### Session Setup
|
||||
### Session Initialization
|
||||
|
||||
```javascript
|
||||
const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
|
||||
The workflow creates a unique session for tracking execution.
|
||||
|
||||
// Resolve plan path
|
||||
let planPath = "$PLAN"
|
||||
if (!fs.existsSync(planPath)) {
|
||||
// Auto-detect from common locations
|
||||
const candidates = [
|
||||
'.workflow/IMPL_PLAN.md',
|
||||
'.workflow/.planning/*/plan-note.md',
|
||||
'.workflow/.brainstorm/*/synthesis.json',
|
||||
'.workflow/.analysis/*/conclusions.json'
|
||||
]
|
||||
planPath = autoDetectPlan(candidates)
|
||||
}
|
||||
**Session ID Format**: `EXEC-{slug}-{date}-{random}`
|
||||
- `slug`: Plan filename without extension, lowercased, max 30 chars
|
||||
- `date`: YYYY-MM-DD format (UTC+8)
|
||||
- `random`: 7-char random suffix for uniqueness
|
||||
|
||||
// Create session
|
||||
const planSlug = path.basename(planPath).replace(/[^a-z0-9-]/g, '').substring(0, 30)
|
||||
const dateStr = getUtc8ISOString().substring(0, 10)
|
||||
const randomId = Math.random().toString(36).substring(7)
|
||||
const sessionId = `EXEC-${planSlug}-${dateStr}-${randomId}`
|
||||
**Session Directory**: `.workflow/.execution/{sessionId}/`
|
||||
|
||||
const sessionFolder = `.workflow/.execution/${sessionId}`
|
||||
const executionPath = `${sessionFolder}/execution.md`
|
||||
const eventsPath = `${sessionFolder}/execution-events.md`
|
||||
**Plan Path Resolution**:
|
||||
1. If `$PLAN` provided explicitly, use it
|
||||
2. Otherwise, auto-detect from common locations:
|
||||
- `.workflow/IMPL_PLAN.md`
|
||||
- `.workflow/.planning/*/plan-note.md`
|
||||
- `.workflow/.brainstorm/*/synthesis.json`
|
||||
- `.workflow/.analysis/*/conclusions.json`
|
||||
|
||||
bash(`mkdir -p ${sessionFolder}`)
|
||||
```
|
||||
**Session Variables**:
|
||||
- `sessionId`: Unique session identifier
|
||||
- `sessionFolder`: Base directory for artifacts
|
||||
- `planPath`: Resolved path to plan file
|
||||
- `autoCommit`: Boolean flag for auto-commit mode
|
||||
- `dryRun`: Boolean flag for dry-run mode
|
||||
|
||||
---
|
||||
|
||||
### Phase 1: Plan Detection & Parsing
|
||||
## Phase 1: Plan Detection & Parsing
|
||||
|
||||
#### Step 1.1: Load Plan File
|
||||
**Objective**: Load plan file, parse tasks, build execution order, and validate for cycles.
|
||||
|
||||
```javascript
|
||||
// Detect plan format and parse
|
||||
let tasks = []
|
||||
### Step 1.1: Load Plan File
|
||||
|
||||
if (planPath.endsWith('.json')) {
|
||||
// JSON plan (from lite-plan, collaborative-plan, etc.)
|
||||
const planJson = JSON.parse(Read(planPath))
|
||||
tasks = parsePlanJson(planJson)
|
||||
} else if (planPath.endsWith('.md')) {
|
||||
// Markdown plan (IMPL_PLAN.md, plan-note.md, etc.)
|
||||
const planMd = Read(planPath)
|
||||
tasks = parsePlanMarkdown(planMd)
|
||||
} else if (planPath.endsWith('synthesis.json')) {
|
||||
// Brainstorm synthesis
|
||||
const synthesis = JSON.parse(Read(planPath))
|
||||
tasks = convertSynthesisToTasks(synthesis)
|
||||
} else if (planPath.endsWith('conclusions.json')) {
|
||||
// Analysis conclusions
|
||||
const conclusions = JSON.parse(Read(planPath))
|
||||
tasks = convertConclusionsToTasks(conclusions)
|
||||
} else {
|
||||
throw new Error(`Unsupported plan format: ${planPath}`)
|
||||
}
|
||||
```
|
||||
Detect plan format and parse based on file extension.
|
||||
|
||||
#### Step 1.2: Build Execution Order
|
||||
**Supported Formats**:
|
||||
|
||||
```javascript
|
||||
// Handle task dependencies
|
||||
const depGraph = buildDependencyGraph(tasks)
|
||||
| Format | Source | Parser |
|
||||
|--------|--------|--------|
|
||||
| plan.json | lite-plan, collaborative-plan | parsePlanJson() |
|
||||
| plan-note.md | collaborative-plan | parsePlanMarkdown() |
|
||||
| synthesis.json | brainstorm session | convertSynthesisToTasks() |
|
||||
| conclusions.json | analysis session | convertConclusionsToTasks() |
|
||||
|
||||
// Validate: no cycles
|
||||
validateNoCycles(depGraph)
|
||||
**Parsing Activities**:
|
||||
1. Read plan file content
|
||||
2. Detect format from filename or content structure
|
||||
3. Route to appropriate parser
|
||||
4. Extract tasks with required fields: id, title, description, files_to_modify, depends_on
|
||||
|
||||
// Calculate execution order (simple topological sort)
|
||||
const executionOrder = topologicalSort(depGraph, tasks)
|
||||
### Step 1.2: Build Execution Order
|
||||
|
||||
// In Codex: serial execution, no parallel waves
|
||||
console.log(`Total tasks: ${tasks.length}`)
|
||||
console.log(`Execution order: ${executionOrder.map(t => t.id).join(' → ')}`)
|
||||
```
|
||||
Analyze task dependencies and calculate execution sequence.
|
||||
|
||||
#### Step 1.3: Generate execution.md
|
||||
**Execution Order Calculation**:
|
||||
1. Build dependency graph from task dependencies
|
||||
2. Validate for circular dependencies (no cycles allowed)
|
||||
3. Calculate topological sort for sequential execution order
|
||||
4. In Codex: serial mode means executing tasks one by one
|
||||
|
||||
```markdown
|
||||
# 执行计划
|
||||
**Dependency Validation**:
|
||||
- Check that all referenced dependencies exist
|
||||
- Detect cycles and report as critical error
|
||||
- Order tasks based on dependencies
|
||||
|
||||
**Session**: ${sessionId}
|
||||
**Plan Source**: ${planPath}
|
||||
**Started**: ${getUtc8ISOString()}
|
||||
### Step 1.3: Generate execution.md
|
||||
|
||||
Create the main execution tracking document.
|
||||
|
||||
**execution.md Structure**:
|
||||
- **Header**: Session ID, plan source, execution timestamp
|
||||
- **Plan Overview**: Summary from plan metadata
|
||||
- **Task List**: Table with ID, title, complexity, dependencies, status
|
||||
- **Execution Timeline**: To be updated as tasks complete
|
||||
|
||||
**Success Criteria**:
|
||||
- execution.md created with complete plan overview
|
||||
- Task list includes all tasks from plan
|
||||
- Execution order calculated with no cycles
|
||||
- Ready for feasibility analysis
|
||||
|
||||
---
|
||||
|
||||
## 计划概览
|
||||
## Phase 2: Pre-Execution Analysis
|
||||
|
||||
| 字段 | 值 |
|
||||
|------|-----|
|
||||
| 总任务数 | ${tasks.length} |
|
||||
| 计划来源 | ${planPath} |
|
||||
| 执行模式 | ${dryRun ? '模拟' : '实际'} |
|
||||
| 自动提交 | ${autoCommit ? '启用' : '禁用'} |
|
||||
**Objective**: Validate feasibility and identify potential issues before starting execution.
|
||||
|
||||
### Step 2.1: Analyze Plan Structure
|
||||
|
||||
Examine task dependencies, file modifications, and potential conflicts.
|
||||
|
||||
**Analysis Activities**:
|
||||
1. **Check file conflicts**: Identify files modified by multiple tasks
|
||||
2. **Check missing dependencies**: Verify all referenced dependencies exist
|
||||
3. **Check file existence**: Identify files that will be created vs modified
|
||||
4. **Estimate complexity**: Assess overall execution complexity
|
||||
|
||||
**Issue Detection**:
|
||||
- Sequential modifications to same file (document for ordered execution)
|
||||
- Missing dependency targets
|
||||
- High complexity patterns that may need special handling
|
||||
|
||||
### Step 2.2: Generate Feasibility Report
|
||||
|
||||
Document analysis results and recommendations.
|
||||
|
||||
**Feasibility Report Content**:
|
||||
- Issues found (if any)
|
||||
- File conflict warnings
|
||||
- Dependency validation results
|
||||
- Complexity assessment
|
||||
- Recommended execution strategy
|
||||
|
||||
### Step 2.3: Update execution.md
|
||||
|
||||
Append feasibility analysis results.
|
||||
|
||||
**Success Criteria**:
|
||||
- All validation checks completed
|
||||
- Issues documented in execution.md
|
||||
- No blocking issues found (or user confirmed to proceed)
|
||||
- Ready for task execution
|
||||
|
||||
---
|
||||
|
||||
## 任务列表
|
||||
## Phase 3: Serial Task Execution
|
||||
|
||||
| ID | 标题 | 复杂度 | 依赖 | 状态 |
|
||||
|----|------|--------|-------|-------|
|
||||
${tasks.map(t => `| ${t.id} | ${t.title} | ${t.complexity || 'medium'} | ${t.depends_on?.join(',') || '-'} | ⏳ |`).join('\n')}
|
||||
**Objective**: Execute tasks one by one in dependency order, tracking progress and recording results.
|
||||
|
||||
---
|
||||
**Execution Model**: Serial execution - process tasks sequentially, one at a time. Each task must complete before the next begins.
|
||||
|
||||
## 执行时间线
|
||||
### Step 3.1: Execute Tasks Sequentially
|
||||
|
||||
*(更新于 execution-events.md)*
|
||||
For each task in execution order:
|
||||
1. Load context from previous task results
|
||||
2. Route to Codex CLI for execution
|
||||
3. Wait for completion
|
||||
4. Record results in execution-events.md
|
||||
5. Auto-commit if enabled
|
||||
6. Move to next task
|
||||
|
||||
---
|
||||
**Execution Loop**:
|
||||
```
|
||||
For each task in executionOrder:
|
||||
├─ Extract task context
|
||||
├─ Load previous task outputs
|
||||
├─ Execute task via CLI (synchronous)
|
||||
├─ Record result with timestamp
|
||||
├─ Auto-commit if enabled
|
||||
└─ Continue to next task
|
||||
```
|
||||
|
||||
---
|
||||
### Step 3.2: Execute Task via CLI
|
||||
|
||||
### Phase 2: Pre-Execution Analysis
|
||||
Execute individual task using Codex CLI in synchronous mode.
|
||||
|
||||
#### Step 2.1: Feasibility Check
|
||||
**CLI Execution Scope**:
|
||||
- **PURPOSE**: Execute task from plan
|
||||
- **TASK DETAILS**: ID, title, description, required changes
|
||||
- **PRIOR CONTEXT**: Results from previous tasks
|
||||
- **REQUIRED CHANGES**: Files to modify with specific locations
|
||||
- **MODE**: write (modification mode)
|
||||
- **EXPECTED**: Files modified as specified, no test failures
|
||||
|
||||
```javascript
|
||||
const issues = []
|
||||
**CLI Parameters**:
|
||||
- `--tool codex`: Use Codex for execution
|
||||
- `--mode write`: Allow file modifications
|
||||
- Synchronous execution: Wait for completion
|
||||
|
||||
// Check file conflicts
|
||||
const fileMap = new Map()
|
||||
for (const task of tasks) {
|
||||
for (const file of task.files_to_modify || []) {
|
||||
if (!fileMap.has(file)) fileMap.set(file, [])
|
||||
fileMap.get(file).push(task.id)
|
||||
}
|
||||
}
|
||||
### Step 3.3: Track Progress
|
||||
|
||||
for (const [file, taskIds] of fileMap.entries()) {
|
||||
if (taskIds.length > 1) {
|
||||
// Sequential modification of same file
|
||||
console.log(`⚠️ Sequential modification: ${file} (${taskIds.join(' → ')})`)
|
||||
}
|
||||
}
|
||||
Record task execution results in the unified event log.
|
||||
|
||||
// Check missing dependencies
|
||||
for (const task of tasks) {
|
||||
for (const depId of task.depends_on || []) {
|
||||
if (!tasks.find(t => t.id === depId)) {
|
||||
issues.push(`Task ${task.id} depends on missing ${depId}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
**execution-events.md Structure**:
|
||||
- **Header**: Session metadata
|
||||
- **Event Timeline**: One entry per task with results
|
||||
- **Event Format**:
|
||||
- Task ID and title
|
||||
- Timestamp and duration
|
||||
- Status (completed/failed)
|
||||
- Summary of changes
|
||||
- Any notes or issues discovered
|
||||
|
||||
if (issues.length > 0) {
|
||||
console.log(`⚠️ Issues found:\n${issues.map(i => `- ${i}`).join('\n')}`)
|
||||
}
|
||||
```
|
||||
**Event Recording Activities**:
|
||||
1. Capture execution timestamp
|
||||
2. Record task status and duration
|
||||
3. Document any modifications made
|
||||
4. Note any issues or discoveries
|
||||
5. Append event to execution-events.md
|
||||
|
||||
### Step 3.4: Auto-Commit (if enabled)
|
||||
|
||||
Commit task changes with conventional commit format.
|
||||
|
||||
**Auto-Commit Process**:
|
||||
1. Get changed files from git status
|
||||
2. Filter to task.files_to_modify
|
||||
3. Stage files: `git add`
|
||||
4. Generate commit message based on task type
|
||||
5. Commit: `git commit -m`
|
||||
|
||||
**Commit Message Format**:
|
||||
- Type: feat, fix, refactor, test, docs (inferred from task)
|
||||
- Scope: file/module affected (inferred from files modified)
|
||||
- Subject: Task title or description
|
||||
- Footer: Task ID and plan reference
|
||||
|
||||
**Success Criteria**:
|
||||
- All tasks executed sequentially
|
||||
- Results recorded in execution-events.md
|
||||
- Auto-commits created (if enabled)
|
||||
- Failed tasks logged for review
|
||||
|
||||
---
|
||||
|
||||
### Phase 3: Serial Task Execution
|
||||
## Phase 4: Completion
|
||||
|
||||
#### Step 3.1: Execute Tasks Sequentially
|
||||
**Objective**: Summarize execution results and offer follow-up actions.
|
||||
|
||||
```javascript
|
||||
const executionLog = []
|
||||
const taskResults = new Map()
|
||||
### Step 4.1: Collect Statistics
|
||||
|
||||
for (const task of executionOrder) {
|
||||
console.log(`\n📋 Executing: ${task.id} - ${task.title}`)
|
||||
Gather execution metrics.
|
||||
|
||||
const eventRecord = {
|
||||
timestamp: getUtc8ISOString(),
|
||||
task_id: task.id,
|
||||
task_title: task.title,
|
||||
status: 'in_progress',
|
||||
notes: []
|
||||
}
|
||||
**Metrics Collection**:
|
||||
- Total tasks executed
|
||||
- Successfully completed count
|
||||
- Failed count
|
||||
- Success rate percentage
|
||||
- Total duration
|
||||
- Artifacts generated
|
||||
|
||||
try {
|
||||
// Load context from previous tasks
|
||||
const priorOutputs = executionOrder
|
||||
.slice(0, executionOrder.indexOf(task))
|
||||
.map(t => taskResults.get(t.id))
|
||||
.filter(Boolean)
|
||||
### Step 4.2: Generate Summary
|
||||
|
||||
const context = {
|
||||
task: task,
|
||||
prior_outputs: priorOutputs,
|
||||
plan_source: planPath
|
||||
}
|
||||
Update execution.md with final results.
|
||||
|
||||
// Execute task via Codex CLI
|
||||
if (dryRun) {
|
||||
console.log(`[DRY RUN] ${task.id}`)
|
||||
eventRecord.status = 'completed'
|
||||
eventRecord.notes.push('Dry run - no changes made')
|
||||
} else {
|
||||
await executeTaskViaCLI(task, context)
|
||||
eventRecord.status = 'completed'
|
||||
|
||||
// Auto-commit if enabled
|
||||
if (autoCommit) {
|
||||
commitTask(task)
|
||||
eventRecord.notes.push(`✅ Committed: ${task.id}`)
|
||||
}
|
||||
}
|
||||
**Summary Content**:
|
||||
- Execution completion timestamp
|
||||
- Statistics table
|
||||
- Task status table (completed/failed)
|
||||
- Commit log (if auto-commit enabled)
|
||||
- Any failed tasks requiring attention
|
||||
|
||||
} catch (error) {
|
||||
eventRecord.status = 'failed'
|
||||
eventRecord.error = error.message
|
||||
eventRecord.notes.push(`❌ Error: ${error.message}`)
|
||||
console.log(`❌ Failed: ${task.id}`)
|
||||
}
|
||||
### Step 4.3: Display Completion Summary
|
||||
|
||||
executionLog.push(eventRecord)
|
||||
updateExecutionEvents(eventsPath, executionLog)
|
||||
updateExecutionMd(executionPath, task, eventRecord)
|
||||
}
|
||||
```
|
||||
Present results to user.
|
||||
|
||||
#### Step 3.2: Execute Task via CLI
|
||||
**Summary Output**:
|
||||
- Session ID and folder path
|
||||
- Statistics (completed/failed/total)
|
||||
- Failed tasks (if any)
|
||||
- Execution log location
|
||||
- Next step recommendations
|
||||
|
||||
**CLI Call** (synchronous):
|
||||
```bash
|
||||
ccw cli -p "
|
||||
PURPOSE: Execute task '${task.id}: ${task.title}' from plan
|
||||
Success: Task completed as specified in plan
|
||||
|
||||
TASK DETAILS:
|
||||
- ID: ${task.id}
|
||||
- Title: ${task.title}
|
||||
- Description: ${task.description}
|
||||
- Complexity: ${task.complexity}
|
||||
- Estimated Effort: ${task.effort}
|
||||
|
||||
REQUIRED CHANGES:
|
||||
${task.files_to_modify?.map(f => `- \`${f.path}\`: ${f.summary}`).join('\n')}
|
||||
|
||||
PRIOR CONTEXT:
|
||||
${priorOutputs.map(p => `- ${p.task_id}: ${p.notes.join('; ')}`).join('\n')}
|
||||
|
||||
TASK ACTIONS:
|
||||
${task.actions?.map((a, i) => `${i+1}. ${a}`).join('\n')}
|
||||
|
||||
MODE: write
|
||||
|
||||
CONTEXT: @**/* | Plan Source: ${planPath} | Task: ${task.id}
|
||||
|
||||
EXPECTED:
|
||||
- Modifications implemented as specified
|
||||
- Code follows project conventions
|
||||
- No test failures introduced
|
||||
- All required files updated
|
||||
|
||||
CONSTRAINTS: Exactly as specified in plan | No additional scope
|
||||
" --tool codex --mode write
|
||||
```
|
||||
|
||||
#### Step 3.3: Track Progress
|
||||
|
||||
```javascript
|
||||
function updateExecutionEvents(eventsPath, log) {
|
||||
const eventsMd = `# 执行日志
|
||||
|
||||
**Session**: ${sessionId}
|
||||
**更新**: ${getUtc8ISOString()}
|
||||
|
||||
---
|
||||
|
||||
## 事件时间线
|
||||
|
||||
${log.map((e, i) => `
|
||||
### 事件 ${i+1}: ${e.task_id}
|
||||
|
||||
**时间**: ${e.timestamp}
|
||||
**任务**: ${e.task_title}
|
||||
**状态**: ${e.status === 'completed' ? '✅' : e.status === 'failed' ? '❌' : '⏳'}
|
||||
|
||||
**笔记**:
|
||||
${e.notes.map(n => `- ${n}`).join('\n')}
|
||||
|
||||
${e.error ? `**错误**: ${e.error}` : ''}
|
||||
`).join('\n')}
|
||||
|
||||
---
|
||||
|
||||
## 统计
|
||||
|
||||
- **总数**: ${log.length}
|
||||
- **完成**: ${log.filter(e => e.status === 'completed').length}
|
||||
- **失败**: ${log.filter(e => e.status === 'failed').length}
|
||||
- **进行中**: ${log.filter(e => e.status === 'in_progress').length}
|
||||
`
|
||||
|
||||
Write(eventsPath, eventsMd)
|
||||
}
|
||||
|
||||
function updateExecutionMd(mdPath, task, record) {
|
||||
const content = Read(mdPath)
|
||||
|
||||
// Update task status in table
|
||||
const updated = content.replace(
|
||||
new RegExp(`\\| ${task.id} \\|.*\\| ⏳ \\|`),
|
||||
`| ${task.id} | ... | ... | ... | ${record.status === 'completed' ? '✅' : '❌'} |`
|
||||
)
|
||||
|
||||
Write(mdPath, updated)
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Phase 4: Completion
|
||||
|
||||
#### Step 4.1: Generate Summary
|
||||
|
||||
```javascript
|
||||
const completed = executionLog.filter(e => e.status === 'completed').length
|
||||
const failed = executionLog.filter(e => e.status === 'failed').length
|
||||
|
||||
const summary = `
|
||||
# 执行完成
|
||||
|
||||
**Session**: ${sessionId}
|
||||
**完成时间**: ${getUtc8ISOString()}
|
||||
|
||||
## 结果
|
||||
|
||||
| 指标 | 数值 |
|
||||
|------|------|
|
||||
| 总任务 | ${executionLog.length} |
|
||||
| 成功 | ${completed} ✅ |
|
||||
| 失败 | ${failed} ❌ |
|
||||
| 成功率 | ${Math.round(completed / executionLog.length * 100)}% |
|
||||
|
||||
## 后续步骤
|
||||
|
||||
${failed > 0 ? `
|
||||
### ❌ 修复失败的任务
|
||||
|
||||
\`\`\`bash
|
||||
# 检查失败详情
|
||||
cat ${eventsPath}
|
||||
|
||||
# 重新执行失败任务
|
||||
${executionLog.filter(e => e.status === 'failed').map(e => `# ${e.task_id}`).join('\n')}
|
||||
\`\`\`
|
||||
` : `
|
||||
### ✅ 执行完成
|
||||
|
||||
所有任务已成功完成！
|
||||
`}
|
||||
|
||||
## 提交日志
|
||||
|
||||
${executionLog.filter(e => e.notes.some(n => n.includes('Committed'))).map(e => `- ${e.task_id}: ✅`).join('\n')}
|
||||
`
|
||||
|
||||
Write(executionPath, summary)
|
||||
```
|
||||
|
||||
#### Step 4.2: Report Results
|
||||
|
||||
```javascript
|
||||
console.log(`
|
||||
✅ 执行完成: ${sessionId}
|
||||
成功: ${completed}/${executionLog.length}
|
||||
${failed > 0 ? `失败: ${failed}` : '无失败'}
|
||||
|
||||
📁 详情: ${eventsPath}
|
||||
`)
|
||||
```
|
||||
**Success Criteria**:
|
||||
- execution.md finalized with complete summary
|
||||
- execution-events.md contains all task records
|
||||
- User informed of completion status
|
||||
- All artifacts successfully created
|
||||
|
||||
---
|
||||
|
||||
## Configuration
|
||||
|
||||
### Task Format Detection
|
||||
### Plan Format Detection
|
||||
|
||||
Supports multiple plan formats:
|
||||
Workflow automatically detects plan format:
|
||||
|
||||
| Format | Source | Parser |
|
||||
|--------|--------|--------|
|
||||
| JSON | lite-plan, collaborative-plan | parsePlanJson() |
|
||||
| Markdown | IMPL_PLAN.md, plan-note.md | parsePlanMarkdown() |
|
||||
| JSON synthesis | Brainstorm session | convertSynthesisToTasks() |
|
||||
| JSON conclusions | Analysis session | convertConclusionsToTasks() |
|
||||
| File Extension | Format |
|
||||
|---|---|
|
||||
| `.json` | JSON plan (lite-plan, collaborative-plan) |
|
||||
| `.md` | Markdown plan (IMPL_PLAN.md, plan-note.md) |
|
||||
| `synthesis.json` | Brainstorm synthesis |
|
||||
| `conclusions.json` | Analysis conclusions |
|
||||
|
||||
### Auto-Commit Format
|
||||
### Execution Modes
|
||||
|
||||
| Mode | Behavior | Use Case |
|
||||
|------|----------|----------|
|
||||
| Normal | Execute tasks, track progress | Standard execution |
|
||||
| `--auto-commit` | Execute + commit each task | Tracked progress with git history |
|
||||
| `--dry-run` | Simulate execution, no changes | Validate plan before executing |
|
||||
|
||||
### Task Dependencies
|
||||
|
||||
Tasks can declare dependencies on other tasks:
|
||||
- `depends_on: ["TASK-001", "TASK-002"]` - Wait for these tasks
|
||||
- Tasks are executed in topological order
|
||||
- Circular dependencies are detected and reported as error
|
||||
|
||||
---
|
||||
|
||||
## Error Handling & Recovery
|
||||
|
||||
| Situation | Action | Recovery |
|
||||
|-----------|--------|----------|
|
||||
| Plan not found | Check file path and common locations | Verify plan path is correct |
|
||||
| Unsupported format | Detect format from extension/content | Use supported plan format |
|
||||
| Circular dependency | Stop execution, report error | Remove or reorganize dependencies |
|
||||
| Task execution fails | Record failure in log | Review error details in execution-events.md |
|
||||
| File conflict | Document in execution-events.md | Resolve conflict manually or adjust plan order |
|
||||
| Missing file | Log as warning, continue | Verify files will be created by prior tasks |
|
||||
|
||||
---
|
||||
|
||||
## Execution Flow Diagram
|
||||
|
||||
Conventional Commits:
|
||||
```
|
||||
{type}({scope}): {description}
|
||||
Load Plan File
|
||||
├─ Detect format (JSON/Markdown)
|
||||
├─ Parse tasks
|
||||
└─ Build dependency graph
|
||||
|
||||
{task_id}: {task_title}
|
||||
Files: {list of modified files}
|
||||
Validate
|
||||
├─ Check for cycles
|
||||
├─ Analyze file conflicts
|
||||
└─ Calculate execution order
|
||||
|
||||
Execute Sequentially
|
||||
├─ Task 1: CLI execution → record result
|
||||
├─ Task 2: CLI execution → record result
|
||||
├─ Task 3: CLI execution → record result
|
||||
└─ (repeat for all tasks)
|
||||
|
||||
Track Progress
|
||||
├─ Update execution.md after each task
|
||||
└─ Append event to execution-events.md
|
||||
|
||||
Complete
|
||||
├─ Generate final summary
|
||||
├─ Report statistics
|
||||
└─ Offer follow-up actions
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Error Handling
|
||||
## Best Practices
|
||||
|
||||
| Error | Resolution |
|
||||
|-------|------------|
|
||||
| Plan not found | Use explicit --plan flag or check .workflow/ |
|
||||
| Unsupported format | Verify plan file format matches supported types |
|
||||
| Task execution fails | Check execution-events.md for details |
|
||||
| Dependency missing | Verify plan completeness |
|
||||
### Before Execution
|
||||
|
||||
1. **Review Plan**: Check plan.md or plan-note.md for completeness
|
||||
2. **Validate Format**: Ensure plan is in supported format
|
||||
3. **Check Dependencies**: Verify dependency order is logical
|
||||
4. **Test First**: Use `--dry-run` mode to validate before actual execution
|
||||
5. **Backup**: Commit any pending changes before starting
|
||||
|
||||
### During Execution
|
||||
|
||||
1. **Monitor Progress**: Check execution-events.md for real-time updates
|
||||
2. **Handle Failures**: Review error details and decide whether to continue
|
||||
3. **Check Commits**: Verify auto-commits are correct if enabled
|
||||
4. **Track Context**: Prior task results are available to subsequent tasks
|
||||
|
||||
### After Execution
|
||||
|
||||
1. **Review Results**: Check execution.md summary and statistics
|
||||
2. **Verify Changes**: Inspect modified files match expected changes
|
||||
3. **Handle Failures**: Address any failed tasks
|
||||
4. **Update History**: Check git log for conventional commits if enabled
|
||||
5. **Plan Next Steps**: Use completion artifacts for future work
|
||||
|
||||
---
|
||||
|
||||
## Execution Modes
|
||||
## When to Use This Workflow
|
||||
|
||||
| Mode | Behavior |
|
||||
|------|----------|
|
||||
| Normal | Execute tasks sequentially, auto-commit disabled |
|
||||
| --auto-commit | Execute + commit each task |
|
||||
| --dry-run | Simulate execution, no changes |
|
||||
### Use unified-execute-with-file when:
|
||||
- Ready to execute a complete plan from planning workflow
|
||||
- Need reliable sequential task execution with tracking
|
||||
- Want automatic git commits for audit trail
|
||||
- Executing plans from brainstorm, analysis, or collaborative-plan workflows
|
||||
- Need to validate plan before full execution (--dry-run)
|
||||
|
||||
### Use direct CLI execution when:
|
||||
- Single task that doesn't need full plan structure
|
||||
- Quick implementation without tracking overhead
|
||||
- Small changes that don't need git history
|
||||
|
||||
### Consider alternatives when:
|
||||
- Still planning/exploring → use `workflow:brainstorm-with-file` or `workflow:analyze-with-file`
|
||||
- Need complex task planning → use `workflow:collaborative-plan-with-file`
|
||||
- Debugging or troubleshooting → use `workflow:debug-with-file`
|
||||
|
||||
---
|
||||
|
||||
## Usage
|
||||
## Command Examples
|
||||
|
||||
### Standard Execution
|
||||
|
||||
```bash
|
||||
# Load and execute plan
|
||||
PLAN="path/to/plan.json" \
|
||||
PLAN=".workflow/.planning/CPLAN-auth-2025-01-27/plan-note.md"
|
||||
```
|
||||
|
||||
Execute the plan with standard options.
|
||||
|
||||
### With Auto-Commit
|
||||
|
||||
```bash
|
||||
PLAN=".workflow/.planning/CPLAN-auth-2025-01-27/plan-note.md" \
|
||||
--auto-commit
|
||||
```
|
||||
|
||||
# Dry run first
|
||||
PLAN="path/to/plan.json" \
|
||||
Execute and automatically commit changes after each task.
|
||||
|
||||
### Dry-Run Mode
|
||||
|
||||
```bash
|
||||
PLAN=".workflow/.planning/CPLAN-auth-2025-01-27/plan-note.md" \
|
||||
--dry-run
|
||||
```
|
||||
|
||||
# Auto-detect plan
|
||||
# (searches .workflow/ for recent plans)
|
||||
Simulate execution without making changes.
|
||||
|
||||
### Auto-Detect Plan
|
||||
|
||||
```bash
|
||||
# No PLAN specified - auto-detects from .workflow/ directories
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
Reference in New Issue
Block a user