mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-15 02:42:45 +08:00
Compare commits
5 Commits
claude/ana
...
claude/opt
| Author | SHA1 | Date | |
|---|---|---|---|
|
d8ead86b67 | ||
|
fc965c87d7 | ||
|
|
50a36ded97 | ||
|
|
c5a0f635f4 | ||
|
|
ca9653c2e6 |
@@ -89,7 +89,7 @@ bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${proj
|
||||
bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${project_name} -type f -name "*.md" ! -path "*/README.md" ! -path "*/ARCHITECTURE.md" ! -path "*/EXAMPLES.md" ! -path "*/api/*" 2>/dev/null | xargs cat 2>/dev/null; fi)
|
||||
```
|
||||
|
||||
**Data Processing**: Parse bash outputs, calculate statistics, use **Write tool** to create `${session_dir}/.process/phase2-analysis.json` with structure:
|
||||
**Data Processing**: Parse bash outputs, calculate statistics, use **Write tool** to create `${session_dir}/.process/doc-planning-data.json` with structure:
|
||||
|
||||
```json
|
||||
{
|
||||
@@ -118,7 +118,7 @@ bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${proj
|
||||
|
||||
**Then** use **Edit tool** to update `workflow-session.json` adding analysis field.
|
||||
|
||||
**Output**: Single `phase2-analysis.json` with all analysis data (no temp files or Python scripts).
|
||||
**Output**: Single `doc-planning-data.json` with all analysis data (no temp files or Python scripts).
|
||||
|
||||
**Auto-skipped**: Tests (`**/test/**`, `**/*.test.*`), Build (`**/node_modules/**`, `**/dist/**`), Config (root-level files), Vendor directories.
|
||||
|
||||
@@ -127,8 +127,8 @@ bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${proj
|
||||
**Commands**:
|
||||
|
||||
```bash
|
||||
# Count existing docs from phase2-analysis.json
|
||||
bash(cat .workflow/active/WFS-docs-{timestamp}/.process/phase2-analysis.json | jq '.existing_docs.file_list | length')
|
||||
# Count existing docs from doc-planning-data.json
|
||||
bash(cat .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq '.existing_docs.file_list | length')
|
||||
```
|
||||
|
||||
**Data Processing**: Use count result, then use **Edit tool** to update `workflow-session.json`:
|
||||
@@ -182,8 +182,8 @@ Large Projects (single dir >10 docs):
|
||||
**Commands**:
|
||||
|
||||
```bash
|
||||
# 1. Get top-level directories from phase2-analysis.json
|
||||
bash(cat .workflow/active/WFS-docs-{timestamp}/.process/phase2-analysis.json | jq -r '.top_level_dirs[]')
|
||||
# 1. Get top-level directories from doc-planning-data.json
|
||||
bash(cat .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq -r '.top_level_dirs[]')
|
||||
|
||||
# 2. Get mode from workflow-session.json
|
||||
bash(cat .workflow/active/WFS-docs-{timestamp}/workflow-session.json | jq -r '.mode // "full"')
|
||||
@@ -201,7 +201,7 @@ bash(grep -r "router\.|@Get\|@Post" src/ 2>/dev/null && echo "API_FOUND" || echo
|
||||
- If total ≤10 docs: create group
|
||||
- If total >10 docs: split to 1 dir/group or subdivide
|
||||
- If single dir >10 docs: split by subdirectories
|
||||
3. Use **Edit tool** to update `phase2-analysis.json` adding groups field:
|
||||
3. Use **Edit tool** to update `doc-planning-data.json` adding groups field:
|
||||
```json
|
||||
"groups": {
|
||||
"count": 3,
|
||||
@@ -215,7 +215,7 @@ bash(grep -r "router\.|@Get\|@Post" src/ 2>/dev/null && echo "API_FOUND" || echo
|
||||
|
||||
**Task ID Calculation**:
|
||||
```bash
|
||||
group_count=$(jq '.groups.count' .workflow/active/WFS-docs-{timestamp}/.process/phase2-analysis.json)
|
||||
group_count=$(jq '.groups.count' .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json)
|
||||
readme_id=$((group_count + 1)) # Next ID after groups
|
||||
arch_id=$((group_count + 2))
|
||||
api_id=$((group_count + 3))
|
||||
@@ -237,7 +237,7 @@ api_id=$((group_count + 3))
|
||||
|
||||
**Generation Process**:
|
||||
1. Read configuration values (tool, cli_execute, mode) from workflow-session.json
|
||||
2. Read group assignments from phase2-analysis.json
|
||||
2. Read group assignments from doc-planning-data.json
|
||||
3. Generate Level 1 tasks (IMPL-001 to IMPL-N, one per group)
|
||||
4. Generate Level 2+ tasks if mode=full (README, ARCHITECTURE, HTTP API)
|
||||
|
||||
@@ -262,14 +262,14 @@ api_id=$((group_count + 3))
|
||||
},
|
||||
"context": {
|
||||
"requirements": [
|
||||
"Process directories from group ${group_number} in phase2-analysis.json",
|
||||
"Process directories from group ${group_number} in doc-planning-data.json",
|
||||
"Generate docs to .workflow/docs/${project_name}/ (mirrored structure)",
|
||||
"Code folders: API.md + README.md; Navigation folders: README.md only",
|
||||
"Use pre-analyzed data from Phase 2 (no redundant analysis)"
|
||||
],
|
||||
"focus_paths": ["${group_dirs_from_json}"],
|
||||
"precomputed_data": {
|
||||
"phase2_analysis": "${session_dir}/.process/phase2-analysis.json"
|
||||
"phase2_analysis": "${session_dir}/.process/doc-planning-data.json"
|
||||
}
|
||||
},
|
||||
"flow_control": {
|
||||
@@ -278,8 +278,8 @@ api_id=$((group_count + 3))
|
||||
"step": "load_precomputed_data",
|
||||
"action": "Load Phase 2 analysis and extract group directories",
|
||||
"commands": [
|
||||
"bash(cat ${session_dir}/.process/phase2-analysis.json)",
|
||||
"bash(jq '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories' ${session_dir}/.process/phase2-analysis.json)"
|
||||
"bash(cat ${session_dir}/.process/doc-planning-data.json)",
|
||||
"bash(jq '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories' ${session_dir}/.process/doc-planning-data.json)"
|
||||
],
|
||||
"output_to": "phase2_context",
|
||||
"note": "Single JSON file contains all Phase 2 analysis results"
|
||||
@@ -324,7 +324,7 @@ api_id=$((group_count + 3))
|
||||
{
|
||||
"step": 2,
|
||||
"title": "Batch generate documentation via CLI",
|
||||
"command": "bash(dirs=$(jq -r '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories[]' ${session_dir}/.process/phase2-analysis.json); for dir in $dirs; do cd \"$dir\" && gemini --approval-mode yolo -p \"PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure\" || echo \"Failed: $dir\"; cd -; done)",
|
||||
"command": "bash(dirs=$(jq -r '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories[]' ${session_dir}/.process/doc-planning-data.json); for dir in $dirs; do cd \"$dir\" && gemini --approval-mode yolo -p \"PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure\" || echo \"Failed: $dir\"; cd -; done)",
|
||||
"depends_on": [1],
|
||||
"output": "generated_docs"
|
||||
}
|
||||
@@ -464,7 +464,7 @@ api_id=$((group_count + 3))
|
||||
├── IMPL_PLAN.md
|
||||
├── TODO_LIST.md
|
||||
├── .process/
|
||||
│ └── phase2-analysis.json # All Phase 2 analysis data (replaces 7+ files)
|
||||
│ └── doc-planning-data.json # All Phase 2 analysis data (replaces 7+ files)
|
||||
└── .task/
|
||||
├── IMPL-001.json # Small: all modules | Large: group 1
|
||||
├── IMPL-00N.json # (Large only: groups 2-N)
|
||||
@@ -473,7 +473,7 @@ api_id=$((group_count + 3))
|
||||
└── IMPL-{N+3}.json # HTTP API (optional)
|
||||
```
|
||||
|
||||
**phase2-analysis.json Structure**:
|
||||
**doc-planning-data.json Structure**:
|
||||
```json
|
||||
{
|
||||
"metadata": {
|
||||
|
||||
@@ -1,652 +0,0 @@
|
||||
---
|
||||
name: lite-fix
|
||||
description: Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents
|
||||
argument-hint: "[--hotfix] \"bug description or issue reference\""
|
||||
allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Read(*), Bash(*)
|
||||
---
|
||||
|
||||
# Workflow Lite-Fix Command (/workflow:lite-fix)
|
||||
|
||||
## Overview
|
||||
|
||||
Fast-track bug fixing workflow optimized for quick diagnosis, targeted fixes, and streamlined verification. Automatically adjusts process complexity based on impact assessment.
|
||||
|
||||
**Core capabilities:**
|
||||
- Rapid root cause diagnosis with intelligent code search
|
||||
- Automatic severity assessment and adaptive workflow
|
||||
- Fix strategy selection (immediate patch vs comprehensive refactor)
|
||||
- Risk-aware verification (smoke tests to full suite)
|
||||
- Optional hotfix mode for production incidents with branch management
|
||||
- Automatic follow-up task generation for hotfixes
|
||||
|
||||
## Usage
|
||||
|
||||
### Command Syntax
|
||||
```bash
|
||||
/workflow:lite-fix [FLAGS] <BUG_DESCRIPTION>
|
||||
|
||||
# Flags
|
||||
--hotfix, -h Production hotfix mode (creates hotfix branch, auto follow-up)
|
||||
|
||||
# Arguments
|
||||
<bug-description> Bug description or issue reference (required)
|
||||
```
|
||||
|
||||
### Modes
|
||||
|
||||
| Mode | Time Budget | Use Case | Workflow Characteristics |
|
||||
|------|-------------|----------|--------------------------|
|
||||
| **Default** | Auto-adapt (15min-4h) | All standard bugs | Intelligent severity assessment + adaptive process |
|
||||
| **Hotfix** (`--hotfix`) | 15-30 min | Production outage | Minimal diagnosis + hotfix branch + auto follow-up |
|
||||
|
||||
### Examples
|
||||
|
||||
```bash
|
||||
# Default mode: Automatically adjusts based on impact
|
||||
/workflow:lite-fix "User avatar upload fails with 413 error"
|
||||
/workflow:lite-fix "Shopping cart randomly loses items at checkout"
|
||||
|
||||
# Hotfix mode: Production incident
|
||||
/workflow:lite-fix --hotfix "Payment gateway 5xx errors"
|
||||
```
|
||||
|
||||
## 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)
|
||||
```
|
||||
|
||||
### Phase Summary
|
||||
|
||||
| Phase | Default Mode | Hotfix Mode |
|
||||
|-------|--------------|-------------|
|
||||
| 1. Diagnosis | Adaptive search depth | Minimal (known issue) |
|
||||
| 2. Impact Assessment | Full risk scoring | Critical path only |
|
||||
| 3. Fix Planning | Strategy options based on complexity | Single surgical fix |
|
||||
| 4. Verification | Test level matches risk score | Smoke tests only |
|
||||
| 5. User Confirmation | 3 dimensions | 2 dimensions |
|
||||
| 6. Execution | Via lite-execute | Via lite-execute + monitoring |
|
||||
|
||||
---
|
||||
|
||||
## Detailed Phase Execution
|
||||
|
||||
### Phase 1: Diagnosis & Root Cause Analysis
|
||||
|
||||
**Goal**: Identify root cause and affected code paths
|
||||
|
||||
**Execution Strategy**:
|
||||
|
||||
**Default Mode** - Adaptive search:
|
||||
- **High confidence keywords** (e.g., specific error messages): Direct grep search (5min)
|
||||
- **Medium confidence**: cli-explore-agent with focused search (10-15min)
|
||||
- **Low confidence** (vague symptoms): cli-explore-agent with broad search (20min)
|
||||
|
||||
```javascript
|
||||
// Confidence-based strategy selection
|
||||
if (has_specific_error_message || has_file_path_hint) {
|
||||
// Quick targeted search
|
||||
grep -r '${error_message}' src/ --include='*.ts' -n | head -10
|
||||
git log --oneline --since='1 week ago' -- '*affected*'
|
||||
} else {
|
||||
// Deep exploration
|
||||
Task(subagent_type="cli-explore-agent", prompt=`
|
||||
Bug: ${bug_description}
|
||||
Execute diagnostic search:
|
||||
1. Search error patterns and similar issues
|
||||
2. Trace execution path in affected modules
|
||||
3. Check recent changes
|
||||
Return: Root cause hypothesis, affected paths, reproduction steps
|
||||
`)
|
||||
}
|
||||
```
|
||||
|
||||
**Hotfix Mode** - Minimal search:
|
||||
```bash
|
||||
Read(suspected_file) # User typically knows the file
|
||||
git blame ${suspected_file}
|
||||
```
|
||||
|
||||
**Output Structure**:
|
||||
```javascript
|
||||
{
|
||||
root_cause: {
|
||||
file: "src/auth/tokenValidator.ts",
|
||||
line_range: "45-52",
|
||||
issue: "Token expiration check uses wrong comparison",
|
||||
introduced_by: "commit abc123"
|
||||
},
|
||||
reproduction_steps: ["Login", "Wait 15min", "Access protected route"],
|
||||
affected_scope: {
|
||||
users: "All authenticated users",
|
||||
features: ["login", "API access"],
|
||||
data_risk: "none"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**TodoWrite**: Mark Phase 1 completed, Phase 2 in_progress
|
||||
|
||||
---
|
||||
|
||||
### Phase 2: Impact Assessment & Severity Auto-Detection
|
||||
|
||||
**Goal**: Quantify blast radius and auto-determine severity
|
||||
|
||||
**Risk Score Calculation**:
|
||||
```javascript
|
||||
risk_score = (user_impact × 0.4) + (system_risk × 0.3) + (business_impact × 0.3)
|
||||
|
||||
// Auto-severity mapping
|
||||
if (risk_score >= 8.0) severity = "critical"
|
||||
else if (risk_score >= 5.0) severity = "high"
|
||||
else if (risk_score >= 3.0) severity = "medium"
|
||||
else severity = "low"
|
||||
|
||||
// Workflow adaptation
|
||||
if (severity >= "high") {
|
||||
diagnosis_depth = "focused"
|
||||
test_strategy = "smoke_and_critical"
|
||||
review_optional = true
|
||||
} else {
|
||||
diagnosis_depth = "comprehensive"
|
||||
test_strategy = "full_suite"
|
||||
review_optional = false
|
||||
}
|
||||
```
|
||||
|
||||
**Assessment Output**:
|
||||
```javascript
|
||||
{
|
||||
affected_users: {
|
||||
count: "5000 active users (100%)",
|
||||
severity: "high"
|
||||
},
|
||||
system_risk: {
|
||||
availability: "degraded_30%",
|
||||
cascading_failures: "possible_logout_storm"
|
||||
},
|
||||
business_impact: {
|
||||
revenue: "medium",
|
||||
reputation: "high",
|
||||
sla_breach: "yes"
|
||||
},
|
||||
risk_score: 7.1,
|
||||
severity: "high",
|
||||
workflow_adaptation: {
|
||||
test_strategy: "focused_integration",
|
||||
review_required: false,
|
||||
time_budget: "1_hour"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Hotfix Mode**: Skip detailed assessment, assume critical
|
||||
|
||||
**TodoWrite**: Mark Phase 2 completed, Phase 3 in_progress
|
||||
|
||||
---
|
||||
|
||||
### Phase 3: Fix Planning & Strategy Selection
|
||||
|
||||
**Goal**: Generate fix options with trade-off analysis
|
||||
|
||||
**Strategy Generation**:
|
||||
|
||||
**Default Mode** - Complexity-adaptive:
|
||||
- **Low risk score (<5.0)**: Generate 2-3 strategy options for user selection
|
||||
- **High risk score (≥5.0)**: Generate single best strategy for speed
|
||||
|
||||
```javascript
|
||||
strategies = generateFixStrategies(root_cause, risk_score)
|
||||
|
||||
if (risk_score >= 5.0 || mode === "hotfix") {
|
||||
// Single best strategy
|
||||
return strategies[0] // Fastest viable fix
|
||||
} else {
|
||||
// Multiple options with trade-offs
|
||||
return strategies // Let user choose
|
||||
}
|
||||
```
|
||||
|
||||
**Example Strategies**:
|
||||
```javascript
|
||||
// Low risk: Multiple options
|
||||
[
|
||||
{
|
||||
strategy: "immediate_patch",
|
||||
description: "Fix comparison operator",
|
||||
estimated_time: "15 minutes",
|
||||
risk: "low",
|
||||
pros: ["Quick fix"],
|
||||
cons: ["Doesn't address underlying issue"]
|
||||
},
|
||||
{
|
||||
strategy: "comprehensive_fix",
|
||||
description: "Refactor token validation logic",
|
||||
estimated_time: "2 hours",
|
||||
risk: "medium",
|
||||
pros: ["Addresses root cause"],
|
||||
cons: ["Longer implementation"]
|
||||
}
|
||||
]
|
||||
|
||||
// High risk or hotfix: Single option
|
||||
{
|
||||
strategy: "surgical_fix",
|
||||
description: "Minimal change to fix comparison",
|
||||
files: ["src/auth/tokenValidator.ts:47"],
|
||||
estimated_time: "5 minutes",
|
||||
risk: "minimal"
|
||||
}
|
||||
```
|
||||
|
||||
**Complexity Assessment**:
|
||||
```javascript
|
||||
if (complexity === "high" && risk_score < 5.0) {
|
||||
suggestCommand("/workflow:plan --mode bugfix")
|
||||
return // Escalate to full planning
|
||||
}
|
||||
```
|
||||
|
||||
**TodoWrite**: Mark Phase 3 completed, Phase 4 in_progress
|
||||
|
||||
---
|
||||
|
||||
### Phase 4: Verification Strategy
|
||||
|
||||
**Goal**: Define testing approach based on severity
|
||||
|
||||
**Adaptive Test Strategy**:
|
||||
|
||||
| Risk Score | Test Scope | Duration | Automation |
|
||||
|------------|------------|----------|------------|
|
||||
| **< 3.0** (Low) | Full test suite | 15-20 min | `npm test` |
|
||||
| **3.0-5.0** (Medium) | Focused integration | 8-12 min | `npm test -- affected-module.test.ts` |
|
||||
| **5.0-8.0** (High) | Smoke + critical | 5-8 min | `npm test -- critical.smoke.test.ts` |
|
||||
| **≥ 8.0** (Critical) | Smoke only | 2-5 min | `npm test -- smoke.test.ts` |
|
||||
| **Hotfix** | Production smoke | 2-3 min | `npm test -- production.smoke.test.ts` |
|
||||
|
||||
**Branch Strategy**:
|
||||
|
||||
**Default Mode**:
|
||||
```javascript
|
||||
{
|
||||
type: "feature_branch",
|
||||
base: "main",
|
||||
name: "fix/token-expiration-edge-case",
|
||||
merge_target: "main"
|
||||
}
|
||||
```
|
||||
|
||||
**Hotfix Mode**:
|
||||
```javascript
|
||||
{
|
||||
type: "hotfix_branch",
|
||||
base: "production_tag_v2.3.1", // ⚠️ From production tag
|
||||
name: "hotfix/token-validation-fix",
|
||||
merge_target: ["main", "production"] // Dual merge
|
||||
}
|
||||
```
|
||||
|
||||
**TodoWrite**: Mark Phase 4 completed, Phase 5 in_progress
|
||||
|
||||
---
|
||||
|
||||
### Phase 5: User Confirmation & Execution Selection
|
||||
|
||||
**Adaptive Confirmation Dimensions**:
|
||||
|
||||
**Default Mode** - 3 dimensions (adapted by risk score):
|
||||
|
||||
```javascript
|
||||
dimensions = [
|
||||
{
|
||||
question: "Confirm fix approach?",
|
||||
options: ["Proceed", "Modify", "Escalate to /workflow:plan"]
|
||||
},
|
||||
{
|
||||
question: "Execution method:",
|
||||
options: ["Agent", "CLI Tool (Codex/Gemini)", "Manual (plan only)"]
|
||||
},
|
||||
{
|
||||
question: "Verification level:",
|
||||
options: adaptedByRiskScore() // Auto-suggest based on Phase 2
|
||||
}
|
||||
]
|
||||
|
||||
// If risk_score >= 5.0, auto-skip code review dimension
|
||||
// If risk_score < 5.0, add optional code review dimension
|
||||
if (risk_score < 5.0) {
|
||||
dimensions.push({
|
||||
question: "Post-fix review:",
|
||||
options: ["Gemini", "Skip"]
|
||||
})
|
||||
}
|
||||
```
|
||||
|
||||
**Hotfix Mode** - 2 dimensions (minimal):
|
||||
```javascript
|
||||
[
|
||||
{
|
||||
question: "Confirm hotfix deployment:",
|
||||
options: ["Deploy", "Stage First", "Abort"]
|
||||
},
|
||||
{
|
||||
question: "Post-deployment monitoring:",
|
||||
options: ["Real-time (15 min)", "Passive (alerts only)"]
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
**TodoWrite**: Mark Phase 5 completed, Phase 6 in_progress
|
||||
|
||||
---
|
||||
|
||||
### Phase 6: Execution Dispatch & Follow-up
|
||||
|
||||
**Dispatch to lite-execute**:
|
||||
|
||||
```javascript
|
||||
executionContext = {
|
||||
mode: "bugfix",
|
||||
severity: auto_detected_severity, // From Phase 2
|
||||
planObject: plan,
|
||||
diagnosisContext: diagnosis,
|
||||
impactContext: impact_assessment,
|
||||
verificationStrategy: test_strategy,
|
||||
branchStrategy: branch_strategy,
|
||||
executionMethod: user_selection.execution_method
|
||||
}
|
||||
|
||||
SlashCommand("/workflow:lite-execute --in-memory --mode bugfix")
|
||||
```
|
||||
|
||||
**Hotfix Auto Follow-up**:
|
||||
|
||||
```javascript
|
||||
if (mode === "hotfix") {
|
||||
follow_up_tasks = [
|
||||
{
|
||||
id: `FOLLOWUP-${taskId}-comprehensive`,
|
||||
title: "Replace hotfix with comprehensive fix",
|
||||
priority: "high",
|
||||
due_date: "within_3_days",
|
||||
description: "Refactor quick hotfix into proper solution with full test coverage"
|
||||
},
|
||||
{
|
||||
id: `FOLLOWUP-${taskId}-postmortem`,
|
||||
title: "Incident postmortem",
|
||||
priority: "medium",
|
||||
due_date: "within_1_week",
|
||||
sections: ["Timeline", "Root cause", "Prevention measures"]
|
||||
}
|
||||
]
|
||||
|
||||
Write(`.workflow/lite-fixes/${taskId}-followup.json`, follow_up_tasks)
|
||||
|
||||
console.log(`
|
||||
⚠️ Hotfix follow-up tasks generated:
|
||||
- Comprehensive fix: ${follow_up_tasks[0].id} (due in 3 days)
|
||||
- Postmortem: ${follow_up_tasks[1].id} (due in 1 week)
|
||||
`)
|
||||
}
|
||||
```
|
||||
|
||||
**TodoWrite**: Mark Phase 6 completed
|
||||
|
||||
---
|
||||
|
||||
## Data Structures
|
||||
|
||||
### diagnosisContext
|
||||
```javascript
|
||||
{
|
||||
symptom: string,
|
||||
error_message: string | null,
|
||||
keywords: string[],
|
||||
confidence_level: "high" | "medium" | "low", // Search confidence
|
||||
root_cause: {
|
||||
file: string,
|
||||
line_range: string,
|
||||
issue: string,
|
||||
introduced_by: string
|
||||
},
|
||||
reproduction_steps: string[],
|
||||
affected_scope: {...}
|
||||
}
|
||||
```
|
||||
|
||||
### impactContext
|
||||
```javascript
|
||||
{
|
||||
affected_users: { count: string, severity: string },
|
||||
system_risk: { availability: string, cascading_failures: string },
|
||||
business_impact: { revenue: string, reputation: string, sla_breach: string },
|
||||
risk_score: number, // 0-10
|
||||
severity: "low" | "medium" | "high" | "critical",
|
||||
workflow_adaptation: {
|
||||
diagnosis_depth: string,
|
||||
test_strategy: string,
|
||||
review_optional: boolean,
|
||||
time_budget: string
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### fixPlan
|
||||
```javascript
|
||||
{
|
||||
strategy: string,
|
||||
summary: string,
|
||||
tasks: [{
|
||||
title: string,
|
||||
file: string,
|
||||
action: "Update" | "Create" | "Delete",
|
||||
implementation: string[],
|
||||
verification: string[]
|
||||
}],
|
||||
estimated_time: string,
|
||||
recommended_execution: "Agent" | "CLI" | "Manual"
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Best Practices
|
||||
|
||||
### When to Use Default Mode
|
||||
|
||||
**Use for all standard bugs:**
|
||||
- Automatically adapts to severity (no manual mode selection needed)
|
||||
- Risk score determines workflow complexity
|
||||
- Handles 90% of bug fixing scenarios
|
||||
|
||||
**Typical scenarios:**
|
||||
- UI bugs, logic errors, edge cases
|
||||
- Performance issues (non-critical)
|
||||
- Integration failures
|
||||
- Data validation bugs
|
||||
|
||||
### When to Use Hotfix Mode
|
||||
|
||||
**Only use for production incidents:**
|
||||
- Production is down or critically degraded
|
||||
- Revenue/reputation at immediate risk
|
||||
- SLA breach occurring
|
||||
- Issue is well-understood (minimal diagnosis needed)
|
||||
|
||||
**Hotfix characteristics:**
|
||||
- Creates hotfix branch from production tag
|
||||
- Minimal diagnosis (assumes known issue)
|
||||
- Smoke tests only
|
||||
- Auto-generates follow-up tasks
|
||||
- Requires incident tracking
|
||||
|
||||
### Branching Strategy
|
||||
|
||||
**Default Mode (feature branch)**:
|
||||
```bash
|
||||
# Standard feature branch workflow
|
||||
git checkout -b fix/issue-description main
|
||||
# ... implement fix
|
||||
git checkout main && git merge fix/issue-description
|
||||
```
|
||||
|
||||
**Hotfix Mode (dual merge)**:
|
||||
```bash
|
||||
# ✅ Correct: Branch from production tag
|
||||
git checkout -b hotfix/fix-name v2.3.1
|
||||
|
||||
# Merge to both targets
|
||||
git checkout main && git merge hotfix/fix-name
|
||||
git checkout production && git merge hotfix/fix-name
|
||||
git tag v2.3.2
|
||||
|
||||
# ❌ Wrong: Branch from main
|
||||
git checkout -b hotfix/fix-name main # Contains unreleased code!
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Error Handling
|
||||
|
||||
| Error | Cause | Resolution |
|
||||
|-------|-------|------------|
|
||||
| Root cause unclear | Vague symptoms | Extend diagnosis time or use /cli:mode:bug-diagnosis |
|
||||
| Multiple potential causes | Complex interaction | Use /cli:discuss-plan for analysis |
|
||||
| Fix too complex | High-risk refactor | Escalate to /workflow:plan --mode bugfix |
|
||||
| High risk score but unsure | Uncertain severity | Default mode will adapt, proceed normally |
|
||||
|
||||
---
|
||||
|
||||
## Output Routing
|
||||
|
||||
**Lite-fix directory**:
|
||||
```
|
||||
.workflow/lite-fixes/
|
||||
├── BUGFIX-2024-10-20T14-30-00.json # Task JSON
|
||||
├── BUGFIX-2024-10-20T14-30-00-followup.json # Follow-up (hotfix only)
|
||||
└── diagnosis-cache/ # Cached diagnoses
|
||||
└── ${bug_hash}.json
|
||||
```
|
||||
|
||||
**Session-based** (if active session):
|
||||
```
|
||||
.workflow/active/WFS-feature/
|
||||
├── .bugfixes/
|
||||
│ ├── BUGFIX-001.json
|
||||
│ └── BUGFIX-001-followup.json
|
||||
└── .summaries/
|
||||
└── BUGFIX-001-summary.md
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Advanced Features
|
||||
|
||||
### 1. Intelligent Diagnosis Caching
|
||||
|
||||
Reuse diagnosis for similar bugs:
|
||||
```javascript
|
||||
cache_key = hash(bug_keywords + recent_changes_hash)
|
||||
if (cache_exists && cache_age < 7_days && similarity > 0.8) {
|
||||
diagnosis = load_from_cache()
|
||||
console.log("Using cached diagnosis (similar issue found)")
|
||||
}
|
||||
```
|
||||
|
||||
### 2. Auto-Severity Suggestion
|
||||
|
||||
Detect urgency from keywords:
|
||||
```javascript
|
||||
urgency_keywords = ["production", "down", "outage", "critical", "urgent"]
|
||||
if (bug_description.includes(urgency_keywords) && !mode_specified) {
|
||||
console.log("💡 Tip: Consider --hotfix flag for production issues")
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Adaptive Workflow Intelligence
|
||||
|
||||
Real-time workflow adjustment:
|
||||
```javascript
|
||||
// During Phase 2, if risk score suddenly increases
|
||||
if (new_risk_score > initial_estimate * 1.5) {
|
||||
console.log("⚠️ Severity increased, adjusting workflow...")
|
||||
test_strategy = "more_comprehensive"
|
||||
review_required = true
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Related Commands
|
||||
|
||||
**Diagnostic Commands**:
|
||||
- `/cli:mode:bug-diagnosis` - Detailed root cause analysis (use before lite-fix if unclear)
|
||||
|
||||
**Fix Execution**:
|
||||
- `/workflow:lite-execute --in-memory` - Execute fix plan (automatically called)
|
||||
|
||||
**Planning Commands**:
|
||||
- `/workflow:plan --mode bugfix` - Complex bugs requiring comprehensive planning
|
||||
|
||||
**Review Commands**:
|
||||
- `/workflow:review --type quality` - Post-fix quality review
|
||||
|
||||
---
|
||||
|
||||
## Comparison with Other Commands
|
||||
|
||||
| Command | Use Case | Modes | Adaptation | Output |
|
||||
|---------|----------|-------|------------|--------|
|
||||
| `/workflow:lite-fix` | Bug fixes | 2 (default + hotfix) | Auto-adaptive | In-memory + JSON |
|
||||
| `/workflow:lite-plan` | New features | 1 + explore flag | Manual | In-memory + JSON |
|
||||
| `/workflow:plan` | Complex features | Multiple | Manual | Persistent session |
|
||||
| `/cli:mode:bug-diagnosis` | Analysis only | 1 | N/A | Report only |
|
||||
|
||||
---
|
||||
|
||||
## Quality Gates
|
||||
|
||||
**Before execution** (auto-checked):
|
||||
- [ ] Root cause identified (>70% confidence for default, >90% for hotfix)
|
||||
- [ ] Impact scope defined
|
||||
- [ ] Fix strategy reviewed
|
||||
- [ ] Verification plan matches risk level
|
||||
|
||||
**Hotfix-specific**:
|
||||
- [ ] Production tag identified
|
||||
- [ ] Rollback plan documented
|
||||
- [ ] Follow-up tasks generated
|
||||
- [ ] Monitoring configured
|
||||
|
||||
---
|
||||
|
||||
## When to Use lite-fix
|
||||
|
||||
✅ **Perfect for:**
|
||||
- Any bug with clear symptoms
|
||||
- Localized fixes (1-5 files)
|
||||
- Known technology stack
|
||||
- Time-sensitive but not catastrophic (default mode adapts)
|
||||
- Production incidents (use --hotfix)
|
||||
|
||||
❌ **Not suitable for:**
|
||||
- Root cause completely unclear → use `/cli:mode:bug-diagnosis` first
|
||||
- Requires architectural changes → use `/workflow:plan`
|
||||
- Complex legacy code without tests → use `/workflow:plan --legacy-refactor`
|
||||
- Performance deep-dive → use `/workflow:plan --performance-optimization`
|
||||
- Data migration → use `/workflow:plan --data-migration`
|
||||
|
||||
---
|
||||
|
||||
**Last Updated**: 2025-11-20
|
||||
**Version**: 2.0.0
|
||||
**Status**: Design Document (Simplified)
|
||||
@@ -89,7 +89,7 @@ bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${proj
|
||||
bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${project_name} -type f -name "*.md" ! -path "*/README.md" ! -path "*/ARCHITECTURE.md" ! -path "*/EXAMPLES.md" ! -path "*/api/*" 2>/dev/null | xargs cat 2>/dev/null; fi)
|
||||
```
|
||||
|
||||
**Data Processing**: Parse bash outputs, calculate statistics, use **Write tool** to create `${session_dir}/.process/phase2-analysis.json` with structure:
|
||||
**Data Processing**: Parse bash outputs, calculate statistics, use **Write tool** to create `${session_dir}/.process/doc-planning-data.json` with structure:
|
||||
|
||||
```json
|
||||
{
|
||||
@@ -118,7 +118,7 @@ bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${proj
|
||||
|
||||
**Then** use **Edit tool** to update `workflow-session.json` adding analysis field.
|
||||
|
||||
**Output**: Single `phase2-analysis.json` with all analysis data (no temp files or Python scripts).
|
||||
**Output**: Single `doc-planning-data.json` with all analysis data (no temp files or Python scripts).
|
||||
|
||||
**Auto-skipped**: Tests (`**/test/**`, `**/*.test.*`), Build (`**/node_modules/**`, `**/dist/**`), Config (root-level files), Vendor directories.
|
||||
|
||||
@@ -127,8 +127,8 @@ bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${proj
|
||||
**Commands**:
|
||||
|
||||
```bash
|
||||
# Count existing docs from phase2-analysis.json
|
||||
bash(cat .workflow/WFS-docs-{timestamp}/.process/phase2-analysis.json | jq '.existing_docs.file_list | length')
|
||||
# Count existing docs from doc-planning-data.json
|
||||
bash(cat .workflow/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq '.existing_docs.file_list | length')
|
||||
```
|
||||
|
||||
**Data Processing**: Use count result, then use **Edit tool** to update `workflow-session.json`:
|
||||
@@ -182,8 +182,8 @@ Large Projects (single dir >10 docs):
|
||||
**Commands**:
|
||||
|
||||
```bash
|
||||
# 1. Get top-level directories from phase2-analysis.json
|
||||
bash(cat .workflow/WFS-docs-{timestamp}/.process/phase2-analysis.json | jq -r '.top_level_dirs[]')
|
||||
# 1. Get top-level directories from doc-planning-data.json
|
||||
bash(cat .workflow/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq -r '.top_level_dirs[]')
|
||||
|
||||
# 2. Get mode from workflow-session.json
|
||||
bash(cat .workflow/WFS-docs-{timestamp}/workflow-session.json | jq -r '.mode // "full"')
|
||||
@@ -201,7 +201,7 @@ bash(grep -r "router\.|@Get\|@Post" src/ 2>/dev/null && echo "API_FOUND" || echo
|
||||
- If total ≤10 docs: create group
|
||||
- If total >10 docs: split to 1 dir/group or subdivide
|
||||
- If single dir >10 docs: split by subdirectories
|
||||
3. Use **Edit tool** to update `phase2-analysis.json` adding groups field:
|
||||
3. Use **Edit tool** to update `doc-planning-data.json` adding groups field:
|
||||
```json
|
||||
"groups": {
|
||||
"count": 3,
|
||||
@@ -215,7 +215,7 @@ bash(grep -r "router\.|@Get\|@Post" src/ 2>/dev/null && echo "API_FOUND" || echo
|
||||
|
||||
**Task ID Calculation**:
|
||||
```bash
|
||||
group_count=$(jq '.groups.count' .workflow/WFS-docs-{timestamp}/.process/phase2-analysis.json)
|
||||
group_count=$(jq '.groups.count' .workflow/WFS-docs-{timestamp}/.process/doc-planning-data.json)
|
||||
readme_id=$((group_count + 1)) # Next ID after groups
|
||||
arch_id=$((group_count + 2))
|
||||
api_id=$((group_count + 3))
|
||||
@@ -237,7 +237,7 @@ api_id=$((group_count + 3))
|
||||
|
||||
**Generation Process**:
|
||||
1. Read configuration values (tool, cli_execute, mode) from workflow-session.json
|
||||
2. Read group assignments from phase2-analysis.json
|
||||
2. Read group assignments from doc-planning-data.json
|
||||
3. Generate Level 1 tasks (IMPL-001 to IMPL-N, one per group)
|
||||
4. Generate Level 2+ tasks if mode=full (README, ARCHITECTURE, HTTP API)
|
||||
|
||||
@@ -262,14 +262,14 @@ api_id=$((group_count + 3))
|
||||
},
|
||||
"context": {
|
||||
"requirements": [
|
||||
"Process directories from group ${group_number} in phase2-analysis.json",
|
||||
"Process directories from group ${group_number} in doc-planning-data.json",
|
||||
"Generate docs to .workflow/docs/${project_name}/ (mirrored structure)",
|
||||
"Code folders: API.md + README.md; Navigation folders: README.md only",
|
||||
"Use pre-analyzed data from Phase 2 (no redundant analysis)"
|
||||
],
|
||||
"focus_paths": ["${group_dirs_from_json}"],
|
||||
"precomputed_data": {
|
||||
"phase2_analysis": "${session_dir}/.process/phase2-analysis.json"
|
||||
"phase2_analysis": "${session_dir}/.process/doc-planning-data.json"
|
||||
}
|
||||
},
|
||||
"flow_control": {
|
||||
@@ -278,8 +278,8 @@ api_id=$((group_count + 3))
|
||||
"step": "load_precomputed_data",
|
||||
"action": "Load Phase 2 analysis and extract group directories",
|
||||
"commands": [
|
||||
"bash(cat ${session_dir}/.process/phase2-analysis.json)",
|
||||
"bash(jq '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories' ${session_dir}/.process/phase2-analysis.json)"
|
||||
"bash(cat ${session_dir}/.process/doc-planning-data.json)",
|
||||
"bash(jq '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories' ${session_dir}/.process/doc-planning-data.json)"
|
||||
],
|
||||
"output_to": "phase2_context",
|
||||
"note": "Single JSON file contains all Phase 2 analysis results"
|
||||
@@ -324,7 +324,7 @@ api_id=$((group_count + 3))
|
||||
{
|
||||
"step": 2,
|
||||
"title": "Batch generate documentation via CLI",
|
||||
"command": "bash(dirs=$(jq -r '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories[]' ${session_dir}/.process/phase2-analysis.json); for dir in $dirs; do cd \"$dir\" && gemini --approval-mode yolo -p \"PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure\" || echo \"Failed: $dir\"; cd -; done)",
|
||||
"command": "bash(dirs=$(jq -r '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories[]' ${session_dir}/.process/doc-planning-data.json); for dir in $dirs; do cd \"$dir\" && gemini --approval-mode yolo -p \"PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure\" || echo \"Failed: $dir\"; cd -; done)",
|
||||
"depends_on": [1],
|
||||
"output": "generated_docs"
|
||||
}
|
||||
@@ -464,7 +464,7 @@ api_id=$((group_count + 3))
|
||||
├── IMPL_PLAN.md
|
||||
├── TODO_LIST.md
|
||||
├── .process/
|
||||
│ └── phase2-analysis.json # All Phase 2 analysis data (replaces 7+ files)
|
||||
│ └── doc-planning-data.json # All Phase 2 analysis data (replaces 7+ files)
|
||||
└── .task/
|
||||
├── IMPL-001.json # Small: all modules | Large: group 1
|
||||
├── IMPL-00N.json # (Large only: groups 2-N)
|
||||
@@ -473,7 +473,7 @@ api_id=$((group_count + 3))
|
||||
└── IMPL-{N+3}.json # HTTP API (optional)
|
||||
```
|
||||
|
||||
**phase2-analysis.json Structure**:
|
||||
**doc-planning-data.json Structure**:
|
||||
```json
|
||||
{
|
||||
"metadata": {
|
||||
|
||||
@@ -5,27 +5,22 @@ description: Product backlog management, user story creation, and feature priori
|
||||
|
||||
# Product Owner Planning Template
|
||||
|
||||
You are a **Product Owner** specializing in product backlog management, user story creation, and feature prioritization.
|
||||
## Role & Scope
|
||||
|
||||
## Your Role & Responsibilities
|
||||
**Role**: Product Owner
|
||||
**Focus**: Product backlog management, user story definition, stakeholder alignment, value delivery
|
||||
**Excluded**: Team management, technical implementation, detailed system design
|
||||
|
||||
**Primary Focus**: Product backlog management, user story definition, stakeholder alignment, and value delivery
|
||||
|
||||
**Core Responsibilities**:
|
||||
- Product backlog creation and prioritization
|
||||
- User story writing with acceptance criteria
|
||||
- Stakeholder engagement and requirement gathering
|
||||
- Feature value assessment and ROI analysis
|
||||
- Release planning and roadmap management
|
||||
- Sprint goal definition and commitment
|
||||
- Acceptance testing and definition of done
|
||||
|
||||
**Does NOT Include**: Team management, technical implementation, detailed system design
|
||||
## Planning Process (Required)
|
||||
Before providing planning document, you MUST:
|
||||
1. Analyze product vision and stakeholder needs
|
||||
2. Define backlog structure and prioritization framework
|
||||
3. Create user stories with acceptance criteria
|
||||
4. Plan releases and define success metrics
|
||||
5. Present structured planning document
|
||||
|
||||
## Planning Document Structure
|
||||
|
||||
Generate a comprehensive Product Owner planning document with the following structure:
|
||||
|
||||
### 1. Product Vision & Strategy
|
||||
- **Product Vision**: Long-term product goals and target outcomes
|
||||
- **Value Proposition**: User value and business benefits
|
||||
|
||||
@@ -5,55 +5,52 @@ category: development
|
||||
keywords: [bug诊断, 故障分析, 修复方案]
|
||||
---
|
||||
|
||||
# AI Persona & Core Mission
|
||||
# Role & Output Requirements
|
||||
|
||||
You are a **资深软件工程师 & 故障诊断专家 (Senior Software Engineer & Fault Diagnosis Expert)**. Your mission is to meticulously analyze user-provided bug reports, logs, and code snippets to perform a forensic-level investigation. Your goal is to pinpoint the precise root cause of the bug and then propose a targeted, robust, and minimally invasive correction plan. **Critically, you will *not* write complete, ready-to-use code files. Your output is a diagnostic report and a clear, actionable correction suggestion, articulated in professional Chinese.** You are an expert at logical deduction, tracing execution flows, and anticipating the side effects of any proposed fix.
|
||||
**Role**: Software engineer specializing in bug diagnosis
|
||||
**Output Format**: Diagnostic report in Chinese following the specified structure
|
||||
**Constraints**: Do NOT write complete code files. Provide diagnostic analysis and targeted correction suggestions only.
|
||||
|
||||
## II. ROLE DEFINITION & CORE CAPABILITIES
|
||||
1. **Role**: Senior Software Engineer & Fault Diagnosis Expert.
|
||||
2. **Core Capabilities**:
|
||||
* **Symptom Interpretation**: Deconstructing bug reports, stack traces, logs, and user descriptions into concrete technical observations.
|
||||
* **Logical Deduction & Root Cause Analysis**: Masterfully applying deductive reasoning to trace symptoms back to their fundamental cause, moving from what is happening to why its happening.
|
||||
* **Code Traversal & Execution Flow Analysis**: Mentally (or schematically) tracing code paths, state changes, and data transformations to identify logical flaws.
|
||||
* **Hypothesis Formulation & Validation**: Formulating plausible hypotheses about the bugs origin and systematically validating or refuting them based on the provided evidence.
|
||||
* **Targeted Solution Design**: Proposing precise, effective, and low-risk code corrections rather than broad refactoring.
|
||||
* **Impact Analysis**: Foreseeing the potential ripple effects or unintended consequences of a proposed fix on other parts of the system.
|
||||
* **Clear Technical Communication (Chinese)**: Articulating complex diagnostic processes and correction plans in clear, unambiguous Chinese for a developer audience.
|
||||
## Core Capabilities
|
||||
- Interpret symptoms from bug reports, stack traces, and logs
|
||||
- Trace execution flow to identify root causes
|
||||
- Formulate and validate hypotheses about bug origins
|
||||
- Design targeted, low-risk corrections
|
||||
- Analyze impact on other system components
|
||||
|
||||
3. **Core Thinking Mode**:
|
||||
* **Detective-like & Methodical**: Start with the evidence (symptoms), follow the clues (code paths), identify the suspect (flawed logic), and prove the case (root cause).
|
||||
* **Hypothesis-Driven**: Actively form and state your working theories (My initial hypothesis is that the null pointer is originating from module X because...) before reaching a conclusion.
|
||||
* **From Effect to Cause**: Your primary thought process should be working backward from the observed failure to the initial error.
|
||||
* **Chain-of-Thought (CoT) Driven**: Explicitly articulate your entire diagnostic journey, from symptom analysis to root cause identification.
|
||||
## Analysis Process (Required)
|
||||
**Before providing your final diagnosis, you MUST:**
|
||||
1. Analyze symptoms and form initial hypothesis
|
||||
2. Trace code execution to identify root cause
|
||||
3. Design correction strategy
|
||||
4. Assess potential impacts and risks
|
||||
5. Present structured diagnostic report
|
||||
|
||||
## III. OBJECTIVES
|
||||
1. **Analyze Evidence**: Thoroughly examine all provided information (bug description, code, logs) to understand the failure conditions.
|
||||
2. **Pinpoint Root Cause**: Go beyond surface-level symptoms to identify the fundamental logical error, race condition, data corruption, or configuration issue.
|
||||
3. **Propose Precise Correction**: Formulate a clear and targeted suggestion for how to fix the bug.
|
||||
4. **Explain the Why**: Justify why the proposed correction effectively resolves the root cause.
|
||||
5. **Assess Risks & Side Effects**: Identify potential negative impacts of the fix and suggest verification steps.
|
||||
6. **Professional Chinese Output**: Produce a highly structured, professional diagnostic report and correction plan entirely in Chinese.
|
||||
7. **Show Your Work (CoT)**: Demonstrate your analytical process clearly in the 思考过程 section.
|
||||
## Objectives
|
||||
1. Identify root cause (not just symptoms)
|
||||
2. Propose targeted correction with justification
|
||||
3. Assess risks and side effects
|
||||
4. Provide verification steps
|
||||
|
||||
## IV. INPUT SPECIFICATIONS
|
||||
1. **Bug Description**: A description of the problem, including observed behavior vs. expected behavior.
|
||||
2. **Code Snippets/File Information**: Relevant source code where the bug is suspected to be.
|
||||
3. **Logs/Stack Traces (Highly Recommended)**: Error messages, logs, or stack traces associated with the bug.
|
||||
4. **Reproduction Steps (Optional)**: Steps to reproduce the bug.
|
||||
## Input
|
||||
- Bug description (observed vs. expected behavior)
|
||||
- Code snippets or file locations
|
||||
- Logs, stack traces, error messages
|
||||
- Reproduction steps (if available)
|
||||
|
||||
## V. RESPONSE STRUCTURE & CONTENT (Strictly Adhere - Output in Chinese)
|
||||
## Output Structure (Required)
|
||||
|
||||
Your response **MUST** be in Chinese and structured in Markdown as follows:
|
||||
Output in Chinese using this Markdown structure:
|
||||
|
||||
---
|
||||
|
||||
### 0. 诊断思维链 (Diagnostic Chain-of-Thought)
|
||||
* *(在此处,您必须结构化地展示您的诊断流程。)*
|
||||
* **1. 症状分析 (Symptom Analysis):** 我首先将用户的描述、日志和错误信息进行归纳,提炼出关键的异常行为和技术线索。
|
||||
* **2. 代码勘察与初步假设 (Code Exploration & Initial Hypothesis):** 基于症状,我将定位到最可疑的代码区域,并提出一个关于根本原因的初步假设。
|
||||
* **3. 逻辑推演与根本原因定位 (Logical Deduction & Root Cause Pinpointing):** 我将沿着代码执行路径进行深入推演,验证或修正我的假设,直至锁定导致错误的精确逻辑点。
|
||||
* **4. 修复方案设计 (Correction Strategy Design):** 在确定根本原因后,我将设计一个最直接、风险最低的修复方案。
|
||||
* **5. 影响评估与验证规划 (Impact Assessment & Verification Planning):** 我会评估修复方案可能带来的副作用,并构思如何验证修复的有效性及系统的稳定性。
|
||||
Present your analysis process in these steps:
|
||||
1. **症状分析**: Summarize error symptoms and technical clues
|
||||
2. **初步假设**: Identify suspicious code areas and form initial hypothesis
|
||||
3. **根本原因定位**: Trace execution path to pinpoint exact cause
|
||||
4. **修复方案设计**: Design targeted, low-risk correction
|
||||
5. **影响评估**: Assess side effects and plan verification
|
||||
|
||||
### **故障诊断与修复建议报告 (Bug Diagnosis & Correction Proposal)**
|
||||
|
||||
@@ -114,17 +111,17 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
|
||||
---
|
||||
*(对每个需要修改的文件重复上述格式)*
|
||||
|
||||
## VI. KEY DIRECTIVES & CONSTRAINTS
|
||||
1. **Language**: **All** descriptive parts MUST be in **Chinese**.
|
||||
2. **No Full Code Generation**: **Strictly refrain** from writing complete functions or files. Your correction suggestions should be concise, using single lines, `diff` format, or pseudo-code to illustrate the change. Your role is to guide the developer, not replace them.
|
||||
3. **Focus on RCA**: The quality of your Root Cause Analysis is paramount. It must be logical, convincing, and directly supported by the evidence.
|
||||
4. **State Assumptions**: If the provided information is insufficient to be 100% certain, clearly state your assumptions in the 诊断分析过程 section.
|
||||
## Key Requirements
|
||||
1. **Language**: All output in Chinese
|
||||
2. **No Code Generation**: Use diff format or pseudo-code only. Do not write complete functions or files
|
||||
3. **Focus on Root Cause**: Analysis must be logical and evidence-based
|
||||
4. **State Assumptions**: Clearly note any assumptions when information is incomplete
|
||||
|
||||
## VII. SELF-CORRECTION / REFLECTION
|
||||
* Before finalizing your response, review it to ensure:
|
||||
* The 诊断思维链 accurately reflects a logical debugging process.
|
||||
* The Root Cause Analysis is deep, clear, and compelling.
|
||||
* The proposed correction directly addresses the identified root cause.
|
||||
* The correction suggestion is minimal and precise (not large-scale refactoring).
|
||||
* The verification steps are actionable and cover both success and failure cases.
|
||||
* You have strictly avoided generating large blocks of code.
|
||||
## Self-Review Checklist
|
||||
Before providing final output, verify:
|
||||
- [ ] Diagnostic chain reflects logical debugging process
|
||||
- [ ] Root cause analysis is clear and evidence-based
|
||||
- [ ] Correction directly addresses root cause (not just symptoms)
|
||||
- [ ] Correction is minimal and targeted (not broad refactoring)
|
||||
- [ ] Verification steps are actionable
|
||||
- [ ] No complete code blocks generated
|
||||
|
||||
@@ -1,10 +1,17 @@
|
||||
Analyze implementation patterns and code structure.
|
||||
|
||||
## CORE CHECKLIST ⚡
|
||||
□ Analyze ALL files in CONTEXT (not just samples)
|
||||
□ Provide file:line references for every pattern identified
|
||||
□ Distinguish between good patterns and anti-patterns
|
||||
□ Apply RULES template requirements exactly as specified
|
||||
## Planning Required
|
||||
Before providing analysis, you MUST:
|
||||
1. Review all files in context (not just samples)
|
||||
2. Identify patterns with file:line references
|
||||
3. Distinguish good patterns from anti-patterns
|
||||
4. Apply template requirements
|
||||
|
||||
## Core Checklist
|
||||
- [ ] Analyze ALL files in CONTEXT
|
||||
- [ ] Provide file:line references for each pattern
|
||||
- [ ] Distinguish good patterns from anti-patterns
|
||||
- [ ] Apply RULES template requirements
|
||||
|
||||
## REQUIRED ANALYSIS
|
||||
1. Identify common code patterns and architectural decisions
|
||||
@@ -19,10 +26,12 @@ Analyze implementation patterns and code structure.
|
||||
- Clear recommendations for pattern improvements
|
||||
- Standards compliance assessment with priority levels
|
||||
|
||||
## VERIFICATION CHECKLIST ✓
|
||||
□ All CONTEXT files analyzed (not partial coverage)
|
||||
□ Every pattern backed by code reference (file:line)
|
||||
□ Anti-patterns clearly distinguished from good patterns
|
||||
□ Recommendations prioritized by impact
|
||||
## Verification Checklist
|
||||
Before finalizing output, verify:
|
||||
- [ ] All CONTEXT files analyzed
|
||||
- [ ] Every pattern has code reference (file:line)
|
||||
- [ ] Anti-patterns clearly distinguished
|
||||
- [ ] Recommendations prioritized by impact
|
||||
|
||||
Focus: Actionable insights with concrete implementation guidance.
|
||||
## Output Requirements
|
||||
Provide actionable insights with concrete implementation guidance.
|
||||
|
||||
@@ -1,10 +1,17 @@
|
||||
Create comprehensive tests for the codebase.
|
||||
|
||||
## CORE CHECKLIST ⚡
|
||||
□ Analyze existing test coverage and identify gaps
|
||||
□ Follow project testing frameworks and conventions
|
||||
□ Include unit, integration, and end-to-end tests
|
||||
□ Ensure tests are reliable and deterministic
|
||||
## Planning Required
|
||||
Before creating tests, you MUST:
|
||||
1. Analyze existing test coverage and identify gaps
|
||||
2. Study testing frameworks and conventions used
|
||||
3. Plan test strategy covering unit, integration, and e2e
|
||||
4. Design test data management approach
|
||||
|
||||
## Core Checklist
|
||||
- [ ] Analyze coverage gaps
|
||||
- [ ] Follow testing frameworks and conventions
|
||||
- [ ] Include unit, integration, and e2e tests
|
||||
- [ ] Ensure tests are reliable and deterministic
|
||||
|
||||
## IMPLEMENTATION PHASES
|
||||
|
||||
@@ -51,11 +58,13 @@ Create comprehensive tests for the codebase.
|
||||
- Test coverage metrics and quality improvements
|
||||
- File:line references for tested code
|
||||
|
||||
## VERIFICATION CHECKLIST ✓
|
||||
□ Test coverage gaps identified and filled
|
||||
□ All test types included (unit + integration + e2e)
|
||||
□ Tests are reliable and deterministic (no flaky tests)
|
||||
□ Test data properly managed (isolation + cleanup)
|
||||
□ Testing conventions followed consistently
|
||||
## Verification Checklist
|
||||
Before finalizing, verify:
|
||||
- [ ] Coverage gaps filled
|
||||
- [ ] All test types included
|
||||
- [ ] Tests are reliable (no flaky tests)
|
||||
- [ ] Test data properly managed
|
||||
- [ ] Conventions followed
|
||||
|
||||
Focus: High-quality, reliable test suite with comprehensive coverage.
|
||||
## Focus
|
||||
High-quality, reliable test suite with comprehensive coverage.
|
||||
|
||||
@@ -1,10 +1,17 @@
|
||||
Implement a new feature following project conventions and best practices.
|
||||
|
||||
## CORE CHECKLIST ⚡
|
||||
□ Study existing code patterns BEFORE implementing
|
||||
□ Follow established project conventions and architecture
|
||||
□ Include comprehensive tests (unit + integration)
|
||||
□ Provide file:line references for all changes
|
||||
## Planning Required
|
||||
Before implementing, you MUST:
|
||||
1. Study existing code patterns and conventions
|
||||
2. Review project architecture and design principles
|
||||
3. Plan implementation with error handling and tests
|
||||
4. Document integration points and dependencies
|
||||
|
||||
## Core Checklist
|
||||
- [ ] Study existing code patterns first
|
||||
- [ ] Follow project conventions and architecture
|
||||
- [ ] Include comprehensive tests
|
||||
- [ ] Provide file:line references
|
||||
|
||||
## IMPLEMENTATION PHASES
|
||||
|
||||
@@ -39,11 +46,13 @@ Implement a new feature following project conventions and best practices.
|
||||
- Documentation of new dependencies or configurations
|
||||
- Test coverage summary
|
||||
|
||||
## VERIFICATION CHECKLIST ✓
|
||||
□ Implementation follows existing patterns (no divergence)
|
||||
□ Complete test coverage (unit + integration)
|
||||
□ Documentation updated (code comments + external docs)
|
||||
□ Integration verified (no breaking changes)
|
||||
□ Security and performance validated
|
||||
## Verification Checklist
|
||||
Before finalizing, verify:
|
||||
- [ ] Follows existing patterns
|
||||
- [ ] Complete test coverage
|
||||
- [ ] Documentation updated
|
||||
- [ ] No breaking changes
|
||||
- [ ] Security and performance validated
|
||||
|
||||
Focus: Production-ready implementation with comprehensive testing and documentation.
|
||||
## Focus
|
||||
Production-ready implementation with comprehensive testing and documentation.
|
||||
|
||||
@@ -1,10 +1,17 @@
|
||||
Generate comprehensive module documentation focused on understanding and usage.
|
||||
Generate module documentation focused on understanding and usage.
|
||||
|
||||
## CORE CHECKLIST ⚡
|
||||
□ Explain WHAT the module does, WHY it exists, and HOW to use it
|
||||
□ Do NOT duplicate API signatures from API.md; refer to it instead
|
||||
□ Provide practical, real-world usage examples
|
||||
□ Clearly define the module's boundaries and dependencies
|
||||
## Planning Required
|
||||
Before providing documentation, you MUST:
|
||||
1. Understand what the module does and why it exists
|
||||
2. Review existing documentation to avoid duplication
|
||||
3. Prepare practical usage examples
|
||||
4. Identify module boundaries and dependencies
|
||||
|
||||
## Core Checklist
|
||||
- [ ] Explain WHAT, WHY, and HOW
|
||||
- [ ] Reference API.md instead of duplicating signatures
|
||||
- [ ] Include practical usage examples
|
||||
- [ ] Define module boundaries and dependencies
|
||||
|
||||
## DOCUMENTATION STRUCTURE
|
||||
|
||||
@@ -31,10 +38,12 @@ Generate comprehensive module documentation focused on understanding and usage.
|
||||
### 7. Common Issues
|
||||
- List common problems and their solutions.
|
||||
|
||||
## VERIFICATION CHECKLIST ✓
|
||||
□ The module's purpose, scope, and boundaries are clearly defined
|
||||
□ Core concepts are explained for better understanding
|
||||
□ Usage examples are practical and demonstrate real-world scenarios
|
||||
□ All dependencies and configuration options are documented
|
||||
## Verification Checklist
|
||||
Before finalizing output, verify:
|
||||
- [ ] Module purpose, scope, and boundaries are clear
|
||||
- [ ] Core concepts are explained
|
||||
- [ ] Usage examples are practical and realistic
|
||||
- [ ] Dependencies and configuration are documented
|
||||
|
||||
Focus: Explaining the module's purpose and usage, not just its API.
|
||||
## Focus
|
||||
Explain module purpose and usage, not just API details.
|
||||
@@ -1,51 +1,51 @@
|
||||
# 软件架构规划模板
|
||||
# AI Persona & Core Mission
|
||||
|
||||
You are a **Distinguished Senior Software Architect and Strategic Technical Planner**. Your primary function is to conduct a meticulous and insightful analysis of provided code, project context, and user requirements to devise an exceptionally clear, comprehensive, actionable, and forward-thinking modification plan. **Critically, you will *not* write or generate any code yourself; your entire output will be a detailed modification plan articulated in precise, professional Chinese.** You are an expert in anticipating dependencies, potential impacts, and ensuring the proposed plan is robust, maintainable, and scalable.
|
||||
## Role & Output Requirements
|
||||
|
||||
## II. ROLE DEFINITION & CORE CAPABILITIES
|
||||
1. **Role**: Distinguished Senior Software Architect and Strategic Technical Planner.
|
||||
2. **Core Capabilities**:
|
||||
* **Deep Code Comprehension**: Ability to rapidly understand complex existing codebases (structure, patterns, dependencies, data flow, control flow).
|
||||
* **Requirements Analysis & Distillation**: Skill in dissecting user requirements, identifying core needs, and translating them into technical planning objectives.
|
||||
* **Software Design Principles**: Strong grasp of SOLID, DRY, KISS, design patterns, and architectural best practices.
|
||||
* **Impact Analysis & Risk Assessment**: Expertise in identifying potential side effects, inter-module dependencies, and risks associated with proposed changes.
|
||||
* **Strategic Planning**: Ability to formulate logical, step-by-step modification plans that are efficient and minimize disruption.
|
||||
* **Clear Technical Communication (Chinese)**: Excellence in conveying complex technical plans and considerations in clear, unambiguous Chinese for a developer audience.
|
||||
* **Visual Logic Representation**: Ability to sketch out intended logic flows using concise diagrammatic notations.
|
||||
3. **Core Thinking Mode**:
|
||||
* **Systematic & Holistic**: Approach analysis and planning with a comprehensive view of the system.
|
||||
* **Critical & Forward-Thinking**: Evaluate requirements critically and plan for future maintainability and scalability.
|
||||
* **Problem-Solver**: Focus on devising effective solutions through planning.
|
||||
* **Chain-of-Thought (CoT) Driven**: Explicitly articulate your reasoning process, especially when making design choices within the plan.
|
||||
**Role**: Software architect specializing in technical planning
|
||||
**Output Format**: Modification plan in Chinese following the specified structure
|
||||
**Constraints**: Do NOT write or generate code. Provide planning and strategy only.
|
||||
|
||||
## III. OBJECTIVES
|
||||
1. **Thoroughly Understand Context**: Analyze user-provided code, modification requirements, and project background to gain a deep understanding of the existing system and the goals of the modification.
|
||||
2. **Meticulous Code Analysis for Planning**: Identify all relevant code sections, their current logic, and how they interrelate, quoting relevant snippets for context.
|
||||
3. **Devise Actionable Modification Plan**: Create a detailed, step-by-step plan outlining *what* changes are needed, *where* they should occur, *why* they are necessary, and the *intended logic* of the new/modified code.
|
||||
4. **Illustrate Intended Logic**: For each significant logical change proposed, visually represent the *intended* new or modified control flow and data flow using a concise call flow diagram.
|
||||
5. **Contextualize for Implementation**: Provide all necessary contextual information (variables, data structures, dependencies, potential side effects) to enable a developer to implement the plan accurately.
|
||||
6. **Professional Chinese Output**: Produce a highly structured, professional planning document entirely in Chinese, adhering to the specified Markdown format.
|
||||
7. **Show Your Work (CoT)**: Before presenting the plan, outline your analytical framework, key considerations, and how you approached the planning task.
|
||||
## Core Capabilities
|
||||
- Understand complex codebases (structure, patterns, dependencies, data flow)
|
||||
- Analyze requirements and translate to technical objectives
|
||||
- Apply software design principles (SOLID, DRY, KISS, design patterns)
|
||||
- Assess impacts, dependencies, and risks
|
||||
- Create step-by-step modification plans
|
||||
|
||||
## IV. INPUT SPECIFICATIONS
|
||||
1. **Code Snippets/File Information**: User-provided source code, file names, paths, or descriptions of relevant code sections.
|
||||
2. **Modification Requirements**: Specific instructions or goals for what needs to be changed or achieved.
|
||||
3. **Project Context (Optional)**: Any background information about the project or system.
|
||||
## Planning Process (Required)
|
||||
**Before providing your final plan, you MUST:**
|
||||
1. Analyze requirements and identify technical objectives
|
||||
2. Explore existing code structure and patterns
|
||||
3. Identify modification points and formulate strategy
|
||||
4. Assess dependencies and risks
|
||||
5. Present structured modification plan
|
||||
|
||||
## V. RESPONSE STRUCTURE & CONTENT (Strictly Adhere - Output in Chinese)
|
||||
## Objectives
|
||||
1. Understand context (code, requirements, project background)
|
||||
2. Analyze relevant code sections and their relationships
|
||||
3. Create step-by-step modification plan (what, where, why, how)
|
||||
4. Illustrate intended logic using call flow diagrams
|
||||
5. Provide implementation context (variables, dependencies, side effects)
|
||||
|
||||
Your response **MUST** be in Chinese and structured in Markdown as follows:
|
||||
## Input
|
||||
- Code snippets or file locations
|
||||
- Modification requirements and goals
|
||||
- Project context (if available)
|
||||
|
||||
## Output Structure (Required)
|
||||
|
||||
Output in Chinese using this Markdown structure:
|
||||
|
||||
---
|
||||
|
||||
### 0. 思考过程与规划策略 (Thinking Process & Planning Strategy)
|
||||
* *(在此处,您必须结构化地展示您的分析框架和规划流程。)*
|
||||
* **1. 需求解析 (Requirement Analysis):** 我首先将用户的原始需求进行拆解和澄清,确保完全理解其核心目标和边界条件。
|
||||
* **2. 现有代码结构勘探 (Existing Code Exploration):** 基于提供的代码片段,我将分析其当前的结构、逻辑流和关键数据对象,以建立修改的基线。
|
||||
* **3. 核心修改点识别与策略制定 (Identification of Core Modification Points & Strategy Formulation):** 我将识别出需要修改的关键代码位置,并为每个修改点制定高级别的技术策略(例如,是重构、新增还是调整)。
|
||||
* **4. 依赖与风险评估 (Dependency & Risk Assessment):** 我会评估提议的修改可能带来的模块间依赖关系变化,以及潜在的风险(如性能下降、兼容性问题、边界情况处理不当等)。
|
||||
* **5. 规划文档结构设计 (Plan Document Structuring):** 最后,我将依据上述分析,按照指定的格式组织并撰写这份详细的修改规划方案。
|
||||
Present your planning process in these steps:
|
||||
1. **需求解析**: Break down requirements and clarify core objectives
|
||||
2. **代码结构勘探**: Analyze current code structure and logic flow
|
||||
3. **核心修改点识别**: Identify modification points and formulate strategy
|
||||
4. **依赖与风险评估**: Assess dependencies and risks
|
||||
5. **规划文档组织**: Organize planning document
|
||||
|
||||
### **代码修改规划方案 (Code Modification Plan)**
|
||||
|
||||
@@ -93,25 +93,17 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
|
||||
---
|
||||
*(对每个需要修改的文件重复上述格式)*
|
||||
|
||||
## VI. STYLE & TONE (Chinese Output)
|
||||
* **Professional & Authoritative**: Maintain a formal, expert tone befitting a Senior Architect.
|
||||
* **Analytical & Insightful**: Demonstrate deep understanding and strategic thinking.
|
||||
* **Precise & Unambiguous**: Use clear, exact technical Chinese terminology.
|
||||
* **Structured & Actionable**: Ensure the plan is well-organized and provides clear guidance.
|
||||
## Key Requirements
|
||||
1. **Language**: All output in Chinese
|
||||
2. **No Code Generation**: Do not write actual code. Provide descriptive modification plan only
|
||||
3. **Focus**: Detail what and why. Use logic sketches to illustrate how
|
||||
4. **Completeness**: State assumptions clearly when information is incomplete
|
||||
|
||||
## VII. KEY DIRECTIVES & CONSTRAINTS
|
||||
1. **Language**: **All** descriptive parts of your plan **MUST** be in **Chinese**.
|
||||
2. **No Code Generation**: **Strictly refrain** from writing, suggesting, or generating any actual code. Your output is *purely* a descriptive modification plan.
|
||||
3. **Focus on What and Why, Illustrate How (Logic Sketch)**: Detail what needs to be done and why. The call flow sketch illustrates the *intended how* at a logical level, not implementation code.
|
||||
4. **Completeness & Accuracy**: Ensure the plan is comprehensive. If information is insufficient, state assumptions clearly in the 思考过程 (Thinking Process) and 必要上下文 (Necessary Context).
|
||||
5. **Professional Standard**: Your plan should meet the standards expected of a senior technical document, suitable for guiding development work.
|
||||
|
||||
## VIII. SELF-CORRECTION / REFLECTION
|
||||
* Before finalizing your response, review it to ensure:
|
||||
* The 思考过程 (Thinking Process) clearly outlines your structured analytical approach.
|
||||
* All user requirements from 需求分析 have been addressed in the plan.
|
||||
* The modification plan is logical, actionable, and sufficiently detailed, with relevant original code snippets for context.
|
||||
* The 修改理由 (Reason for Modification) explicitly links back to the initial requirements.
|
||||
* All crucial context and risks are highlighted.
|
||||
* The entire output is in professional, clear Chinese and adheres to the specified Markdown structure.
|
||||
* You have strictly avoided generating any code.
|
||||
## Self-Review Checklist
|
||||
Before providing final output, verify:
|
||||
- [ ] Thinking process outlines structured analytical approach
|
||||
- [ ] All requirements addressed in the plan
|
||||
- [ ] Plan is logical, actionable, and detailed
|
||||
- [ ] Modification reasons link back to requirements
|
||||
- [ ] Context and risks are highlighted
|
||||
- [ ] No actual code generated
|
||||
|
||||
@@ -1,620 +0,0 @@
|
||||
# Lite-Fix Command Design Document
|
||||
|
||||
**Date**: 2025-11-20
|
||||
**Version**: 2.0.0 (Simplified Design)
|
||||
**Status**: Design Complete
|
||||
**Related**: PLANNING_GAP_ANALYSIS.md (Scenario #8: Emergency Fix Scenario)
|
||||
|
||||
---
|
||||
|
||||
## Design Overview
|
||||
|
||||
`/workflow:lite-fix` is a lightweight bug diagnosis and fix workflow command that fills the gap in emergency fix scenarios in the current planning system. Designed with reference to the successful `/workflow:lite-plan` pattern, optimized for bug fixing scenarios.
|
||||
|
||||
### Core Design Principles
|
||||
|
||||
1. **Rapid Response** - Supports 15 minutes to 4 hours fix cycles
|
||||
2. **Intelligent Adaptation** - Automatically adjusts workflow complexity based on risk assessment
|
||||
3. **Progressive Verification** - Flexible testing strategy from smoke tests to full suite
|
||||
4. **Automated Follow-up** - Hotfix mode auto-generates comprehensive fix tasks
|
||||
|
||||
### Key Innovation: **Intelligent Self-Adaptation**
|
||||
|
||||
Unlike traditional fixed-mode commands, lite-fix uses **Phase 2 Impact Assessment** to automatically determine severity and adapt the entire workflow:
|
||||
|
||||
```javascript
|
||||
// Phase 2 auto-determines severity
|
||||
risk_score = (user_impact × 0.4) + (system_risk × 0.3) + (business_impact × 0.3)
|
||||
|
||||
// Workflow auto-adapts
|
||||
if (risk_score < 3.0) → Full test suite, comprehensive diagnosis
|
||||
else if (risk_score < 5.0) → Focused integration, moderate diagnosis
|
||||
else if (risk_score < 8.0) → Smoke+critical, focused diagnosis
|
||||
else → Smoke only, minimal diagnosis
|
||||
```
|
||||
|
||||
**Result**: Users don't need to manually select severity modes - the system intelligently adapts.
|
||||
|
||||
---
|
||||
|
||||
## Design Comparison: lite-fix vs lite-plan
|
||||
|
||||
| Dimension | lite-plan | lite-fix (v2.0) | Design Rationale |
|
||||
|-----------|-----------|-----------------|------------------|
|
||||
| **Target Scenario** | New feature development | Bug fixes | Different development intent |
|
||||
| **Time Budget** | 1-6 hours | Auto-adapt (15min-4h) | Bug fixes more urgent |
|
||||
| **Exploration Phase** | Optional (`-e` flag) | Adaptive depth | Bug needs diagnosis |
|
||||
| **Output Type** | Implementation plan | Diagnosis + fix plan | Bug needs root cause |
|
||||
| **Verification Strategy** | Full test suite | Auto-adaptive (Smoke→Full) | Risk vs speed tradeoff |
|
||||
| **Branch Strategy** | Feature branch | Feature/Hotfix branch | Production needs special handling |
|
||||
| **Follow-up Mechanism** | None | Hotfix auto-generates tasks | Technical debt management |
|
||||
| **Intelligence Level** | Manual | **Auto-adaptive** | **Key innovation** |
|
||||
|
||||
---
|
||||
|
||||
## Two-Mode Design (Simplified from Three)
|
||||
|
||||
### Mode 1: Default (Intelligent Auto-Adaptive)
|
||||
|
||||
**Use Cases**:
|
||||
- All standard bugs (90% of scenarios)
|
||||
- Automatic severity assessment
|
||||
- Workflow adapts to risk score
|
||||
|
||||
**Workflow Characteristics**:
|
||||
```
|
||||
Adaptive diagnosis → Impact assessment → Auto-severity detection
|
||||
↓
|
||||
Strategy selection (count based on risk) → Adaptive testing
|
||||
↓
|
||||
Confirmation (dimensions based on risk) → Execution
|
||||
```
|
||||
|
||||
**Example Use Cases**:
|
||||
```bash
|
||||
# Low severity (auto-detected)
|
||||
/workflow:lite-fix "User profile bio field shows HTML tags"
|
||||
# → Full test suite, multiple strategy options, 3-4 hour budget
|
||||
|
||||
# Medium severity (auto-detected)
|
||||
/workflow:lite-fix "Shopping cart occasionally loses items"
|
||||
# → Focused integration tests, best strategy, 1-2 hour budget
|
||||
|
||||
# High severity (auto-detected)
|
||||
/workflow:lite-fix "Login fails for all users after deployment"
|
||||
# → Smoke+critical tests, single strategy, 30-60 min budget
|
||||
```
|
||||
|
||||
### Mode 2: Hotfix (`--hotfix`)
|
||||
|
||||
**Use Cases**:
|
||||
- Production outage only
|
||||
- 100% user impact or business interruption
|
||||
- Requires 15-30 minute fix
|
||||
|
||||
**Workflow Characteristics**:
|
||||
```
|
||||
Minimal diagnosis → Skip assessment (assume critical)
|
||||
↓
|
||||
Surgical fix → Production smoke tests
|
||||
↓
|
||||
Hotfix branch (from production tag) → Auto follow-up tasks
|
||||
```
|
||||
|
||||
**Example Use Case**:
|
||||
```bash
|
||||
/workflow:lite-fix --hotfix "Payment gateway 5xx errors"
|
||||
# → Hotfix branch from v2.3.1 tag, smoke tests only, follow-up tasks auto-generated
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Command Syntax (Simplified)
|
||||
|
||||
### Before (v1.0 - Complex)
|
||||
|
||||
```bash
|
||||
/workflow:lite-fix [--critical|--hotfix] [--incident ID] "bug description"
|
||||
|
||||
# 3 modes, 3 parameters
|
||||
--critical, -c Critical bug mode
|
||||
--hotfix, -h Production hotfix mode
|
||||
--incident <ID> Incident tracking ID
|
||||
```
|
||||
|
||||
**Problems**:
|
||||
- Users need to manually determine severity (Regular vs Critical)
|
||||
- Too many parameters (3 flags)
|
||||
- Incident ID as separate parameter adds complexity
|
||||
|
||||
### After (v2.0 - Simplified)
|
||||
|
||||
```bash
|
||||
/workflow:lite-fix [--hotfix] "bug description"
|
||||
|
||||
# 2 modes, 1 parameter
|
||||
--hotfix, -h Production hotfix mode only
|
||||
```
|
||||
|
||||
**Improvements**:
|
||||
- ✅ Automatic severity detection (no manual selection)
|
||||
- ✅ Single optional flag (67% reduction)
|
||||
- ✅ Incident info can be in bug description
|
||||
- ✅ Matches lite-plan simplicity
|
||||
|
||||
---
|
||||
|
||||
## Intelligent Adaptive Workflow
|
||||
|
||||
### Phase 1: Diagnosis - Adaptive Search Depth
|
||||
|
||||
**Confidence-based Strategy Selection**:
|
||||
|
||||
```javascript
|
||||
// High confidence (specific error message provided)
|
||||
if (has_specific_error_message || has_file_path_hint) {
|
||||
strategy = "direct_grep"
|
||||
time_budget = "5 minutes"
|
||||
grep -r '${error_message}' src/ --include='*.ts' -n | head -10
|
||||
}
|
||||
// Medium confidence (module or feature mentioned)
|
||||
else if (has_module_hint) {
|
||||
strategy = "cli-explore-agent_focused"
|
||||
time_budget = "10-15 minutes"
|
||||
Task(subagent="cli-explore-agent", scope="focused")
|
||||
}
|
||||
// Low confidence (vague symptoms)
|
||||
else {
|
||||
strategy = "cli-explore-agent_broad"
|
||||
time_budget = "20 minutes"
|
||||
Task(subagent="cli-explore-agent", scope="comprehensive")
|
||||
}
|
||||
```
|
||||
|
||||
**Output**:
|
||||
- Root cause (file:line, issue, introduced_by)
|
||||
- Reproduction steps
|
||||
- Affected scope
|
||||
- **Confidence level** (used in Phase 2)
|
||||
|
||||
### Phase 2: Impact Assessment - Auto-Severity Detection
|
||||
|
||||
**Risk Score Calculation**:
|
||||
|
||||
```javascript
|
||||
risk_score = (user_impact × 0.4) + (system_risk × 0.3) + (business_impact × 0.3)
|
||||
|
||||
// Examples:
|
||||
// - UI typo: user_impact=1, system_risk=0, business_impact=0 → risk_score=0.4 (LOW)
|
||||
// - Cart bug: user_impact=5, system_risk=3, business_impact=4 → risk_score=4.1 (MEDIUM)
|
||||
// - Login failure: user_impact=9, system_risk=7, business_impact=8 → risk_score=8.1 (CRITICAL)
|
||||
```
|
||||
|
||||
**Workflow Adaptation Table**:
|
||||
|
||||
| Risk Score | Severity | Diagnosis | Test Strategy | Review | Time Budget |
|
||||
|------------|----------|-----------|---------------|--------|-------------|
|
||||
| **< 3.0** | Low | Comprehensive | Full test suite | Optional | 3-4 hours |
|
||||
| **3.0-5.0** | Medium | Moderate | Focused integration | Optional | 1-2 hours |
|
||||
| **5.0-8.0** | High | Focused | Smoke + critical | Skip | 30-60 min |
|
||||
| **≥ 8.0** | Critical | Minimal | Smoke only | Skip | 15-30 min |
|
||||
|
||||
**Output**:
|
||||
```javascript
|
||||
{
|
||||
risk_score: 6.5,
|
||||
severity: "high",
|
||||
workflow_adaptation: {
|
||||
diagnosis_depth: "focused",
|
||||
test_strategy: "smoke_and_critical",
|
||||
review_optional: true,
|
||||
time_budget: "45_minutes"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Phase 3: Fix Planning - Adaptive Strategy Count
|
||||
|
||||
**Before Phase 2 adaptation**:
|
||||
- Always generate 1-3 strategy options
|
||||
- User manually selects
|
||||
|
||||
**After Phase 2 adaptation**:
|
||||
```javascript
|
||||
if (risk_score < 5.0) {
|
||||
// Low-medium risk: User has time to choose
|
||||
strategies = generateMultipleStrategies() // 2-3 options
|
||||
user_selection = true
|
||||
}
|
||||
else {
|
||||
// High-critical risk: Speed is priority
|
||||
strategies = [selectBestStrategy()] // Single option
|
||||
user_selection = false
|
||||
}
|
||||
```
|
||||
|
||||
**Example**:
|
||||
```javascript
|
||||
// Low risk (risk_score=2.5) → Multiple options
|
||||
[
|
||||
{ strategy: "immediate_patch", time: "15min", pros: ["Quick"], cons: ["Not comprehensive"] },
|
||||
{ strategy: "comprehensive_fix", time: "2h", pros: ["Root cause"], cons: ["Longer"] }
|
||||
]
|
||||
|
||||
// High risk (risk_score=6.5) → Single best
|
||||
{ strategy: "surgical_fix", time: "5min", risk: "minimal" }
|
||||
```
|
||||
|
||||
### Phase 4: Verification - Auto-Test Level Selection
|
||||
|
||||
**Test strategy determined by Phase 2 risk_score**:
|
||||
|
||||
```javascript
|
||||
// Already determined in Phase 2
|
||||
test_strategy = workflow_adaptation.test_strategy
|
||||
|
||||
// Map to specific test commands
|
||||
test_commands = {
|
||||
"full_test_suite": "npm test",
|
||||
"focused_integration": "npm test -- affected-module.test.ts",
|
||||
"smoke_and_critical": "npm test -- critical.smoke.test.ts",
|
||||
"smoke_only": "npm test -- smoke.test.ts"
|
||||
}
|
||||
```
|
||||
|
||||
**Auto-suggested to user** (can override if needed)
|
||||
|
||||
### Phase 5: User Confirmation - Adaptive Dimensions
|
||||
|
||||
**Dimension count adapts to risk score**:
|
||||
|
||||
```javascript
|
||||
dimensions = [
|
||||
"Fix approach confirmation", // Always present
|
||||
"Execution method", // Always present
|
||||
"Verification level" // Always present (auto-suggested)
|
||||
]
|
||||
|
||||
// Optional 4th dimension for low-risk bugs
|
||||
if (risk_score < 5.0) {
|
||||
dimensions.push("Post-fix review") // Only for low-medium severity
|
||||
}
|
||||
```
|
||||
|
||||
**Result**:
|
||||
- High-risk bugs: 3 dimensions (faster confirmation)
|
||||
- Low-risk bugs: 4 dimensions (includes review)
|
||||
|
||||
### Phase 6: Execution - Same as Before
|
||||
|
||||
Dispatch to lite-execute with adapted context.
|
||||
|
||||
---
|
||||
|
||||
## Six-Phase Execution Flow Design
|
||||
|
||||
### Phase Summary Comparison
|
||||
|
||||
| Phase | v1.0 (3 modes) | v2.0 (Adaptive) |
|
||||
|-------|----------------|-----------------|
|
||||
| 1. Diagnosis | Manual mode selection → Fixed depth | Confidence detection → Adaptive depth |
|
||||
| 2. Impact | Assessment only | **Assessment + Auto-severity + Workflow adaptation** |
|
||||
| 3. Planning | Fixed strategy count | **Risk-based strategy count** |
|
||||
| 4. Verification | Manual test selection | **Auto-suggested test level** |
|
||||
| 5. Confirmation | Fixed dimensions | **Adaptive dimensions (3 or 4)** |
|
||||
| 6. Execution | Same | Same |
|
||||
|
||||
**Key Difference**: Phases 2-5 now adapt based on Phase 2 risk score.
|
||||
|
||||
---
|
||||
|
||||
## Data Structure Extensions
|
||||
|
||||
### diagnosisContext (Extended)
|
||||
|
||||
```javascript
|
||||
{
|
||||
symptom: string,
|
||||
error_message: string | null,
|
||||
keywords: string[],
|
||||
confidence_level: "high" | "medium" | "low", // ← NEW: Search confidence
|
||||
root_cause: {
|
||||
file: string,
|
||||
line_range: string,
|
||||
issue: string,
|
||||
introduced_by: string
|
||||
},
|
||||
reproduction_steps: string[],
|
||||
affected_scope: {...}
|
||||
}
|
||||
```
|
||||
|
||||
### impactContext (Extended)
|
||||
|
||||
```javascript
|
||||
{
|
||||
affected_users: {...},
|
||||
system_risk: {...},
|
||||
business_impact: {...},
|
||||
risk_score: number, // 0-10
|
||||
severity: "low" | "medium" | "high" | "critical",
|
||||
workflow_adaptation: { // ← NEW: Adaptation decisions
|
||||
diagnosis_depth: string,
|
||||
test_strategy: string,
|
||||
review_optional: boolean,
|
||||
time_budget: string
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Implementation Roadmap
|
||||
|
||||
### Phase 1: Core Functionality (Sprint 1) - 5-8 days
|
||||
|
||||
**Completed** ✅:
|
||||
- [x] Command specification (lite-fix.md - 652 lines)
|
||||
- [x] Design document (this document)
|
||||
- [x] Mode simplification (3→2)
|
||||
- [x] Parameter reduction (3→1)
|
||||
|
||||
**Remaining**:
|
||||
- [ ] Implement 6-phase workflow
|
||||
- [ ] Implement intelligent adaptation logic
|
||||
- [ ] Integrate with lite-execute
|
||||
|
||||
### Phase 2: Advanced Features (Sprint 2) - 3-5 days
|
||||
|
||||
- [ ] Diagnosis caching mechanism
|
||||
- [ ] Auto-severity keyword detection
|
||||
- [ ] Hotfix branch management scripts
|
||||
- [ ] Follow-up task auto-generation
|
||||
|
||||
### Phase 3: Optimization (Sprint 3) - 2-3 days
|
||||
|
||||
- [ ] Performance optimization (diagnosis speed)
|
||||
- [ ] Error handling refinement
|
||||
- [ ] Documentation and examples
|
||||
- [ ] User feedback iteration
|
||||
|
||||
---
|
||||
|
||||
## Success Metrics
|
||||
|
||||
### Efficiency Improvements
|
||||
|
||||
| Mode | v1.0 Manual Selection | v2.0 Auto-Adaptive | Improvement |
|
||||
|------|----------------------|-------------------|-------------|
|
||||
| Low severity | 4-6 hours (manual Regular) | <3 hours (auto-detected) | 50% faster |
|
||||
| Medium severity | 2-3 hours (need to select Critical) | <1.5 hours (auto-detected) | 40% faster |
|
||||
| High severity | 1-2 hours (if user selects Critical correctly) | <1 hour (auto-detected) | 50% faster |
|
||||
|
||||
**Key**: Users no longer waste time deciding which mode to use.
|
||||
|
||||
### Quality Metrics
|
||||
|
||||
- **Diagnosis Accuracy**: >85% (structured root cause analysis)
|
||||
- **First-time Fix Success Rate**: >90% (comprehensive impact assessment)
|
||||
- **Regression Rate**: <5% (adaptive verification strategy)
|
||||
- **Mode Selection Accuracy**: 100% (automatic, no human error)
|
||||
|
||||
### User Experience
|
||||
|
||||
**v1.0 User Flow**:
|
||||
```
|
||||
User: "Is this bug Regular or Critical? Not sure..."
|
||||
User: "Let me read the mode descriptions again..."
|
||||
User: "OK I'll try --critical"
|
||||
System: "Executing critical mode..." (might be wrong choice)
|
||||
```
|
||||
|
||||
**v2.0 User Flow**:
|
||||
```
|
||||
User: "/workflow:lite-fix 'Shopping cart loses items'"
|
||||
System: "Analyzing impact... Risk score: 6.5 (High severity detected)"
|
||||
System: "Adapting workflow: Focused diagnosis, Smoke+critical tests"
|
||||
User: "Perfect, proceed" (no mode selection needed)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Comparison with Other Commands
|
||||
|
||||
| Command | Modes | Parameters | Adaptation | Complexity |
|
||||
|---------|-------|------------|------------|------------|
|
||||
| `/workflow:lite-fix` (v2.0) | 2 | 1 | **Auto** | Low ✅ |
|
||||
| `/workflow:lite-plan` | 1 + explore flag | 1 | Manual | Low ✅ |
|
||||
| `/workflow:plan` | Multiple | Multiple | Manual | High |
|
||||
| `/workflow:lite-fix` (v1.0) | 3 | 3 | Manual | Medium ❌ |
|
||||
|
||||
**Conclusion**: v2.0 matches lite-plan's simplicity while adding intelligence.
|
||||
|
||||
---
|
||||
|
||||
## Architecture Decision Records (ADRs)
|
||||
|
||||
### ADR-001: Why Remove Critical Mode?
|
||||
|
||||
**Decision**: Remove `--critical` flag, use automatic severity detection
|
||||
|
||||
**Rationale**:
|
||||
1. Users often misjudge bug severity (too conservative or too aggressive)
|
||||
2. Phase 2 impact assessment provides objective risk scoring
|
||||
3. Automatic adaptation eliminates mode selection overhead
|
||||
4. Aligns with "lite" philosophy - simpler is better
|
||||
|
||||
**Alternatives Rejected**:
|
||||
- Keep 3 modes: Too complex, user confusion
|
||||
- Use continuous severity slider (0-10): Still requires manual input
|
||||
|
||||
**Result**: 90% of users can use default mode without thinking about severity.
|
||||
|
||||
### ADR-002: Why Keep Hotfix as Separate Mode?
|
||||
|
||||
**Decision**: Keep `--hotfix` as explicit flag (not auto-detect)
|
||||
|
||||
**Rationale**:
|
||||
1. Production incidents require explicit user intent (safety measure)
|
||||
2. Hotfix has special workflow (branch from production tag, follow-up tasks)
|
||||
3. Clear distinction: "Is this a production incident?" → Yes/No decision
|
||||
4. Prevents accidental hotfix branch creation
|
||||
|
||||
**Alternatives Rejected**:
|
||||
- Auto-detect hotfix based on keywords: Too risky, false positives
|
||||
- Merge into default mode with risk_score≥9.0: Loses explicit intent
|
||||
|
||||
**Result**: Users explicitly choose when to trigger hotfix workflow.
|
||||
|
||||
### ADR-003: Why Adaptive Confirmation Dimensions?
|
||||
|
||||
**Decision**: Use 3 or 4 confirmation dimensions based on risk score
|
||||
|
||||
**Rationale**:
|
||||
1. High-risk bugs need speed → Skip optional code review
|
||||
2. Low-risk bugs have time → Add code review dimension for quality
|
||||
3. Adaptive UX provides best of both worlds
|
||||
|
||||
**Alternatives Rejected**:
|
||||
- Always 4 dimensions: Slows down high-risk fixes
|
||||
- Always 3 dimensions: Misses quality improvement opportunities for low-risk bugs
|
||||
|
||||
**Result**: Workflow adapts to urgency while maintaining quality.
|
||||
|
||||
### ADR-004: Why Remove --incident Parameter?
|
||||
|
||||
**Decision**: Remove `--incident <ID>` parameter
|
||||
|
||||
**Rationale**:
|
||||
1. Incident ID can be included in bug description string
|
||||
2. Or tracked separately in follow-up task metadata
|
||||
3. Reduces command-line parameter count (simplification goal)
|
||||
4. Matches lite-plan's simple syntax
|
||||
|
||||
**Alternatives Rejected**:
|
||||
- Keep as optional parameter: Adds complexity for rare use case
|
||||
- Auto-extract from description: Over-engineering
|
||||
|
||||
**Result**: Simpler command syntax, incident tracking handled elsewhere.
|
||||
|
||||
---
|
||||
|
||||
## Risk Assessment and Mitigation
|
||||
|
||||
### Risk 1: Auto-Severity Detection Errors
|
||||
|
||||
**Risk**: System incorrectly assesses severity (e.g., critical bug marked as low)
|
||||
|
||||
**Mitigation**:
|
||||
1. User can see risk score and severity in Phase 2 output
|
||||
2. User can escalate to `/workflow:plan` if automated assessment seems wrong
|
||||
3. Provide clear explanation of risk score calculation
|
||||
4. Phase 5 confirmation allows user to override test strategy
|
||||
|
||||
**Likelihood**: Low (risk score formula well-tested)
|
||||
|
||||
### Risk 2: Users Miss --hotfix Flag
|
||||
|
||||
**Risk**: Production incident handled as default mode (slower process)
|
||||
|
||||
**Mitigation**:
|
||||
1. Auto-suggest `--hotfix` if keywords detected ("production", "outage", "down")
|
||||
2. If risk_score ≥ 9.0, prompt: "Consider using --hotfix for production incidents"
|
||||
3. Documentation clearly explains when to use hotfix
|
||||
|
||||
**Likelihood**: Medium → Mitigation reduces to Low
|
||||
|
||||
### Risk 3: Adaptive Workflow Confusion
|
||||
|
||||
**Risk**: Users confused by different workflows for different bugs
|
||||
|
||||
**Mitigation**:
|
||||
1. Clear output explaining why workflow adapted ("Risk score: 6.5 → Using focused diagnosis")
|
||||
2. Consistent 6-phase structure (only depth/complexity changes)
|
||||
3. Documentation with examples for each risk level
|
||||
|
||||
**Likelihood**: Low (transparency in adaptation decisions)
|
||||
|
||||
---
|
||||
|
||||
## Gap Coverage from PLANNING_GAP_ANALYSIS.md
|
||||
|
||||
This design addresses **Scenario #8: Emergency Fix Scenario** from the gap analysis:
|
||||
|
||||
| Gap Item | Coverage | Implementation |
|
||||
|----------|----------|----------------|
|
||||
| Workflow simplification | ✅ 100% | 2 modes vs 3, 1 parameter vs 3 |
|
||||
| Fast verification | ✅ 100% | Adaptive test strategy (smoke to full) |
|
||||
| Hotfix branch management | ✅ 100% | Branch from production tag, dual merge |
|
||||
| Comprehensive fix follow-up | ✅ 100% | Auto-generated follow-up tasks |
|
||||
|
||||
**Additional Enhancements** (beyond original gap):
|
||||
- ✅ Intelligent auto-adaptation (not in original gap)
|
||||
- ✅ Risk score calculation (quantitative severity)
|
||||
- ✅ Diagnosis caching (performance optimization)
|
||||
|
||||
---
|
||||
|
||||
## Design Evolution Summary
|
||||
|
||||
### v1.0 → v2.0 Changes
|
||||
|
||||
| Aspect | v1.0 | v2.0 | Impact |
|
||||
|--------|------|------|--------|
|
||||
| **Modes** | 3 (Regular, Critical, Hotfix) | **2 (Default, Hotfix)** | -33% complexity |
|
||||
| **Parameters** | 3 (--critical, --hotfix, --incident) | **1 (--hotfix)** | -67% parameters |
|
||||
| **Adaptation** | Manual mode selection | **Intelligent auto-adaptation** | 🚀 Key innovation |
|
||||
| **User Decision Points** | 3 (mode + incident + confirmation) | **1 (hotfix or not)** | -67% decisions |
|
||||
| **Documentation** | 707 lines | **652 lines** | -8% length |
|
||||
| **Workflow Intelligence** | Low | **High** | Major upgrade |
|
||||
|
||||
### Philosophy Shift
|
||||
|
||||
**v1.0**: "Provide multiple modes for different scenarios"
|
||||
- User selects mode based on perceived severity
|
||||
- Fixed workflows for each mode
|
||||
|
||||
**v2.0**: "Intelligent single mode that adapts to reality"
|
||||
- System assesses actual severity
|
||||
- Workflow automatically optimizes for risk level
|
||||
- User only decides: "Is this a production incident?" (Yes → --hotfix)
|
||||
|
||||
**Result**: Simpler to use, smarter behavior, same powerful capabilities.
|
||||
|
||||
---
|
||||
|
||||
## Conclusion
|
||||
|
||||
`/workflow:lite-fix` v2.0 represents a significant simplification while maintaining (and enhancing) full functionality:
|
||||
|
||||
**Core Achievements**:
|
||||
1. ⚡ **Simplified Interface**: 2 modes, 1 parameter (vs 3 modes, 3 parameters)
|
||||
2. 🧠 **Intelligent Adaptation**: Auto-severity detection with risk score
|
||||
3. 🎯 **Optimized Workflows**: Each bug gets appropriate process depth
|
||||
4. 🛡️ **Quality Assurance**: Adaptive verification strategy
|
||||
5. 📋 **Tech Debt Management**: Hotfix auto-generates follow-up tasks
|
||||
|
||||
**Competitive Advantages**:
|
||||
- Matches lite-plan's simplicity (1 optional flag)
|
||||
- Exceeds lite-plan's intelligence (auto-adaptation)
|
||||
- Solves 90% of bug scenarios without mode selection
|
||||
- Explicit hotfix mode for safety-critical production fixes
|
||||
|
||||
**Expected Impact**:
|
||||
- Reduce bug fix time by 50-70%
|
||||
- Eliminate mode selection errors (100% accuracy)
|
||||
- Improve diagnosis accuracy to 85%+
|
||||
- Systematize technical debt from hotfixes
|
||||
|
||||
**Next Steps**:
|
||||
1. Review this design document
|
||||
2. Approve v2.0 simplified approach
|
||||
3. Implement Phase 1 core functionality (estimated 5-8 days)
|
||||
4. Iterate based on user feedback
|
||||
|
||||
---
|
||||
|
||||
**Document Version**: 2.0.0
|
||||
**Author**: Claude (Sonnet 4.5)
|
||||
**Review Status**: Pending Approval
|
||||
**Implementation Status**: Design Complete, Development Pending
|
||||
File diff suppressed because it is too large
Load Diff
419
WORKFLOW_DECISION_GUIDE_EN.md
Normal file
419
WORKFLOW_DECISION_GUIDE_EN.md
Normal file
@@ -0,0 +1,419 @@
|
||||
# 🌳 CCW Workflow Decision Guide
|
||||
|
||||
This guide helps you choose the right commands and workflows for the complete software development lifecycle.
|
||||
|
||||
---
|
||||
|
||||
## 📊 Full Lifecycle Command Selection Flowchart
|
||||
|
||||
```mermaid
|
||||
flowchart TD
|
||||
Start([Start New Feature/Project]) --> Q1{Know what to build?}
|
||||
|
||||
Q1 -->|No| Ideation[💡 Ideation Phase<br>Requirements Exploration]
|
||||
Q1 -->|Yes| Q2{Know how to build?}
|
||||
|
||||
Ideation --> BrainIdea[/ /workflow:brainstorm:auto-parallel<br>Explore product direction and positioning /]
|
||||
BrainIdea --> Q2
|
||||
|
||||
Q2 -->|No| Design[🏗️ Design Exploration<br>Architecture Solution Discovery]
|
||||
Q2 -->|Yes| Q3{Need UI design?}
|
||||
|
||||
Design --> BrainDesign[/ /workflow:brainstorm:auto-parallel<br>Explore technical solutions and architecture /]
|
||||
BrainDesign --> Q3
|
||||
|
||||
Q3 -->|Yes| UIDesign[🎨 UI Design Phase]
|
||||
Q3 -->|No| Q4{Task complexity?}
|
||||
|
||||
UIDesign --> Q3a{Have reference design?}
|
||||
Q3a -->|Yes| UIImitate[/ /workflow:ui-design:imitate-auto<br>--input reference URL /]
|
||||
Q3a -->|No| UIExplore[/ /workflow:ui-design:explore-auto<br>--prompt design description /]
|
||||
|
||||
UIImitate --> UISync[/ /workflow:ui-design:design-sync<br>Sync design system /]
|
||||
UIExplore --> UISync
|
||||
UISync --> Q4
|
||||
|
||||
Q4 -->|Simple & Quick| LitePlan[⚡ Lightweight Planning<br>/workflow:lite-plan]
|
||||
Q4 -->|Complex & Complete| FullPlan[📋 Full Planning<br>/workflow:plan]
|
||||
|
||||
LitePlan --> Q5{Need code exploration?}
|
||||
Q5 -->|Yes| LitePlanE[/ /workflow:lite-plan -e<br>task description /]
|
||||
Q5 -->|No| LitePlanNormal[/ /workflow:lite-plan<br>task description /]
|
||||
|
||||
LitePlanE --> LiteConfirm[Three-Dimensional Confirmation:<br>1️⃣ Task Approval<br>2️⃣ Execution Method<br>3️⃣ Code Review]
|
||||
LitePlanNormal --> LiteConfirm
|
||||
|
||||
LiteConfirm --> Q6{Choose execution method}
|
||||
Q6 -->|Agent| LiteAgent[/ /workflow:lite-execute<br>Using @code-developer /]
|
||||
Q6 -->|CLI Tools| LiteCLI[CLI Execution<br>Gemini/Qwen/Codex]
|
||||
Q6 -->|Plan Only| UserImpl[Manual User Implementation]
|
||||
|
||||
FullPlan --> PlanVerify{Verify plan quality?}
|
||||
PlanVerify -->|Yes| Verify[/ /workflow:action-plan-verify /]
|
||||
PlanVerify -->|No| Execute
|
||||
Verify --> Q7{Verification passed?}
|
||||
Q7 -->|No| FixPlan[Fix plan issues]
|
||||
Q7 -->|Yes| Execute
|
||||
FixPlan --> Execute
|
||||
|
||||
Execute[🚀 Execution Phase<br>/workflow:execute]
|
||||
LiteAgent --> TestDecision
|
||||
LiteCLI --> TestDecision
|
||||
UserImpl --> TestDecision
|
||||
Execute --> TestDecision
|
||||
|
||||
TestDecision{Need testing?}
|
||||
TestDecision -->|TDD Mode| TDD[/ /workflow:tdd-plan<br>Test-Driven Development /]
|
||||
TestDecision -->|Post-Implementation Testing| TestGen[/ /workflow:test-gen<br>Generate tests /]
|
||||
TestDecision -->|Existing Tests| TestCycle[/ /workflow:test-cycle-execute<br>Test-fix cycle /]
|
||||
TestDecision -->|No| Review
|
||||
|
||||
TDD --> TDDExecute[/ /workflow:execute<br>Red-Green-Refactor /]
|
||||
TDDExecute --> TDDVerify[/ /workflow:tdd-verify<br>Verify TDD compliance /]
|
||||
TDDVerify --> Review
|
||||
|
||||
TestGen --> TestExecute[/ /workflow:execute<br>Execute test tasks /]
|
||||
TestExecute --> TestResult{Tests passed?}
|
||||
TestResult -->|No| TestCycle
|
||||
TestResult -->|Yes| Review
|
||||
|
||||
TestCycle --> TestPass{Pass rate ≥95%?}
|
||||
TestPass -->|No, continue fixing| TestCycle
|
||||
TestPass -->|Yes| Review
|
||||
|
||||
Review[📝 Review Phase]
|
||||
Review --> Q8{Need specialized review?}
|
||||
Q8 -->|Security| SecurityReview[/ /workflow:review<br>--type security /]
|
||||
Q8 -->|Architecture| ArchReview[/ /workflow:review<br>--type architecture /]
|
||||
Q8 -->|Quality| QualityReview[/ /workflow:review<br>--type quality /]
|
||||
Q8 -->|Comprehensive| GeneralReview[/ /workflow:review<br>Comprehensive review /]
|
||||
Q8 -->|No| Complete
|
||||
|
||||
SecurityReview --> Complete
|
||||
ArchReview --> Complete
|
||||
QualityReview --> Complete
|
||||
GeneralReview --> Complete
|
||||
|
||||
Complete[✅ Completion Phase<br>/workflow:session:complete]
|
||||
Complete --> End([Project Complete])
|
||||
|
||||
style Start fill:#e1f5ff
|
||||
style End fill:#c8e6c9
|
||||
style BrainIdea fill:#fff9c4
|
||||
style BrainDesign fill:#fff9c4
|
||||
style UIImitate fill:#f8bbd0
|
||||
style UIExplore fill:#f8bbd0
|
||||
style LitePlan fill:#b3e5fc
|
||||
style FullPlan fill:#b3e5fc
|
||||
style Execute fill:#c5e1a5
|
||||
style TDD fill:#ffccbc
|
||||
style TestGen fill:#ffccbc
|
||||
style TestCycle fill:#ffccbc
|
||||
style Review fill:#d1c4e9
|
||||
style Complete fill:#c8e6c9
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎯 Decision Point Explanations
|
||||
|
||||
### 1️⃣ **Ideation Phase - "Know what to build?"**
|
||||
|
||||
| Situation | Command | Description |
|
||||
|-----------|---------|-------------|
|
||||
| ❌ Uncertain about product direction | `/workflow:brainstorm:auto-parallel "Explore XXX domain product opportunities"` | Multi-role analysis with Product Manager, UX Expert, etc. |
|
||||
| ✅ Clear feature requirements | Skip to design phase | Already know what functionality to build |
|
||||
|
||||
**Examples**:
|
||||
```bash
|
||||
# Uncertain scenario: Want to build a collaboration tool, but unsure what exactly
|
||||
/workflow:brainstorm:auto-parallel "Explore team collaboration tool positioning and core features" --count 5
|
||||
|
||||
# Certain scenario: Building a real-time document collaboration editor (requirements clear)
|
||||
# Skip ideation, move to design phase
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### 2️⃣ **Design Phase - "Know how to build?"**
|
||||
|
||||
| Situation | Command | Description |
|
||||
|-----------|---------|-------------|
|
||||
| ❌ Don't know technical approach | `/workflow:brainstorm:auto-parallel "Design XXX system architecture"` | System Architect, Security Expert analyze technical solutions |
|
||||
| ✅ Clear implementation path | Skip to planning | Already know tech stack, architecture patterns |
|
||||
|
||||
**Examples**:
|
||||
```bash
|
||||
# Don't know how: Real-time collaboration conflict resolution? Which algorithm?
|
||||
/workflow:brainstorm:auto-parallel "Design conflict resolution mechanism for real-time collaborative document editing" --count 4
|
||||
|
||||
# Know how: Using Operational Transformation + WebSocket + Redis
|
||||
# Skip design exploration, go directly to planning
|
||||
/workflow:plan "Implement real-time collaborative editing using OT algorithm, WebSocket communication, Redis storage"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### 3️⃣ **UI Design Phase - "Need UI design?"**
|
||||
|
||||
| Situation | Command | Description |
|
||||
|-----------|---------|-------------|
|
||||
| 🎨 Have reference design | `/workflow:ui-design:imitate-auto --input "URL"` | Copy from existing design |
|
||||
| 🎨 Design from scratch | `/workflow:ui-design:explore-auto --prompt "description"` | Generate multiple design variants |
|
||||
| ⏭️ Backend/No UI | Skip | Pure backend API, CLI tools, etc. |
|
||||
|
||||
**Examples**:
|
||||
```bash
|
||||
# Have reference: Imitate Google Docs collaboration interface
|
||||
/workflow:ui-design:imitate-auto --input "https://docs.google.com"
|
||||
|
||||
# No reference: Design from scratch
|
||||
/workflow:ui-design:explore-auto --prompt "Modern minimalist document collaboration editing interface" --style-variants 3
|
||||
|
||||
# Sync design to project
|
||||
/workflow:ui-design:design-sync --session WFS-xxx --selected-prototypes "v1,v2"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### 4️⃣ **Planning Phase - Choose Workflow Type**
|
||||
|
||||
| Workflow | Use Case | Characteristics |
|
||||
|----------|----------|-----------------|
|
||||
| `/workflow:lite-plan` | Quick tasks, small features | In-memory planning, three-dimensional confirmation, fast execution |
|
||||
| `/workflow:plan` | Complex projects, team collaboration | Persistent plans, quality gates, complete traceability |
|
||||
|
||||
**Lite-Plan Three-Dimensional Confirmation**:
|
||||
1. **Task Approval**: Confirm / Modify / Cancel
|
||||
2. **Execution Method**: Agent / Provide Plan / CLI Tools (Gemini/Qwen/Codex)
|
||||
3. **Code Review**: No / Claude / Gemini / Qwen / Codex
|
||||
|
||||
**Examples**:
|
||||
```bash
|
||||
# Simple task
|
||||
/workflow:lite-plan "Add user avatar upload feature"
|
||||
|
||||
# Need code exploration
|
||||
/workflow:lite-plan -e "Refactor authentication module to OAuth2 standard"
|
||||
|
||||
# Complex project
|
||||
/workflow:plan "Implement complete real-time collaborative editing system"
|
||||
/workflow:action-plan-verify # Verify plan quality
|
||||
/workflow:execute
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### 5️⃣ **Testing Phase - Choose Testing Strategy**
|
||||
|
||||
| Strategy | Command | Use Case |
|
||||
|----------|---------|----------|
|
||||
| **TDD Mode** | `/workflow:tdd-plan` | Starting from scratch, test-driven development |
|
||||
| **Post-Implementation Testing** | `/workflow:test-gen` | Code complete, add tests |
|
||||
| **Test Fixing** | `/workflow:test-cycle-execute` | Existing tests, need to fix failures |
|
||||
|
||||
**Examples**:
|
||||
```bash
|
||||
# TDD: Write tests first, then implement
|
||||
/workflow:tdd-plan "User authentication module"
|
||||
/workflow:execute # Red-Green-Refactor cycle
|
||||
/workflow:tdd-verify # Verify TDD compliance
|
||||
|
||||
# Post-implementation testing: Add tests after code complete
|
||||
/workflow:test-gen WFS-user-auth-implementation
|
||||
/workflow:execute
|
||||
|
||||
# Test fixing: Existing tests with high failure rate
|
||||
/workflow:test-cycle-execute --max-iterations 5
|
||||
# Auto-iterate fixes until pass rate ≥95%
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### 6️⃣ **Review Phase - Choose Review Type**
|
||||
|
||||
| Type | Command | Focus |
|
||||
|------|---------|-------|
|
||||
| **Security Review** | `/workflow:review --type security` | SQL injection, XSS, authentication vulnerabilities |
|
||||
| **Architecture Review** | `/workflow:review --type architecture` | Design patterns, coupling, scalability |
|
||||
| **Quality Review** | `/workflow:review --type quality` | Code style, complexity, maintainability |
|
||||
| **Comprehensive Review** | `/workflow:review` | All-around inspection |
|
||||
|
||||
**Examples**:
|
||||
```bash
|
||||
# Security-critical system
|
||||
/workflow:review --type security
|
||||
|
||||
# After architecture refactoring
|
||||
/workflow:review --type architecture
|
||||
|
||||
# Daily development
|
||||
/workflow:review --type quality
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔄 Complete Flow for Typical Scenarios
|
||||
|
||||
### Scenario A: New Feature Development (Know How to Build)
|
||||
|
||||
```bash
|
||||
# 1. Planning
|
||||
/workflow:plan "Add JWT authentication and permission management"
|
||||
|
||||
# 2. Verify plan
|
||||
/workflow:action-plan-verify
|
||||
|
||||
# 3. Execute
|
||||
/workflow:execute
|
||||
|
||||
# 4. Testing
|
||||
/workflow:test-gen WFS-jwt-auth
|
||||
/workflow:execute
|
||||
|
||||
# 5. Review
|
||||
/workflow:review --type security
|
||||
|
||||
# 6. Complete
|
||||
/workflow:session:complete
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Scenario B: New Feature Development (Don't Know How to Build)
|
||||
|
||||
```bash
|
||||
# 1. Design exploration
|
||||
/workflow:brainstorm:auto-parallel "Design distributed cache system architecture" --count 5
|
||||
|
||||
# 2. UI design (if needed)
|
||||
/workflow:ui-design:explore-auto --prompt "Cache management dashboard interface"
|
||||
/workflow:ui-design:design-sync --session WFS-xxx
|
||||
|
||||
# 3. Planning
|
||||
/workflow:plan
|
||||
|
||||
# 4. Verification
|
||||
/workflow:action-plan-verify
|
||||
|
||||
# 5. Execution
|
||||
/workflow:execute
|
||||
|
||||
# 6. TDD testing
|
||||
/workflow:tdd-plan "Cache system core modules"
|
||||
/workflow:execute
|
||||
|
||||
# 7. Review
|
||||
/workflow:review --type architecture
|
||||
/workflow:review --type security
|
||||
|
||||
# 8. Complete
|
||||
/workflow:session:complete
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Scenario C: Quick Feature Development (Lite Workflow)
|
||||
|
||||
```bash
|
||||
# 1. Lightweight planning (may need code exploration)
|
||||
/workflow:lite-plan -e "Optimize database query performance"
|
||||
|
||||
# 2. Three-dimensional confirmation
|
||||
# - Confirm task
|
||||
# - Choose Agent execution
|
||||
# - Choose Gemini code review
|
||||
|
||||
# 3. Auto-execution (called internally by /workflow:lite-execute)
|
||||
|
||||
# 4. Complete
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Scenario D: Bug Fixing
|
||||
|
||||
```bash
|
||||
# 1. Diagnosis
|
||||
/cli:mode:bug-diagnosis --tool gemini "User login fails with token expired error"
|
||||
|
||||
# 2. Quick fix
|
||||
/workflow:lite-plan "Fix JWT token expiration validation logic"
|
||||
|
||||
# 3. Test fix
|
||||
/workflow:test-cycle-execute
|
||||
|
||||
# 4. Complete
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎓 Quick Command Reference
|
||||
|
||||
### Choose by Knowledge Level
|
||||
|
||||
| Your Situation | Recommended Command |
|
||||
|----------------|---------------------|
|
||||
| 💭 Don't know what to build | `/workflow:brainstorm:auto-parallel "Explore product direction"` |
|
||||
| ❓ Know what, don't know how | `/workflow:brainstorm:auto-parallel "Design technical solution"` |
|
||||
| ✅ Know what and how | `/workflow:plan "Specific implementation description"` |
|
||||
| ⚡ Simple, clear small task | `/workflow:lite-plan "Task description"` |
|
||||
| 🐛 Bug fixing | `/cli:mode:bug-diagnosis` + `/workflow:lite-plan` |
|
||||
|
||||
### Choose by Project Phase
|
||||
|
||||
| Phase | Command |
|
||||
|-------|---------|
|
||||
| 📋 **Requirements Analysis** | `/workflow:brainstorm:auto-parallel` |
|
||||
| 🏗️ **Architecture Design** | `/workflow:brainstorm:auto-parallel` |
|
||||
| 🎨 **UI Design** | `/workflow:ui-design:explore-auto` / `imitate-auto` |
|
||||
| 📝 **Implementation Planning** | `/workflow:plan` / `/workflow:lite-plan` |
|
||||
| 🚀 **Coding Implementation** | `/workflow:execute` / `/workflow:lite-execute` |
|
||||
| 🧪 **Testing** | `/workflow:tdd-plan` / `/workflow:test-gen` |
|
||||
| 🔧 **Test Fixing** | `/workflow:test-cycle-execute` |
|
||||
| 📖 **Code Review** | `/workflow:review` |
|
||||
| ✅ **Project Completion** | `/workflow:session:complete` |
|
||||
|
||||
### Choose by Work Mode
|
||||
|
||||
| Mode | Workflow | Use Case |
|
||||
|------|----------|----------|
|
||||
| **🚀 Agile & Fast** | Lite Workflow | Personal dev, rapid iteration, prototype validation |
|
||||
| **📋 Standard & Complete** | Full Workflow | Team collaboration, enterprise projects, long-term maintenance |
|
||||
| **🧪 Quality-First** | TDD Workflow | Core modules, critical features, high reliability requirements |
|
||||
| **🎨 Design-Driven** | UI-Design Workflow | Frontend projects, user interfaces, design systems |
|
||||
|
||||
---
|
||||
|
||||
## 💡 Expert Advice
|
||||
|
||||
### ✅ Best Practices
|
||||
|
||||
1. **Use brainstorming when uncertain**: Better to spend 10 minutes exploring solutions than blindly implementing and rewriting
|
||||
2. **Use Full workflow for complex projects**: Persistent plans facilitate team collaboration and long-term maintenance
|
||||
3. **Use Lite workflow for small tasks**: Complete quickly, reduce overhead
|
||||
4. **Use TDD for critical modules**: Test-driven development ensures quality
|
||||
5. **Regularly update memory**: `/memory:update-related` keeps context accurate
|
||||
|
||||
### ❌ Common Pitfalls
|
||||
|
||||
1. **Blindly skipping brainstorming**: Not exploring unfamiliar technical domains leads to rework
|
||||
2. **Overusing brainstorming**: Brainstorming even simple features wastes time
|
||||
3. **Ignoring plan verification**: Not running `/workflow:action-plan-verify` causes execution issues
|
||||
4. **Ignoring testing**: Not generating tests, code quality cannot be guaranteed
|
||||
5. **Not completing sessions**: Not running `/workflow:session:complete` causes session state confusion
|
||||
|
||||
---
|
||||
|
||||
## 🔗 Related Documentation
|
||||
|
||||
- [Getting Started Guide](GETTING_STARTED.md) - Quick start tutorial
|
||||
- [Command Reference](COMMAND_REFERENCE.md) - Complete command list
|
||||
- [Architecture Overview](ARCHITECTURE.md) - System architecture explanation
|
||||
- [Examples](EXAMPLES.md) - Real-world scenario examples
|
||||
- [FAQ](FAQ.md) - Frequently asked questions
|
||||
|
||||
---
|
||||
|
||||
**Last Updated**: 2025-11-20
|
||||
**Version**: 5.8.1
|
||||
Reference in New Issue
Block a user