mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-05 01:50:27 +08:00
refactor: Add tree-style execution flow diagrams to all workflow commands
Added tree-style execution process diagrams using ASCII art (├─, └─, │) to 34 workflow command files across three directories for improved readability and execution flow clarity. ## Changes by Directory ### workflow/ root (17 files) - lite-plan.md, lite-execute.md, lite-fix.md - plan.md, execute.md, replan.md - status.md, review.md, review-fix.md - review-session-cycle.md, review-module-cycle.md - session commands (start, complete, resume, list) - tdd-plan.md, tdd-verify.md, test-cycle-execute.md, test-gen.md, test-fix-gen.md ### workflow/ui-design/ (10 files) - layout-extract.md, animation-extract.md, style-extract.md - generate.md, import-from-code.md, codify-style.md - imitate-auto.md, explore-auto.md - reference-page-generator.md, design-sync.md ### workflow/tools/ (8 files) - conflict-resolution.md, task-generate-agent.md, context-gather.md - tdd-coverage-analysis.md, task-generate-tdd.md - test-task-generate.md, test-concept-enhanced.md, test-context-gather.md ## Diagram Features - Input parsing with flag enumeration - Decision branching with conditional paths - Phase/step hierarchy with clear nesting - Mode detection and validation flows 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
catlog22
@@ -32,12 +32,16 @@ Identify inconsistencies, duplications, ambiguities, and underspecified items be
|
||||
IF --session parameter provided:
|
||||
session_id = provided session
|
||||
ELSE:
|
||||
CHECK: find .workflow/active/ -name "WFS-*" -type d
|
||||
IF active_session EXISTS:
|
||||
session_id = get_active_session()
|
||||
ELSE:
|
||||
# Auto-detect active session
|
||||
active_sessions = bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
|
||||
IF active_sessions is empty:
|
||||
ERROR: "No active workflow session found. Use --session <session-id>"
|
||||
EXIT
|
||||
ELSE IF active_sessions has multiple entries:
|
||||
# Use most recently modified session
|
||||
session_id = bash(ls -td .workflow/active/WFS-*/ 2>/dev/null | head -1 | xargs basename)
|
||||
ELSE:
|
||||
session_id = basename(active_sessions[0])
|
||||
|
||||
# Derive absolute paths
|
||||
session_dir = .workflow/active/WFS-{session}
|
||||
@@ -45,13 +49,15 @@ brainstorm_dir = session_dir/.brainstorming
|
||||
task_dir = session_dir/.task
|
||||
|
||||
# Validate required artifacts
|
||||
SYNTHESIS = brainstorm_dir/role analysis documents
|
||||
# Note: "role analysis documents" refers to [role]/analysis.md files (e.g., product-manager/analysis.md)
|
||||
SYNTHESIS_DIR = brainstorm_dir # Contains role analysis files: */analysis.md
|
||||
IMPL_PLAN = session_dir/IMPL_PLAN.md
|
||||
TASK_FILES = Glob(task_dir/*.json)
|
||||
|
||||
# Abort if missing
|
||||
IF NOT EXISTS(SYNTHESIS):
|
||||
ERROR: "role analysis documents not found. Run /workflow:brainstorm:synthesis first"
|
||||
SYNTHESIS_FILES = Glob(brainstorm_dir/*/analysis.md)
|
||||
IF SYNTHESIS_FILES.count == 0:
|
||||
ERROR: "No role analysis documents found in .brainstorming/*/analysis.md. Run /workflow:brainstorm:synthesis first"
|
||||
EXIT
|
||||
|
||||
IF NOT EXISTS(IMPL_PLAN):
|
||||
@@ -135,27 +141,27 @@ Focus on high-signal findings. Limit to 50 findings total; aggregate remainder i
|
||||
- **Unmapped Tasks**: Tasks with no clear requirement linkage
|
||||
- **NFR Coverage Gaps**: Non-functional requirements (performance, security, scalability) not reflected in tasks
|
||||
|
||||
#### B. Consistency Validation
|
||||
#### C. Consistency Validation
|
||||
|
||||
- **Requirement Conflicts**: Tasks contradicting synthesis requirements
|
||||
- **Architecture Drift**: IMPL_PLAN architecture not matching synthesis ADRs
|
||||
- **Terminology Drift**: Same concept named differently across IMPL_PLAN and tasks
|
||||
- **Data Model Inconsistency**: Tasks referencing entities/fields not in synthesis data model
|
||||
|
||||
#### C. Dependency Integrity
|
||||
#### D. Dependency Integrity
|
||||
|
||||
- **Circular Dependencies**: Task A depends on B, B depends on C, C depends on A
|
||||
- **Missing Dependencies**: Task requires outputs from another task but no explicit dependency
|
||||
- **Broken Dependencies**: Task depends on non-existent task ID
|
||||
- **Logical Ordering Issues**: Implementation tasks before foundational setup without dependency note
|
||||
|
||||
#### D. Synthesis Alignment
|
||||
#### E. Synthesis Alignment
|
||||
|
||||
- **Priority Conflicts**: High-priority synthesis requirements mapped to low-priority tasks
|
||||
- **Success Criteria Mismatch**: IMPL_PLAN success criteria not covering synthesis acceptance criteria
|
||||
- **Risk Mitigation Gaps**: Critical risks in synthesis without corresponding mitigation tasks
|
||||
|
||||
#### E. Task Specification Quality
|
||||
#### F. Task Specification Quality
|
||||
|
||||
- **Ambiguous Focus Paths**: Tasks with vague or missing focus_paths
|
||||
- **Underspecified Acceptance**: Tasks without clear acceptance criteria
|
||||
@@ -163,12 +169,12 @@ Focus on high-signal findings. Limit to 50 findings total; aggregate remainder i
|
||||
- **Weak Flow Control**: Tasks without clear implementation_approach or pre_analysis steps
|
||||
- **Missing Target Files**: Tasks without flow_control.target_files specification
|
||||
|
||||
#### F. Duplication Detection
|
||||
#### G. Duplication Detection
|
||||
|
||||
- **Overlapping Task Scope**: Multiple tasks with nearly identical descriptions
|
||||
- **Redundant Requirements Coverage**: Same requirement covered by multiple tasks without clear partitioning
|
||||
|
||||
#### G. Feasibility Assessment
|
||||
#### H. Feasibility Assessment
|
||||
|
||||
- **Complexity Misalignment**: Task marked "simple" but requires multiple file modifications
|
||||
- **Resource Conflicts**: Parallel tasks requiring same resources/files
|
||||
@@ -203,7 +209,9 @@ Use this heuristic to prioritize findings:
|
||||
|
||||
### 6. Produce Compact Analysis Report
|
||||
|
||||
Output a Markdown report (no file writes) with the following structure:
|
||||
**Report Generation**: Generate report content and save to file.
|
||||
|
||||
Output a Markdown report with the following structure:
|
||||
|
||||
```markdown
|
||||
## Action Plan Verification Report
|
||||
@@ -217,7 +225,11 @@ Output a Markdown report (no file writes) with the following structure:
|
||||
### Executive Summary
|
||||
|
||||
- **Overall Risk Level**: CRITICAL | HIGH | MEDIUM | LOW
|
||||
- **Recommendation**: BLOCK_EXECUTION | PROCEED_WITH_FIXES | PROCEED_WITH_CAUTION | PROCEED
|
||||
- **Recommendation**: (See decision matrix below)
|
||||
- BLOCK_EXECUTION: Critical issues exist (must fix before proceeding)
|
||||
- PROCEED_WITH_FIXES: High issues exist, no critical (fix recommended before execution)
|
||||
- PROCEED_WITH_CAUTION: Medium issues only (proceed with awareness)
|
||||
- PROCEED: Low issues only or no issues (safe to execute)
|
||||
- **Critical Issues**: {count}
|
||||
- **High Issues**: {count}
|
||||
- **Medium Issues**: {count}
|
||||
@@ -322,14 +334,27 @@ Output a Markdown report (no file writes) with the following structure:
|
||||
|
||||
#### Action Recommendations
|
||||
|
||||
**If CRITICAL Issues Exist**:
|
||||
- **BLOCK EXECUTION** - Resolve critical issues before proceeding
|
||||
- Use TodoWrite to track all required fixes
|
||||
- Fix broken dependencies and circular references
|
||||
**Recommendation Decision Matrix**:
|
||||
|
||||
**If Only HIGH/MEDIUM/LOW Issues**:
|
||||
- **PROCEED WITH CAUTION** - Fix high-priority issues first
|
||||
- Use TodoWrite to systematically track and complete all improvements
|
||||
| Condition | Recommendation | Action |
|
||||
|-----------|----------------|--------|
|
||||
| Critical > 0 | BLOCK_EXECUTION | Must resolve all critical issues before proceeding |
|
||||
| Critical = 0, High > 0 | PROCEED_WITH_FIXES | Fix high-priority issues before execution |
|
||||
| Critical = 0, High = 0, Medium > 0 | PROCEED_WITH_CAUTION | Proceed with awareness of medium issues |
|
||||
| Only Low or None | PROCEED | Safe to execute workflow |
|
||||
|
||||
**If CRITICAL Issues Exist** (BLOCK_EXECUTION):
|
||||
- Resolve all critical issues before proceeding
|
||||
- Use TodoWrite to track required fixes
|
||||
- Fix broken dependencies and circular references first
|
||||
|
||||
**If HIGH Issues Exist** (PROCEED_WITH_FIXES):
|
||||
- Fix high-priority issues before execution
|
||||
- Use TodoWrite to systematically track and complete improvements
|
||||
|
||||
**If Only MEDIUM/LOW Issues** (PROCEED_WITH_CAUTION / PROCEED):
|
||||
- Can proceed with execution
|
||||
- Address issues during or after implementation
|
||||
|
||||
#### TodoWrite-Based Remediation Workflow
|
||||
|
||||
@@ -359,13 +384,18 @@ Priority Order:
|
||||
|
||||
### 7. Save Report and Execute TodoWrite-Based Remediation
|
||||
|
||||
**Save Analysis Report**:
|
||||
**Step 7.1: Save Analysis Report**:
|
||||
```bash
|
||||
report_path = ".workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md"
|
||||
Write(report_path, full_report_content)
|
||||
```
|
||||
|
||||
**After Report Generation**:
|
||||
**Step 7.2: Display Report Summary to User**:
|
||||
- Show executive summary with counts
|
||||
- Display recommendation (BLOCK/PROCEED_WITH_FIXES/PROCEED_WITH_CAUTION/PROCEED)
|
||||
- List critical and high issues if any
|
||||
|
||||
**Step 7.3: After Report Generation**:
|
||||
|
||||
1. **Extract Findings**: Parse all issues by severity
|
||||
2. **Create TodoWrite Task List**: Convert findings to actionable todos
|
||||
|
||||
@@ -16,9 +16,9 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
|
||||
**Lazy Loading**: Task JSONs read **on-demand** during execution, not upfront. TODO_LIST.md + IMPL_PLAN.md provide metadata for planning.
|
||||
|
||||
**Loading Strategy**:
|
||||
- **TODO_LIST.md**: Read in Phase 2 (task metadata, status, dependencies)
|
||||
- **IMPL_PLAN.md**: Read existence in Phase 2, parse execution strategy when needed
|
||||
- **Task JSONs**: Complete lazy loading (read only during execution)
|
||||
- **TODO_LIST.md**: Read in Phase 3 (task metadata, status, dependencies for TodoWrite generation)
|
||||
- **IMPL_PLAN.md**: Check existence in Phase 2 (normal mode), parse execution strategy in Phase 4A
|
||||
- **Task JSONs**: Lazy loading - read only when task is about to execute (Phase 4B)
|
||||
|
||||
## Core Rules
|
||||
**Complete entire workflow autonomously without user interruption, using TodoWrite for comprehensive progress tracking.**
|
||||
@@ -39,6 +39,48 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
|
||||
- **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
|
||||
- **Autonomous completion**: Execute all tasks without user interruption until workflow complete
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Normal Mode:
|
||||
Phase 1: Discovery
|
||||
├─ Count active sessions
|
||||
└─ Decision:
|
||||
├─ count=0 → ERROR: No active sessions
|
||||
├─ count=1 → Auto-select session → Phase 2
|
||||
└─ count>1 → AskUserQuestion (max 4 options) → Phase 2
|
||||
|
||||
Phase 2: Planning Document Validation
|
||||
├─ Check IMPL_PLAN.md exists
|
||||
├─ Check TODO_LIST.md exists
|
||||
└─ Validate .task/ contains IMPL-*.json files
|
||||
|
||||
Phase 3: TodoWrite Generation
|
||||
├─ Parse TODO_LIST.md for task statuses
|
||||
├─ Generate TodoWrite for entire workflow
|
||||
└─ Prepare session context paths
|
||||
|
||||
Phase 4: Execution Strategy & Task Execution
|
||||
├─ Step 4A: Parse execution strategy from IMPL_PLAN.md
|
||||
└─ Step 4B: Execute tasks with lazy loading
|
||||
└─ Loop:
|
||||
├─ Get next in_progress task from TodoWrite
|
||||
├─ Lazy load task JSON
|
||||
├─ Launch agent with task context
|
||||
├─ Mark task completed
|
||||
└─ Advance to next task
|
||||
|
||||
Phase 5: Completion
|
||||
├─ Update task statuses in JSON files
|
||||
├─ Generate summaries
|
||||
└─ Auto-call /workflow:session:complete
|
||||
|
||||
Resume Mode (--resume-session):
|
||||
├─ Skip Phase 1 & Phase 2
|
||||
└─ Entry Point: Phase 3 (TodoWrite Generation)
|
||||
└─ Continue: Phase 4 → Phase 5
|
||||
```
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Phase 1: Discovery
|
||||
@@ -81,16 +123,31 @@ bash(for dir in .workflow/active/WFS-*/; do
|
||||
done)
|
||||
```
|
||||
|
||||
Use AskUserQuestion to present formatted options:
|
||||
```
|
||||
Multiple active workflow sessions detected. Please select one:
|
||||
Use AskUserQuestion to present formatted options (max 4 options shown):
|
||||
```javascript
|
||||
// If more than 4 sessions, show most recent 4 with "Other" option for manual input
|
||||
const sessions = getActiveSessions() // sorted by last modified
|
||||
const displaySessions = sessions.slice(0, 4)
|
||||
|
||||
1. WFS-auth-system | Authentication System | 3/5 tasks (60%)
|
||||
2. WFS-payment-module | Payment Integration | 0/8 tasks (0%)
|
||||
|
||||
Enter number, full session ID, or partial match:
|
||||
AskUserQuestion({
|
||||
questions: [{
|
||||
question: "Multiple active sessions detected. Select one:",
|
||||
header: "Session",
|
||||
multiSelect: false,
|
||||
options: displaySessions.map(s => ({
|
||||
label: s.id,
|
||||
description: `${s.project} | ${s.progress}`
|
||||
}))
|
||||
// Note: User can select "Other" to manually enter session ID
|
||||
}]
|
||||
})
|
||||
```
|
||||
|
||||
**Input Validation**:
|
||||
- If user selects from options: Use selected session ID
|
||||
- If user selects "Other" and provides input: Validate session exists
|
||||
- If validation fails: Show error and re-prompt or suggest available sessions
|
||||
|
||||
Parse user input (supports: number "1", full ID "WFS-auth-system", or partial "auth"), validate selection, and continue to Phase 2.
|
||||
|
||||
#### Step 1.3: Load Session Metadata
|
||||
@@ -103,20 +160,19 @@ bash(cat .workflow/active/${sessionId}/workflow-session.json)
|
||||
|
||||
**Resume Mode**: This entire phase is skipped when `--resume-session="session-id"` flag is provided.
|
||||
|
||||
### Phase 2: Planning Document Analysis
|
||||
### Phase 2: Planning Document Validation
|
||||
**Applies to**: Normal mode only (skipped in resume mode)
|
||||
|
||||
**Optimized to avoid reading all task JSONs upfront**
|
||||
**Purpose**: Validate planning artifacts exist before execution
|
||||
|
||||
**Process**:
|
||||
1. **Check IMPL_PLAN.md**: Verify file exists and has valid structure (defer detailed parsing to Phase 4)
|
||||
2. **Read TODO_LIST.md**: Get current task statuses and execution progress
|
||||
3. **Extract Task Metadata**: Parse task IDs, titles, and dependency relationships from TODO_LIST.md
|
||||
4. **Build Execution Queue**: Determine ready tasks based on TODO_LIST.md status and dependencies
|
||||
1. **Check IMPL_PLAN.md**: Verify file exists (defer detailed parsing to Phase 4A)
|
||||
2. **Check TODO_LIST.md**: Verify file exists (defer reading to Phase 3)
|
||||
3. **Validate Task Directory**: Ensure `.task/` contains at least one IMPL-*.json file
|
||||
|
||||
**Key Optimization**: Use IMPL_PLAN.md (existence check only) and TODO_LIST.md as primary sources instead of reading all task JSONs. Detailed IMPL_PLAN.md parsing happens in Phase 4A.
|
||||
**Key Optimization**: Only existence checks here. Actual file reading happens in later phases.
|
||||
|
||||
**Resume Mode**: When `--resume-session` flag is provided, **session discovery** (Phase 1) is skipped, but **task metadata loading** (TODO_LIST.md reading) still occurs in Phase 3 for TodoWrite generation.
|
||||
**Resume Mode**: This phase is skipped when `--resume-session` flag is provided. Resume mode entry point is Phase 3.
|
||||
|
||||
### Phase 3: TodoWrite Generation
|
||||
**Applies to**: Both normal and resume modes (resume mode entry point)
|
||||
@@ -156,7 +212,7 @@ If IMPL_PLAN.md lacks execution strategy, use intelligent fallback (analyze task
|
||||
```
|
||||
while (TODO_LIST.md has pending tasks) {
|
||||
next_task_id = getTodoWriteInProgressTask()
|
||||
task_json = Read(.workflow/session/{session}/.task/{next_task_id}.json) // Lazy load
|
||||
task_json = Read(.workflow/active/{session}/.task/{next_task_id}.json) // Lazy load
|
||||
executeTaskWithAgent(task_json)
|
||||
updateTodoListMarkCompleted(next_task_id)
|
||||
advanceTodoWriteToNextTask()
|
||||
|
||||
@@ -20,9 +20,40 @@ Initialize `.workflow/project.json` with comprehensive project understanding by
|
||||
/workflow:init --regenerate # Force regeneration
|
||||
```
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
└─ Parse --regenerate flag → regenerate = true | false
|
||||
|
||||
Decision:
|
||||
├─ EXISTS + no --regenerate → Exit: "Already initialized"
|
||||
├─ EXISTS + --regenerate → Backup existing → Continue analysis
|
||||
└─ NOT_FOUND → Continue analysis
|
||||
|
||||
Analysis Flow:
|
||||
├─ Get project metadata (name, root)
|
||||
├─ Invoke cli-explore-agent
|
||||
│ ├─ Structural scan (get_modules_by_depth.sh, find, wc)
|
||||
│ ├─ Semantic analysis (Gemini CLI)
|
||||
│ ├─ Synthesis and merge
|
||||
│ └─ Write .workflow/project.json
|
||||
└─ Display summary
|
||||
|
||||
Output:
|
||||
└─ .workflow/project.json (+ .backup if regenerate)
|
||||
```
|
||||
|
||||
## Implementation
|
||||
|
||||
### Step 1: Check Existing State
|
||||
### Step 1: Parse Input and Check Existing State
|
||||
|
||||
**Parse --regenerate flag**:
|
||||
```javascript
|
||||
const regenerate = $ARGUMENTS.includes('--regenerate')
|
||||
```
|
||||
|
||||
**Check existing state**:
|
||||
|
||||
```bash
|
||||
bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
|
||||
@@ -59,8 +90,9 @@ Task(
|
||||
prompt=`
|
||||
Analyze project for workflow initialization and generate .workflow/project.json.
|
||||
|
||||
## Output Schema Reference
|
||||
~/.claude/workflows/cli-templates/schemas/project-json-schema.json
|
||||
## MANDATORY FIRST STEPS
|
||||
1. Execute: cat ~/.claude/workflows/cli-templates/schemas/project-json-schema.json (get schema reference)
|
||||
2. Execute: ~/.claude/scripts/get_modules_by_depth.sh (get project structure)
|
||||
|
||||
## Task
|
||||
Generate complete project.json with:
|
||||
|
||||
@@ -138,26 +138,29 @@ If `isPlanJson === false`:
|
||||
|
||||
## Execution Process
|
||||
|
||||
### Workflow Overview
|
||||
|
||||
```
|
||||
Input Processing → Mode Detection
|
||||
|
|
||||
v
|
||||
[Mode 1] --in-memory: Load executionContext → Skip selection
|
||||
[Mode 2] Prompt: Create plan → User selects method + review
|
||||
[Mode 3] File: Detect format → Extract plan OR treat as prompt → User selects
|
||||
|
|
||||
v
|
||||
Execution & Progress Tracking
|
||||
├─ Step 1: Initialize execution tracking
|
||||
├─ Step 2: Create TodoWrite execution list
|
||||
├─ Step 3: Launch execution (Agent or Codex)
|
||||
├─ Step 4: Track execution progress
|
||||
└─ Step 5: Code review (optional)
|
||||
|
|
||||
v
|
||||
Execution Complete
|
||||
Input Parsing:
|
||||
└─ Decision (mode detection):
|
||||
├─ --in-memory flag → Mode 1: Load executionContext → Skip user selection
|
||||
├─ Ends with .md/.json/.txt → Mode 3: Read file → Detect format
|
||||
│ ├─ Valid plan.json → Use planObject → User selects method + review
|
||||
│ └─ Not plan.json → Treat as prompt → User selects method + review
|
||||
└─ Other → Mode 2: Prompt description → User selects method + review
|
||||
|
||||
Execution:
|
||||
├─ Step 1: Initialize result tracking (previousExecutionResults = [])
|
||||
├─ Step 2: Task grouping & batch creation
|
||||
│ ├─ Infer dependencies (same file → sequential, keywords → sequential)
|
||||
│ ├─ Group into batches (parallel: independent, sequential: dependent)
|
||||
│ └─ Create TodoWrite list for batches
|
||||
├─ Step 3: Launch execution
|
||||
│ ├─ Phase 1: All parallel batches (⚡ concurrent via multiple tool calls)
|
||||
│ └─ Phase 2: Sequential batches (→ one by one)
|
||||
├─ Step 4: Track progress (TodoWrite updates per batch)
|
||||
└─ Step 5: Code review (if codeReviewTool ≠ "Skip")
|
||||
|
||||
Output:
|
||||
└─ Execution complete with results in previousExecutionResults[]
|
||||
```
|
||||
|
||||
## Detailed Execution Steps
|
||||
@@ -453,9 +456,16 @@ Complexity: ${planObject.complexity}
|
||||
**Execution with tracking**:
|
||||
```javascript
|
||||
// Launch CLI in foreground (NOT background)
|
||||
// Timeout based on complexity: Low=40min, Medium=60min, High=100min
|
||||
const timeoutByComplexity = {
|
||||
"Low": 2400000, // 40 minutes
|
||||
"Medium": 3600000, // 60 minutes
|
||||
"High": 6000000 // 100 minutes
|
||||
}
|
||||
|
||||
bash_result = Bash(
|
||||
command=cli_command,
|
||||
timeout=6000000
|
||||
timeout=timeoutByComplexity[planObject.complexity] || 3600000
|
||||
)
|
||||
|
||||
// Update TodoWrite when execution completes
|
||||
|
||||
@@ -52,14 +52,42 @@ Fast-track bug fixing workflow optimized for quick diagnosis, targeted fixes, an
|
||||
|
||||
## Execution Process
|
||||
|
||||
### Workflow Overview
|
||||
|
||||
```
|
||||
Bug Input → Diagnosis (Phase 1) → Impact Assessment (Phase 2)
|
||||
↓
|
||||
Severity Auto-Detection → Fix Planning (Phase 3)
|
||||
↓
|
||||
Verification Strategy (Phase 4) → User Confirmation (Phase 5) → Execution (Phase 6)
|
||||
Input Parsing:
|
||||
└─ Parse flags: --hotfix → hotfixMode = true | false
|
||||
|
||||
Phase 1: Diagnosis & Root Cause Analysis
|
||||
└─ Decision (confidence-based):
|
||||
├─ High confidence (specific error) → Direct grep search (5min)
|
||||
├─ Medium confidence → cli-explore-agent focused search (10-15min)
|
||||
└─ Low confidence (vague) → cli-explore-agent broad search (20min)
|
||||
└─ Hotfix mode: Minimal search (Read suspected file + git blame)
|
||||
|
||||
Phase 2: Impact Assessment & Severity Auto-Detection
|
||||
└─ Calculate risk_score → Auto-determine severity
|
||||
├─ ≥8.0 → critical
|
||||
├─ ≥5.0 → high
|
||||
├─ ≥3.0 → medium
|
||||
└─ <3.0 → low
|
||||
└─ Hotfix mode: Skip, assume critical
|
||||
|
||||
Phase 3: Fix Planning & Strategy Selection
|
||||
└─ Decision (by risk score):
|
||||
├─ risk_score ≥5.0 or hotfix → Single best strategy (fastest)
|
||||
└─ risk_score <5.0 → Multiple strategy options for user selection
|
||||
|
||||
Phase 4: Verification Strategy
|
||||
└─ Select test scope by risk score
|
||||
└─ Define branch strategy (feature vs hotfix)
|
||||
|
||||
Phase 5: User Confirmation
|
||||
└─ Default mode: 3 dimensions (approach, execution, verification)
|
||||
└─ Hotfix mode: 2 dimensions (deploy confirmation, monitoring)
|
||||
|
||||
Phase 6: Execution Dispatch
|
||||
├─ Export Enhanced Task JSON
|
||||
├─ Dispatch to lite-execute --in-memory
|
||||
└─ Hotfix mode: Generate follow-up tasks
|
||||
```
|
||||
|
||||
### Phase Summary
|
||||
@@ -77,6 +105,14 @@ Bug Input → Diagnosis (Phase 1) → Impact Assessment (Phase 2)
|
||||
|
||||
## Detailed Phase Execution
|
||||
|
||||
### Input Parsing
|
||||
|
||||
**Parse --hotfix flag**:
|
||||
```javascript
|
||||
const hotfixMode = $ARGUMENTS.includes('--hotfix') || $ARGUMENTS.includes('-h')
|
||||
const bugDescription = $ARGUMENTS.replace(/--hotfix|-h/g, '').trim()
|
||||
```
|
||||
|
||||
### Phase 1: Diagnosis & Root Cause Analysis
|
||||
|
||||
**Goal**: Identify root cause and affected code paths
|
||||
@@ -480,7 +516,6 @@ if (mode === "hotfix") {
|
||||
- Location: ${sessionFolder}/followup.json
|
||||
`)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**TodoWrite**: Mark Phase 6 completed
|
||||
|
||||
@@ -46,6 +46,36 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
|
||||
6. **Task Attachment Model**: SlashCommand invocation **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
|
||||
7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
└─ Convert user input to structured format (GOAL/SCOPE/CONTEXT)
|
||||
|
||||
Phase 1: Session Discovery
|
||||
└─ /workflow:session:start --auto "structured-description"
|
||||
└─ Output: sessionId (WFS-xxx)
|
||||
|
||||
Phase 2: Context Gathering
|
||||
└─ /workflow:tools:context-gather --session sessionId "structured-description"
|
||||
├─ Tasks attached: Analyze structure → Identify integration → Generate package
|
||||
└─ Output: contextPath + conflict_risk
|
||||
|
||||
Phase 3: Conflict Resolution (conditional)
|
||||
└─ Decision (conflict_risk check):
|
||||
├─ conflict_risk ≥ medium → Execute /workflow:tools:conflict-resolution
|
||||
│ ├─ Tasks attached: Detect conflicts → Present to user → Apply strategies
|
||||
│ └─ Output: Modified brainstorm artifacts
|
||||
└─ conflict_risk < medium → Skip to Phase 4
|
||||
|
||||
Phase 4: Task Generation
|
||||
└─ /workflow:tools:task-generate-agent --session sessionId [--cli-execute]
|
||||
└─ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
|
||||
|
||||
Return:
|
||||
└─ Summary with recommended next steps
|
||||
```
|
||||
|
||||
## 5-Phase Execution
|
||||
|
||||
### Phase 1: Session Discovery
|
||||
|
||||
@@ -48,8 +48,54 @@ Intelligently replans workflow sessions or individual tasks with interactive bou
|
||||
/workflow:replan IMPL-1 --interactive
|
||||
```
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session, --interactive
|
||||
└─ Detect mode: task-id present → Task mode | Otherwise → Session mode
|
||||
|
||||
Phase 1: Mode Detection & Session Discovery
|
||||
├─ Detect operation mode (Task vs Session)
|
||||
├─ Discover/validate session (--session flag or auto-detect)
|
||||
└─ Load session context (workflow-session.json, IMPL_PLAN.md, TODO_LIST.md)
|
||||
|
||||
Phase 2: Interactive Requirement Clarification
|
||||
└─ Decision (by mode):
|
||||
├─ Session mode → 3-4 questions (scope, modules, changes, dependencies)
|
||||
└─ Task mode → 2 questions (update type, ripple effect)
|
||||
|
||||
Phase 3: Impact Analysis & Planning
|
||||
├─ Analyze required changes
|
||||
├─ Generate modification plan
|
||||
└─ User confirmation (Execute / Adjust / Cancel)
|
||||
|
||||
Phase 4: Backup Creation
|
||||
└─ Backup all affected files with manifest
|
||||
|
||||
Phase 5: Apply Modifications
|
||||
├─ Update IMPL_PLAN.md (if needed)
|
||||
├─ Update TODO_LIST.md (if needed)
|
||||
├─ Update/Create/Delete task JSONs
|
||||
└─ Update session metadata
|
||||
|
||||
Phase 6: Verification & Summary
|
||||
├─ Validate consistency (JSON validity, task limits, acyclic dependencies)
|
||||
└─ Generate change summary
|
||||
```
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Input Parsing
|
||||
|
||||
**Parse flags**:
|
||||
```javascript
|
||||
const sessionFlag = $ARGUMENTS.match(/--session\s+(\S+)/)?.[1]
|
||||
const interactive = $ARGUMENTS.includes('--interactive')
|
||||
const taskIdMatch = $ARGUMENTS.match(/\b(IMPL-\d+(?:\.\d+)?)\b/)
|
||||
const taskId = taskIdMatch?.[1]
|
||||
```
|
||||
|
||||
### Phase 1: Mode Detection & Session Discovery
|
||||
|
||||
**Process**:
|
||||
@@ -97,11 +143,10 @@ Options: Dynamically generated from existing tasks' focus_paths
|
||||
**Q3: Task Changes** (if scope >= task_restructure)
|
||||
```javascript
|
||||
Options:
|
||||
- 添加新任务
|
||||
- 删除现有任务
|
||||
- 合并任务
|
||||
- 拆分任务
|
||||
- 仅更新内容
|
||||
- 添加/删除任务 (add_remove)
|
||||
- 合并/拆分任务 (merge_split)
|
||||
- 仅更新内容 (update_only)
|
||||
// Note: Max 4 options for AskUserQuestion
|
||||
```
|
||||
|
||||
**Q4: Dependency Changes**
|
||||
|
||||
@@ -29,6 +29,39 @@ argument-hint: "[--type=security|architecture|action-items|quality] [optional: s
|
||||
- For documentation generation, use `/workflow:tools:docs`
|
||||
- For CLAUDE.md updates, use `/update-memory-related`
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse --type flag (default: quality)
|
||||
└─ Parse session-id argument (optional)
|
||||
|
||||
Step 1: Session Resolution
|
||||
└─ Decision:
|
||||
├─ session-id provided → Use provided session
|
||||
└─ Not provided → Auto-detect from .workflow/active/
|
||||
|
||||
Step 2: Validation
|
||||
├─ Check session directory exists
|
||||
└─ Check for completed implementation (.summaries/IMPL-*.md exists)
|
||||
|
||||
Step 3: Type Check
|
||||
└─ Decision:
|
||||
├─ type=docs → Redirect to /workflow:tools:docs
|
||||
└─ Other types → Continue to analysis
|
||||
|
||||
Step 4: Model Analysis Phase
|
||||
├─ Load context (summaries, test results, changed files)
|
||||
└─ Perform specialized review by type:
|
||||
├─ security → Security patterns + Gemini analysis
|
||||
├─ architecture → Qwen architecture analysis
|
||||
├─ quality → Gemini code quality analysis
|
||||
└─ action-items → Requirements verification
|
||||
|
||||
Step 5: Generate Report
|
||||
└─ Output: REVIEW-{type}.md
|
||||
```
|
||||
|
||||
## Execution Template
|
||||
|
||||
```bash
|
||||
|
||||
@@ -23,6 +23,35 @@ No synchronization needed - all views are calculated from current JSON state.
|
||||
/workflow:status --dashboard # Generate HTML dashboard board
|
||||
```
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
└─ Decision (mode detection):
|
||||
├─ --project flag → Project Overview Mode
|
||||
├─ --dashboard flag → Dashboard Mode
|
||||
├─ task-id argument → Task Details Mode
|
||||
└─ No flags → Workflow Session Mode (default)
|
||||
|
||||
Project Overview Mode:
|
||||
├─ Check project.json exists
|
||||
├─ Read project data
|
||||
├─ Parse and display overview + features
|
||||
└─ Show recent archived sessions
|
||||
|
||||
Workflow Session Mode (default):
|
||||
├─ Find active session
|
||||
├─ Load session data
|
||||
├─ Scan task files
|
||||
└─ Display task progress
|
||||
|
||||
Dashboard Mode:
|
||||
├─ Collect active sessions
|
||||
├─ Collect archived sessions
|
||||
├─ Generate HTML from template
|
||||
└─ Write dashboard.html
|
||||
```
|
||||
|
||||
## Implementation Flow
|
||||
|
||||
### Mode Selection
|
||||
|
||||
@@ -18,6 +18,39 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini:*)
|
||||
- Validate TDD cycle execution
|
||||
- Generate compliance report
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
└─ Decision (session argument):
|
||||
├─ session-id provided → Use provided session
|
||||
└─ No session-id → Auto-detect active session
|
||||
|
||||
Phase 1: Session Discovery
|
||||
├─ Validate session directory exists
|
||||
└─ TodoWrite: Mark phase 1 completed
|
||||
|
||||
Phase 2: Task Chain Validation
|
||||
├─ Load all task JSONs from .task/
|
||||
├─ Extract task IDs and group by feature
|
||||
├─ Validate TDD structure:
|
||||
│ ├─ TEST-N.M → IMPL-N.M → REFACTOR-N.M chain
|
||||
│ ├─ Dependency verification
|
||||
│ └─ Meta field validation (tdd_phase, agent)
|
||||
└─ TodoWrite: Mark phase 2 completed
|
||||
|
||||
Phase 3: Test Execution Analysis
|
||||
└─ /workflow:tools:tdd-coverage-analysis
|
||||
├─ Coverage metrics extraction
|
||||
├─ TDD cycle verification
|
||||
└─ Compliance score calculation
|
||||
|
||||
Phase 4: Compliance Report Generation
|
||||
├─ Gemini analysis for comprehensive report
|
||||
├─ Generate TDD_COMPLIANCE_REPORT.md
|
||||
└─ Return summary to user
|
||||
```
|
||||
|
||||
## 4-Phase Execution
|
||||
|
||||
### Phase 1: Session Discovery
|
||||
|
||||
@@ -59,6 +59,41 @@ Analyzes conflicts between implementation plans and existing codebase, **includi
|
||||
- Module merge/split decisions
|
||||
- **Requires iterative clarification until uniqueness confirmed**
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session, --context
|
||||
└─ Validation: Both REQUIRED, conflict_risk >= medium
|
||||
|
||||
Phase 1: Validation
|
||||
├─ Step 1: Verify session directory exists
|
||||
├─ Step 2: Load context-package.json
|
||||
├─ Step 3: Check conflict_risk (skip if none/low)
|
||||
└─ Step 4: Prepare agent task prompt
|
||||
|
||||
Phase 2: CLI-Powered Analysis (Agent)
|
||||
├─ Execute Gemini analysis (Qwen fallback)
|
||||
├─ Detect conflicts including ModuleOverlap category
|
||||
└─ Generate 2-4 strategies per conflict with modifications
|
||||
|
||||
Phase 3: Iterative User Interaction
|
||||
└─ FOR each conflict (one by one):
|
||||
├─ Display conflict with overlap_analysis (if ModuleOverlap)
|
||||
├─ Display strategies (2-4 + custom option)
|
||||
├─ User selects strategy
|
||||
└─ IF clarification_needed:
|
||||
├─ Collect answers
|
||||
├─ Agent re-analysis
|
||||
└─ Loop until uniqueness_confirmed (max 10 rounds)
|
||||
|
||||
Phase 4: Apply Modifications
|
||||
├─ Step 1: Extract modifications from resolved strategies
|
||||
├─ Step 2: Apply using Edit tool
|
||||
├─ Step 3: Update context-package.json (mark resolved)
|
||||
└─ Step 4: Output custom conflict summary (if any)
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Phase 1: Validation
|
||||
|
||||
@@ -24,6 +24,38 @@ Orchestrator command that invokes `context-search-agent` to gather comprehensive
|
||||
- **Plan Mode**: Full comprehensive analysis (vs lightweight brainstorm mode)
|
||||
- **Standardized Output**: Generate `.workflow/active/{session}/.process/context-package.json`
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session
|
||||
└─ Parse: task_description (required)
|
||||
|
||||
Step 1: Context-Package Detection
|
||||
└─ Decision (existing package):
|
||||
├─ Valid package exists → Return existing (skip execution)
|
||||
└─ No valid package → Continue to Step 2
|
||||
|
||||
Step 2: Invoke Context-Search Agent
|
||||
├─ Phase 1: Initialization & Pre-Analysis
|
||||
│ ├─ Load project.json as primary context
|
||||
│ ├─ Initialize code-index
|
||||
│ └─ Classify complexity
|
||||
├─ Phase 2: Multi-Source Discovery
|
||||
│ ├─ Track 1: Historical archive analysis
|
||||
│ ├─ Track 2: Reference documentation
|
||||
│ ├─ Track 3: Web examples (Exa MCP)
|
||||
│ └─ Track 4: Codebase analysis (5-layer)
|
||||
└─ Phase 3: Synthesis & Packaging
|
||||
├─ Apply relevance scoring
|
||||
├─ Integrate brainstorm artifacts
|
||||
├─ Perform conflict detection
|
||||
└─ Generate context-package.json
|
||||
|
||||
Step 3: Output Verification
|
||||
└─ Verify context-package.json created
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Step 1: Context-Package Detection
|
||||
|
||||
@@ -22,6 +22,24 @@ Generate implementation planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.
|
||||
- **MCP-Enhanced**: Use MCP tools for advanced code analysis and research
|
||||
- **Path Clarity**: All `focus_paths` prefer absolute paths (e.g., `D:\\project\\src\\module`), or clear relative paths from project root (e.g., `./src/module`)
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session, --cli-execute
|
||||
└─ Validation: session_id REQUIRED
|
||||
|
||||
Phase 1: Context Preparation (Command)
|
||||
├─ Assemble session paths (metadata, context package, output dirs)
|
||||
└─ Provide metadata (session_id, execution_mode, mcp_capabilities)
|
||||
|
||||
Phase 2: Planning Document Generation (Agent)
|
||||
├─ Load context package (progressive loading strategy)
|
||||
├─ Generate Task JSON Files (.task/IMPL-*.json)
|
||||
├─ Create IMPL_PLAN.md
|
||||
└─ Generate TODO_LIST.md
|
||||
```
|
||||
|
||||
## Document Generation Lifecycle
|
||||
|
||||
### Phase 1: Context Preparation (Command Responsibility)
|
||||
|
||||
@@ -53,6 +53,30 @@ Autonomous TDD task JSON and IMPL_PLAN.md generation using action-planning-agent
|
||||
- **Current approach**: 1 feature = 1 task (IMPL-N with internal Red-Green-Refactor phases)
|
||||
- **Complex features**: 1 container (IMPL-N) + subtasks (IMPL-N.M) when necessary
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session, --cli-execute
|
||||
└─ Validation: session_id REQUIRED
|
||||
|
||||
Phase 1: Discovery & Context Loading (Memory-First)
|
||||
├─ Load session context (if not in memory)
|
||||
├─ Load context package (if not in memory)
|
||||
├─ Load test context package (if not in memory)
|
||||
├─ Extract & load role analyses from context package
|
||||
├─ Load conflict resolution (if exists)
|
||||
└─ Optional: MCP external research
|
||||
|
||||
Phase 2: Agent Execution (Document Generation)
|
||||
├─ Pre-agent template selection (agent-mode OR cli-execute-mode)
|
||||
├─ Invoke action-planning-agent
|
||||
├─ Generate TDD Task JSON Files (.task/IMPL-*.json)
|
||||
│ └─ Each task: complete Red-Green-Refactor cycle internally
|
||||
├─ Create IMPL_PLAN.md (TDD variant)
|
||||
└─ Generate TODO_LIST.md with TDD phase indicators
|
||||
```
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Phase 1: Discovery & Context Loading
|
||||
|
||||
@@ -17,6 +17,38 @@ Analyze test coverage and verify Red-Green-Refactor cycle execution for TDD work
|
||||
- Verify TDD cycle execution (Red -> Green -> Refactor)
|
||||
- Generate coverage and cycle reports
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session
|
||||
└─ Validation: session_id REQUIRED
|
||||
|
||||
Phase 1: Extract Test Tasks
|
||||
└─ Find TEST-*.json files and extract focus_paths
|
||||
|
||||
Phase 2: Run Test Suite
|
||||
└─ Decision (test framework):
|
||||
├─ Node.js → npm test --coverage --json
|
||||
├─ Python → pytest --cov --json-report
|
||||
└─ Other → [test_command] --coverage --json
|
||||
|
||||
Phase 3: Parse Coverage Data
|
||||
├─ Extract line coverage percentage
|
||||
├─ Extract branch coverage percentage
|
||||
├─ Extract function coverage percentage
|
||||
└─ Identify uncovered lines/branches
|
||||
|
||||
Phase 4: Verify TDD Cycle
|
||||
└─ FOR each TDD chain (TEST-N.M → IMPL-N.M → REFACTOR-N.M):
|
||||
├─ Red Phase: Verify tests created and failed initially
|
||||
├─ Green Phase: Verify tests now pass
|
||||
└─ Refactor Phase: Verify code quality improved
|
||||
|
||||
Phase 5: Generate Analysis Report
|
||||
└─ Create tdd-cycle-report.md with coverage metrics and cycle verification
|
||||
```
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Phase 1: Extract Test Tasks
|
||||
|
||||
@@ -24,6 +24,29 @@ Workflow coordinator that delegates test analysis to cli-execution-agent. Agent
|
||||
- Execute Gemini analysis via agent for test strategy generation
|
||||
- Validate agent outputs (gemini-test-analysis.md, TEST_ANALYSIS_RESULTS.md)
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session, --context
|
||||
└─ Validation: Both REQUIRED
|
||||
|
||||
Phase 1: Context Preparation (Command)
|
||||
├─ Load workflow-session.json
|
||||
├─ Verify test session type is "test-gen"
|
||||
├─ Validate test-context-package.json
|
||||
└─ Determine strategy (Simple: 1-3 files | Medium: 4-6 | Complex: >6)
|
||||
|
||||
Phase 2: Test Analysis Execution (Agent)
|
||||
├─ Execute Gemini analysis via cli-execution-agent
|
||||
└─ Generate TEST_ANALYSIS_RESULTS.md
|
||||
|
||||
Phase 3: Output Validation (Command)
|
||||
├─ Verify gemini-test-analysis.md exists
|
||||
├─ Validate TEST_ANALYSIS_RESULTS.md
|
||||
└─ Confirm test requirements are actionable
|
||||
```
|
||||
|
||||
## Execution Lifecycle
|
||||
|
||||
### Phase 1: Context Preparation (Command Responsibility)
|
||||
|
||||
@@ -24,6 +24,36 @@ Orchestrator command that invokes `test-context-search-agent` to gather comprehe
|
||||
- **Source Context Loading**: Import implementation summaries from source session
|
||||
- **Standardized Output**: Generate `.workflow/active/{test_session_id}/.process/test-context-package.json`
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session
|
||||
└─ Validation: test_session_id REQUIRED
|
||||
|
||||
Step 1: Test-Context-Package Detection
|
||||
└─ Decision (existing package):
|
||||
├─ Valid package exists → Return existing (skip execution)
|
||||
└─ No valid package → Continue to Step 2
|
||||
|
||||
Step 2: Invoke Test-Context-Search Agent
|
||||
├─ Phase 1: Session Validation & Source Context Loading
|
||||
│ ├─ Detection: Check for existing test-context-package
|
||||
│ ├─ Test session validation
|
||||
│ └─ Source context loading (summaries, changed files)
|
||||
├─ Phase 2: Test Coverage Analysis
|
||||
│ ├─ Track 1: Existing test discovery
|
||||
│ ├─ Track 2: Coverage gap analysis
|
||||
│ └─ Track 3: Coverage statistics
|
||||
└─ Phase 3: Framework Detection & Packaging
|
||||
├─ Framework identification
|
||||
├─ Convention analysis
|
||||
└─ Generate test-context-package.json
|
||||
|
||||
Step 3: Output Verification
|
||||
└─ Verify test-context-package.json created
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Step 1: Test-Context-Package Detection
|
||||
|
||||
@@ -32,6 +32,29 @@ Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) u
|
||||
- **Manual Mode** (default): Gemini diagnosis → user applies fixes
|
||||
- **Codex Mode** (`--use-codex`): Gemini diagnosis → Codex applies fixes with resume mechanism
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session, --use-codex, --cli-execute
|
||||
└─ Validation: session_id REQUIRED
|
||||
|
||||
Phase 1: Context Preparation (Command)
|
||||
├─ Assemble test session paths
|
||||
│ ├─ session_metadata_path
|
||||
│ ├─ test_analysis_results_path (REQUIRED)
|
||||
│ └─ test_context_package_path
|
||||
└─ Provide metadata (session_id, execution_mode, use_codex, source_session_id)
|
||||
|
||||
Phase 2: Test Document Generation (Agent)
|
||||
├─ Load TEST_ANALYSIS_RESULTS.md as primary requirements source
|
||||
├─ Generate Test Task JSON Files (.task/IMPL-*.json)
|
||||
│ ├─ IMPL-001: Test generation (meta.type: "test-gen")
|
||||
│ └─ IMPL-002+: Test execution & fix (meta.type: "test-fix")
|
||||
├─ Create IMPL_PLAN.md (test_session variant)
|
||||
└─ Generate TODO_LIST.md with test phase indicators
|
||||
```
|
||||
|
||||
## Document Generation Lifecycle
|
||||
|
||||
### Phase 1: Context Preparation (Command Responsibility)
|
||||
|
||||
@@ -23,6 +23,44 @@ Extract animation and transition patterns from prompt inference and image refere
|
||||
- **Production-Ready**: CSS var() format, WCAG-compliant, semantic naming
|
||||
- **Default Behavior**: Non-interactive mode uses inferred patterns + best practices
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --design-id, --session, --images, --focus, --interactive, --refine
|
||||
└─ Decision (mode detection):
|
||||
├─ --refine flag → Refinement Mode
|
||||
└─ No --refine → Exploration Mode
|
||||
|
||||
Phase 0: Setup & Input Validation
|
||||
├─ Step 1: Detect input mode & base path
|
||||
├─ Step 2: Prepare image references (if available)
|
||||
├─ Step 3: Load design tokens context
|
||||
└─ Step 4: Memory check (skip if exists)
|
||||
|
||||
Phase 1: Animation Specification Generation
|
||||
├─ Step 1: Load project context
|
||||
├─ Step 2: Generate animation specification options (Agent Task 1)
|
||||
│ └─ Decision:
|
||||
│ ├─ Exploration Mode → Generate specification questions
|
||||
│ └─ Refinement Mode → Generate refinement options
|
||||
└─ Step 3: Verify options file created
|
||||
|
||||
Phase 1.5: User Confirmation (Optional)
|
||||
└─ Decision (--interactive flag):
|
||||
├─ --interactive present → Present options, capture selection
|
||||
└─ No --interactive → Skip to Phase 2
|
||||
|
||||
Phase 2: Animation System Generation
|
||||
├─ Step 1: Load user selection or use defaults
|
||||
├─ Step 2: Create output directory
|
||||
└─ Step 3: Launch animation generation task (Agent Task 2)
|
||||
|
||||
Phase 3: Verify Output
|
||||
├─ Step 1: Check files created
|
||||
└─ Step 2: Verify file sizes
|
||||
```
|
||||
|
||||
## Phase 0: Setup & Input Validation
|
||||
|
||||
### Step 1: Detect Input Mode & Base Path
|
||||
|
||||
@@ -19,6 +19,48 @@ Synchronize finalized design system references to brainstorming artifacts, prepa
|
||||
- **Plan-Ready Output**: Ensure design artifacts discoverable by task-generate
|
||||
- **Minimal Reading**: Verify file existence, don't read design content
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --session, --selected-prototypes
|
||||
└─ Validation: session_id REQUIRED
|
||||
|
||||
Phase 1: Session & Artifact Validation
|
||||
├─ Step 1: Validate session exists
|
||||
├─ Step 2: Find latest design run
|
||||
├─ Step 3: Detect design system structure
|
||||
└─ Step 4: Select prototypes (--selected-prototypes OR all)
|
||||
|
||||
Phase 1.1: Memory Check (Conditional)
|
||||
└─ Decision (current design run in synthesis):
|
||||
├─ Already updated → Skip Phase 2-5, EXIT
|
||||
└─ Not found → Continue to Phase 2
|
||||
|
||||
Phase 2: Load Target Artifacts
|
||||
├─ Read role analysis documents (files to update)
|
||||
├─ Read ui-designer/analysis.md (if exists)
|
||||
└─ Read prototype notes (minimal context)
|
||||
|
||||
Phase 3: Update Synthesis Specification
|
||||
└─ Edit role analysis documents with UI/UX Guidelines section
|
||||
|
||||
Phase 4A: Update Relevant Role Analysis Documents
|
||||
├─ ui-designer/analysis.md (always)
|
||||
├─ ux-expert/analysis.md (if animations exist)
|
||||
├─ system-architect/analysis.md (if layouts exist)
|
||||
└─ product-manager/analysis.md (if prototypes)
|
||||
|
||||
Phase 4B: Create UI Designer Design System Reference
|
||||
└─ Write ui-designer/design-system-reference.md
|
||||
|
||||
Phase 5: Update Context Package
|
||||
└─ Update context-package.json with design system references
|
||||
|
||||
Phase 6: Completion
|
||||
└─ Report updated artifacts
|
||||
```
|
||||
|
||||
## Execution Protocol
|
||||
|
||||
### Phase 1: Session & Artifact Validation
|
||||
|
||||
@@ -40,6 +40,51 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*
|
||||
|
||||
**Target Type Detection**: Automatically inferred from prompt/targets, or explicitly set via `--target-type`.
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --input, --targets, --target-type, --device-type, --session, --style-variants, --layout-variants
|
||||
└─ Decision (input detection):
|
||||
├─ Contains * or glob matches → images_input (visual)
|
||||
├─ File/directory exists → code import source
|
||||
└─ Pure text → design prompt
|
||||
|
||||
Phase 1-4: Parameter Parsing & Initialization
|
||||
├─ Phase 1: Normalize parameters (legacy deprecation warning)
|
||||
├─ Phase 2: Intelligent prompt parsing (extract variant counts)
|
||||
├─ Phase 3: Device type inference (explicit > keywords > target_type > default)
|
||||
└─ Phase 4: Run initialization and directory setup
|
||||
|
||||
Phase 5: Unified Target Inference
|
||||
├─ Priority: --pages/--components (legacy) → --targets → prompt analysis → synthesis → default
|
||||
├─ Display confirmation with modification options
|
||||
└─ User confirms → IMMEDIATELY triggers Phase 7
|
||||
|
||||
Phase 6: Code Import (Conditional)
|
||||
└─ Decision (design_source):
|
||||
├─ code_only | hybrid → Execute /workflow:ui-design:import-from-code
|
||||
└─ visual_only → Skip to Phase 7
|
||||
|
||||
Phase 7: Style Extraction
|
||||
└─ Decision (needs_visual_supplement):
|
||||
├─ visual_only OR supplement needed → Execute /workflow:ui-design:style-extract
|
||||
└─ code_only AND style_complete → Use code import
|
||||
|
||||
Phase 8: Animation Extraction
|
||||
└─ Decision (should_extract_animation):
|
||||
├─ visual_only OR incomplete OR regenerate → Execute /workflow:ui-design:animation-extract
|
||||
└─ code_only AND animation_complete → Use code import
|
||||
|
||||
Phase 9: Layout Extraction
|
||||
└─ Decision (needs_visual_supplement OR NOT layout_complete):
|
||||
├─ True → Execute /workflow:ui-design:layout-extract
|
||||
└─ False → Use code import
|
||||
|
||||
Phase 10: UI Assembly
|
||||
└─ Execute /workflow:ui-design:generate → Workflow complete
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
1. **Start Immediately**: TodoWrite initialization → Phase 7 execution
|
||||
|
||||
@@ -21,6 +21,36 @@ Pure assembler that combines pre-extracted layout templates with design tokens t
|
||||
- `/workflow:ui-design:style-extract` → Complete design systems (design-tokens.json + style-guide.md)
|
||||
- `/workflow:ui-design:layout-extract` → Layout structure
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --design-id, --session
|
||||
└─ Decision (base path resolution):
|
||||
├─ --design-id provided → Exact match by design ID
|
||||
├─ --session provided → Latest in session
|
||||
└─ No flags → Latest globally
|
||||
|
||||
Phase 1: Setup & Validation
|
||||
├─ Step 1: Resolve base path & parse configuration
|
||||
├─ Step 2: Load layout templates
|
||||
├─ Step 3: Validate design tokens
|
||||
└─ Step 4: Load animation tokens (optional)
|
||||
|
||||
Phase 2: Assembly (Agent)
|
||||
├─ Step 1: Calculate agent grouping plan
|
||||
│ └─ Grouping rules:
|
||||
│ ├─ Style isolation: Each agent processes ONE style
|
||||
│ ├─ Balanced distribution: Layouts evenly split
|
||||
│ └─ Max 10 layouts per agent, max 6 concurrent agents
|
||||
├─ Step 2: Launch batched assembly tasks (parallel)
|
||||
└─ Step 3: Verify generated files
|
||||
|
||||
Phase 3: Generate Preview Files
|
||||
├─ Step 1: Run preview generation script
|
||||
└─ Step 2: Verify preview files
|
||||
```
|
||||
|
||||
## Phase 1: Setup & Validation
|
||||
|
||||
### Step 1: Resolve Base Path & Parse Configuration
|
||||
|
||||
@@ -36,6 +36,50 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*)
|
||||
|
||||
**Task Attachment Model**: SlashCommand invocation is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --input, --session (legacy: --images, --prompt)
|
||||
└─ Decision (input detection):
|
||||
├─ Contains * or glob matches → images_input (visual)
|
||||
├─ File/directory exists → code import source
|
||||
└─ Pure text → design prompt
|
||||
|
||||
Phase 0: Parameter Parsing & Input Detection
|
||||
├─ Step 1: Normalize parameters (legacy deprecation warning)
|
||||
├─ Step 2: Detect design source (hybrid | code_only | visual_only)
|
||||
└─ Step 3: Initialize directories and metadata
|
||||
|
||||
Phase 0.5: Code Import (Conditional)
|
||||
└─ Decision (design_source):
|
||||
├─ hybrid → Execute /workflow:ui-design:import-from-code
|
||||
└─ Other → Skip to Phase 2
|
||||
|
||||
Phase 2: Style Extraction
|
||||
└─ Decision (skip_style):
|
||||
├─ code_only AND style_complete → Use code import
|
||||
└─ Otherwise → Execute /workflow:ui-design:style-extract
|
||||
|
||||
Phase 2.3: Animation Extraction
|
||||
└─ Decision (skip_animation):
|
||||
├─ code_only AND animation_complete → Use code import
|
||||
└─ Otherwise → Execute /workflow:ui-design:animation-extract
|
||||
|
||||
Phase 2.5: Layout Extraction
|
||||
└─ Decision (skip_layout):
|
||||
├─ code_only AND layout_complete → Use code import
|
||||
└─ Otherwise → Execute /workflow:ui-design:layout-extract
|
||||
|
||||
Phase 3: UI Assembly
|
||||
└─ Execute /workflow:ui-design:generate
|
||||
|
||||
Phase 4: Design System Integration
|
||||
└─ Decision (session_id):
|
||||
├─ Provided → Execute /workflow:ui-design:update
|
||||
└─ Not provided → Standalone completion
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
1. **Start Immediately**: TodoWrite initialization → Phase 2 execution
|
||||
|
||||
@@ -43,6 +43,25 @@ Extract design system tokens from source code files (CSS/SCSS/JS/TS/HTML) using
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --design-id, --session, --source
|
||||
└─ Decision (base path resolution):
|
||||
├─ --design-id provided → Exact match by design ID
|
||||
├─ --session provided → Latest design run in session
|
||||
└─ Neither → ERROR: Must provide --design-id or --session
|
||||
|
||||
Phase 0: Setup & File Discovery
|
||||
├─ Step 1: Resolve base path
|
||||
├─ Step 2: Initialize directories
|
||||
└─ Step 3: Discover files using script
|
||||
|
||||
Phase 1: Parallel Agent Analysis (3 agents)
|
||||
├─ Style Agent → design-tokens.json + code_snippets
|
||||
├─ Animation Agent → animation-tokens.json + code_snippets
|
||||
└─ Layout Agent → layout-templates.json + code_snippets
|
||||
```
|
||||
|
||||
### Step 1: Setup & File Discovery
|
||||
|
||||
**Purpose**: Initialize session, discover and categorize code files
|
||||
|
||||
@@ -23,6 +23,39 @@ This command separates the "scaffolding" (HTML structure and CSS layout) from th
|
||||
- **Device-Aware**: Optimized for specific device types (desktop, mobile, tablet, responsive)
|
||||
- **Token-Based**: CSS uses `var()` placeholders for spacing and breakpoints
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --design-id, --session, --images, --prompt, --targets, --variants, --device-type, --interactive, --refine
|
||||
└─ Decision (mode detection):
|
||||
├─ --refine flag → Refinement Mode (variants_count = 1)
|
||||
└─ No --refine → Exploration Mode (variants_count = --variants OR 3)
|
||||
|
||||
Phase 0: Setup & Input Validation
|
||||
├─ Step 1: Detect input, mode & targets
|
||||
├─ Step 2: Load inputs & create directories
|
||||
└─ Step 3: Memory check (skip if cached)
|
||||
|
||||
Phase 1: Layout Concept/Refinement Options Generation
|
||||
├─ Step 0.5: Load existing layout (Refinement Mode only)
|
||||
├─ Step 1: Generate options (Agent Task 1)
|
||||
│ └─ Decision:
|
||||
│ ├─ Exploration Mode → Generate contrasting layout concepts
|
||||
│ └─ Refinement Mode → Generate refinement options
|
||||
└─ Step 2: Verify options file created
|
||||
|
||||
Phase 1.5: User Confirmation (Optional)
|
||||
└─ Decision (--interactive flag):
|
||||
├─ --interactive present → Present options, capture selection
|
||||
└─ No --interactive → Skip to Phase 2
|
||||
|
||||
Phase 2: Layout Template Generation
|
||||
├─ Step 1: Load user selections or default to all
|
||||
├─ Step 2: Launch parallel agent tasks
|
||||
└─ Step 3: Verify output files
|
||||
```
|
||||
|
||||
## Phase 0: Setup & Input Validation
|
||||
|
||||
### Step 1: Detect Input, Mode & Targets
|
||||
|
||||
@@ -33,6 +33,29 @@ Converts design run extraction results into shareable reference package with:
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --design-run, --package-name, --output-dir
|
||||
└─ Validation:
|
||||
├─ --design-run and --package-name REQUIRED
|
||||
└─ Package name format: lowercase, alphanumeric, hyphens only
|
||||
|
||||
Phase 0: Setup & Validation
|
||||
├─ Step 1: Validate required parameters
|
||||
├─ Step 2: Validate package name format
|
||||
├─ Step 3: Validate design run exists
|
||||
├─ Step 4: Check required extraction files (design-tokens.json, layout-templates.json)
|
||||
└─ Step 5: Setup output directory
|
||||
|
||||
Phase 1: Prepare Component Data
|
||||
├─ Step 1: Copy layout templates
|
||||
├─ Step 2: Copy design tokens
|
||||
└─ Step 3: Copy animation tokens (optional)
|
||||
|
||||
Phase 2: Preview Generation (Agent)
|
||||
└─ Generate preview.html + preview.css via ui-design-agent
|
||||
```
|
||||
|
||||
### Phase 0: Setup & Validation
|
||||
|
||||
**Purpose**: Validate inputs, prepare output directory
|
||||
|
||||
@@ -19,6 +19,43 @@ Extract design style from reference images or text prompts using Claude's built-
|
||||
- **Dual Mode**: Exploration (multiple contrasting variants) or Refinement (single design fine-tuning)
|
||||
- **Production-Ready**: WCAG AA compliant, OKLCH colors, semantic naming
|
||||
|
||||
## Execution Process
|
||||
|
||||
```
|
||||
Input Parsing:
|
||||
├─ Parse flags: --design-id, --session, --images, --prompt, --variants, --interactive, --refine
|
||||
└─ Decision (mode detection):
|
||||
├─ --refine flag → Refinement Mode (variants_count = 1)
|
||||
└─ No --refine → Exploration Mode (variants_count = --variants OR 3)
|
||||
|
||||
Phase 0: Setup & Input Validation
|
||||
├─ Step 1: Detect input mode, extraction mode & base path
|
||||
├─ Step 2: Load inputs
|
||||
└─ Step 3: Memory check (skip if exists)
|
||||
|
||||
Phase 1: Design Direction/Refinement Options Generation
|
||||
├─ Step 1: Load project context
|
||||
├─ Step 2: Generate options (Agent Task 1)
|
||||
│ └─ Decision:
|
||||
│ ├─ Exploration Mode → Generate contrasting design directions
|
||||
│ └─ Refinement Mode → Generate refinement options
|
||||
└─ Step 3: Verify options file created
|
||||
|
||||
Phase 1.5: User Confirmation (Optional)
|
||||
└─ Decision (--interactive flag):
|
||||
├─ --interactive present → Present options, capture selection
|
||||
└─ No --interactive → Skip to Phase 2
|
||||
|
||||
Phase 2: Design System Generation
|
||||
├─ Step 1: Load user selection or default to all
|
||||
├─ Step 2: Create output directories
|
||||
└─ Step 3: Launch agent tasks (parallel)
|
||||
|
||||
Phase 3: Verify Output
|
||||
├─ Step 1: Check files created
|
||||
└─ Step 2: Verify file sizes
|
||||
```
|
||||
|
||||
## Phase 0: Setup & Input Validation
|
||||
|
||||
### Step 1: Detect Input Mode, Extraction Mode & Base Path
|
||||
|
||||
Reference in New Issue
Block a user