feat(web): implement schedule editor in MaintenancePoliciesTab
CI / changes (push) Successful in 8s
CI / commitlint (push) Has been skipped
CI / openapi (push) Has been skipped
CI / web (push) Successful in 31s
CI / go (push) Successful in 51s
CI / bird2 (push) Successful in 15s
CI / release (push) Successful in 3m48s
CI / changes (push) Successful in 8s
CI / commitlint (push) Has been skipped
CI / openapi (push) Has been skipped
CI / web (push) Successful in 31s
CI / go (push) Successful in 51s
CI / bird2 (push) Successful in 15s
CI / release (push) Successful in 3m48s
Enhanced the MaintenancePoliciesTab by integrating a schedule editor for maintenance policies. Users can now select schedule modes, input custom cron expressions, and dynamically update the schedule preview. This update improves the user interface and experience for managing maintenance schedules.
This commit is contained in:
Denozordec
@@ -0,0 +1,272 @@
|
||||
---
|
||||
description: Visual process map for ARCHIVE mode (Task Documentation)
|
||||
globs: "**/archive*/**", "**/document*/**", "**/complete*/**"
|
||||
alwaysApply: false
|
||||
---
|
||||
|
||||
# ARCHIVE MODE: TASK DOCUMENTATION PROCESS MAP
|
||||
|
||||
> **TL;DR:** This visual map guides the ARCHIVE mode process, focusing on creating comprehensive documentation of the completed task, archiving relevant files, and updating the Memory Bank for future reference.
|
||||
|
||||
## 🧭 ARCHIVE MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["START ARCHIVE MODE"] --> ReadTasks["Read tasks.md<br>reflection.md and<br>progress.md"]
|
||||
|
||||
%% Initial Assessment
|
||||
ReadTasks --> VerifyReflect{"Reflection<br>Complete?"}
|
||||
VerifyReflect -->|"No"| ReturnReflect["Return to<br>REFLECT Mode"]
|
||||
VerifyReflect -->|"Yes"| AssessLevel{"Determine<br>Complexity Level"}
|
||||
|
||||
%% Level-Based Archiving
|
||||
AssessLevel -->|"Level 1"| L1Archive["LEVEL 1 ARCHIVING"]
|
||||
AssessLevel -->|"Level 2"| L2Archive["LEVEL 2 ARCHIVING<br>Level2/archive-basic.mdc"]
|
||||
AssessLevel -->|"Level 3"| L3Archive["LEVEL 3 ARCHIVING<br>Level3/archive-intermediate.mdc"]
|
||||
AssessLevel -->|"Level 4"| L4Archive["LEVEL 4 ARCHIVING<br>Level4/archive-comprehensive.mdc"]
|
||||
|
||||
%% Level 1 Archiving (Minimal)
|
||||
L1Archive --> L1Summary["Create Quick<br>Summary"]
|
||||
L1Summary --> L1Task["Update<br>tasks.md"]
|
||||
L1Task --> L1Complete["Mark Task<br>Complete"]
|
||||
|
||||
%% Level 2 Archiving (Basic)
|
||||
L2Archive --> L2Summary["Create Basic<br>Archive Document"]
|
||||
L2Summary --> L2Doc["Document<br>Changes"]
|
||||
L2Doc --> L2Task["Update<br>tasks.md"]
|
||||
L2Task --> L2Progress["Update<br>progress.md"]
|
||||
L2Progress --> L2Complete["Mark Task<br>Complete"]
|
||||
|
||||
%% Level 3-4 Archiving (Comprehensive)
|
||||
L3Archive & L4Archive --> L34Summary["Create Comprehensive<br>Archive Document"]
|
||||
L34Summary --> L34Doc["Document<br>Implementation"]
|
||||
L34Doc --> L34Creative["Archive Creative<br>Phase Documents"]
|
||||
L34Creative --> L34Code["Document Code<br>Changes"]
|
||||
L34Code --> L34Test["Document<br>Testing"]
|
||||
L34Test --> L34Lessons["Summarize<br>Lessons Learned"]
|
||||
L34Lessons --> L34Task["Update<br>tasks.md"]
|
||||
L34Task --> L34Progress["Update<br>progress.md"]
|
||||
L34Progress --> L34System["Update System<br>Documentation"]
|
||||
L34System --> L34Complete["Mark Task<br>Complete"]
|
||||
|
||||
%% Completion
|
||||
L1Complete & L2Complete & L34Complete --> CreateArchive["Create Archive<br>Document in<br>docs/archive/"]
|
||||
CreateArchive --> UpdateActive["Update<br>activeContext.md"]
|
||||
UpdateActive --> Reset["Reset for<br>Next Task"]
|
||||
```
|
||||
|
||||
## 📋 ARCHIVE DOCUMENT STRUCTURE
|
||||
|
||||
The archive document should follow this structured format:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Archive Document Structure"
|
||||
Header["# TASK ARCHIVE: [Task Name]"]
|
||||
Meta["## METADATA<br>Task info, dates, complexity"]
|
||||
Summary["## SUMMARY<br>Brief overview of the task"]
|
||||
Requirements["## REQUIREMENTS<br>What the task needed to accomplish"]
|
||||
Implementation["## IMPLEMENTATION<br>How the task was implemented"]
|
||||
Testing["## TESTING<br>How the solution was verified"]
|
||||
Lessons["## LESSONS LEARNED<br>Key takeaways from the task"]
|
||||
Refs["## REFERENCES<br>Links to related documents"]
|
||||
end
|
||||
|
||||
Header --> Meta --> Summary --> Requirements --> Implementation --> Testing --> Lessons --> Refs
|
||||
```
|
||||
|
||||
## 📊 REQUIRED FILE STATE VERIFICATION
|
||||
|
||||
Before archiving can begin, verify file state:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["File State<br>Verification"] --> CheckTasks{"tasks.md has<br>reflection<br>complete?"}
|
||||
|
||||
CheckTasks -->|"No"| ErrorReflect["ERROR:<br>Return to REFLECT Mode"]
|
||||
CheckTasks -->|"Yes"| CheckReflection{"reflection.md<br>exists?"}
|
||||
|
||||
CheckReflection -->|"No"| ErrorCreate["ERROR:<br>Create reflection.md first"]
|
||||
CheckReflection -->|"Yes"| CheckProgress{"progress.md<br>updated?"}
|
||||
|
||||
CheckProgress -->|"No"| ErrorProgress["ERROR:<br>Update progress.md first"]
|
||||
CheckProgress -->|"Yes"| ReadyArchive["Ready for<br>Archiving"]
|
||||
```
|
||||
|
||||
## 🔍 ARCHIVE TYPES BY COMPLEXITY
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Level 1: Minimal Archive"
|
||||
L1A["Basic Bug<br>Description"]
|
||||
L1B["Solution<br>Summary"]
|
||||
L1C["Affected<br>Files"]
|
||||
end
|
||||
|
||||
subgraph "Level 2: Basic Archive"
|
||||
L2A["Enhancement<br>Description"]
|
||||
L2B["Implementation<br>Summary"]
|
||||
L2C["Testing<br>Results"]
|
||||
L2D["Lessons<br>Learned"]
|
||||
end
|
||||
|
||||
subgraph "Level 3-4: Comprehensive Archive"
|
||||
L3A["Detailed<br>Requirements"]
|
||||
L3B["Architecture/<br>Design Decisions"]
|
||||
L3C["Implementation<br>Details"]
|
||||
L3D["Testing<br>Strategy"]
|
||||
L3E["Performance<br>Considerations"]
|
||||
L3F["Future<br>Enhancements"]
|
||||
L3G["Cross-References<br>to Other Systems"]
|
||||
end
|
||||
|
||||
L1A --> L1B --> L1C
|
||||
|
||||
L2A --> L2B --> L2C --> L2D
|
||||
|
||||
L3A --> L3B --> L3C --> L3D --> L3E --> L3F --> L3G
|
||||
```
|
||||
|
||||
## 📝 ARCHIVE DOCUMENT TEMPLATES
|
||||
|
||||
### Level 1 (Minimal) Archive
|
||||
```
|
||||
# Bug Fix Archive: [Bug Name]
|
||||
|
||||
## Date
|
||||
[Date of fix]
|
||||
|
||||
## Summary
|
||||
[Brief description of the bug and solution]
|
||||
|
||||
## Implementation
|
||||
[Description of the fix implemented]
|
||||
|
||||
## Files Changed
|
||||
- [File 1]
|
||||
- [File 2]
|
||||
```
|
||||
|
||||
### Levels 2-4 (Comprehensive) Archive
|
||||
```
|
||||
# Task Archive: [Task Name]
|
||||
|
||||
## Metadata
|
||||
- **Complexity**: Level [2/3/4]
|
||||
- **Type**: [Enhancement/Feature/System]
|
||||
- **Date Completed**: [Date]
|
||||
- **Related Tasks**: [Related task references]
|
||||
|
||||
## Summary
|
||||
[Comprehensive summary of the task]
|
||||
|
||||
## Requirements
|
||||
- [Requirement 1]
|
||||
- [Requirement 2]
|
||||
- [Requirement 3]
|
||||
|
||||
## Implementation
|
||||
### Approach
|
||||
[Description of implementation approach]
|
||||
|
||||
### Key Components
|
||||
- [Component 1]: [Description]
|
||||
- [Component 2]: [Description]
|
||||
|
||||
### Files Changed
|
||||
- [File 1]: [Description of changes]
|
||||
- [File 2]: [Description of changes]
|
||||
|
||||
## Testing
|
||||
- [Test 1]: [Result]
|
||||
- [Test 2]: [Result]
|
||||
|
||||
## Lessons Learned
|
||||
- [Lesson 1]
|
||||
- [Lesson 2]
|
||||
- [Lesson 3]
|
||||
|
||||
## Future Considerations
|
||||
- [Future enhancement 1]
|
||||
- [Future enhancement 2]
|
||||
|
||||
## References
|
||||
- [Link to reflection document]
|
||||
- [Link to creative phase documents]
|
||||
- [Other relevant references]
|
||||
```
|
||||
|
||||
## 📋 ARCHIVE LOCATION AND NAMING
|
||||
|
||||
Archive documents should be organized following this pattern:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Archive Structure"
|
||||
Root["docs/archive/"]
|
||||
Tasks["tasks/"]
|
||||
Features["features/"]
|
||||
Systems["systems/"]
|
||||
|
||||
Root --> Tasks
|
||||
Root --> Features
|
||||
Root --> Systems
|
||||
|
||||
Tasks --> Bug["bug-fix-name-YYYYMMDD.md"]
|
||||
Tasks --> Enhancement["enhancement-name-YYYYMMDD.md"]
|
||||
Features --> Feature["feature-name-YYYYMMDD.md"]
|
||||
Systems --> System["system-name-YYYYMMDD.md"]
|
||||
end
|
||||
```
|
||||
|
||||
## 📊 TASKS.MD FINAL UPDATE
|
||||
|
||||
When archiving is complete, update tasks.md with:
|
||||
|
||||
```
|
||||
## Status
|
||||
- [x] Initialization complete
|
||||
- [x] Planning complete
|
||||
[For Level 3-4:]
|
||||
- [x] Creative phases complete
|
||||
- [x] Implementation complete
|
||||
- [x] Reflection complete
|
||||
- [x] Archiving complete
|
||||
|
||||
## Archive
|
||||
- **Date**: [Completion date]
|
||||
- **Archive Document**: [Link to archive document]
|
||||
- **Status**: COMPLETED
|
||||
```
|
||||
|
||||
## 📋 ARCHIVE VERIFICATION CHECKLIST
|
||||
|
||||
```
|
||||
✓ ARCHIVE VERIFICATION
|
||||
- Reflection document reviewed? [YES/NO]
|
||||
- Archive document created with all sections? [YES/NO]
|
||||
- Archive document placed in correct location? [YES/NO]
|
||||
- tasks.md marked as completed? [YES/NO]
|
||||
- progress.md updated with archive reference? [YES/NO]
|
||||
- activeContext.md updated for next task? [YES/NO]
|
||||
- Creative phase documents archived (Level 3-4)? [YES/NO/NA]
|
||||
|
||||
→ If all YES: Archiving complete - Memory Bank reset for next task
|
||||
→ If any NO: Complete missing archive elements
|
||||
```
|
||||
|
||||
## 🔄 TASK COMPLETION NOTIFICATION
|
||||
|
||||
When archiving is complete, notify user with:
|
||||
|
||||
```
|
||||
## TASK ARCHIVED
|
||||
|
||||
✅ Archive document created in docs/archive/
|
||||
✅ All task documentation preserved
|
||||
✅ Memory Bank updated with references
|
||||
✅ Task marked as COMPLETED
|
||||
|
||||
→ Memory Bank is ready for the next task
|
||||
→ To start a new task, use VAN MODE
|
||||
```
|
||||
@@ -0,0 +1,321 @@
|
||||
---
|
||||
description: Visual process map for BUILD mode (Code Implementation)
|
||||
globs: implementation-mode-map.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
|
||||
# BUILD MODE: CODE EXECUTION PROCESS MAP
|
||||
|
||||
> **TL;DR:** This visual map guides the BUILD mode process, focusing on efficient code implementation based on the planning and creative phases, with proper command execution and progress tracking.
|
||||
|
||||
## 🧭 BUILD MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["START BUILD MODE"] --> ReadDocs["Read Reference Documents<br>Core/command-execution.md"]
|
||||
|
||||
%% Initialization
|
||||
ReadDocs --> CheckLevel{"Determine<br>Complexity Level<br>from tasks.md"}
|
||||
|
||||
%% Level 1 Implementation
|
||||
CheckLevel -->|"Level 1<br>Quick Bug Fix"| L1Process["LEVEL 1 PROCESS<br>Level1/quick-bug-workflow.md"]
|
||||
L1Process --> L1Review["Review Bug<br>Report"]
|
||||
L1Review --> L1Examine["Examine<br>Relevant Code"]
|
||||
L1Examine --> L1Fix["Implement<br>Targeted Fix"]
|
||||
L1Fix --> L1Test["Test<br>Fix"]
|
||||
L1Test --> L1Update["Update<br>tasks.md"]
|
||||
|
||||
%% Level 2 Implementation
|
||||
CheckLevel -->|"Level 2<br>Simple Enhancement"| L2Process["LEVEL 2 PROCESS<br>Level2/enhancement-workflow.md"]
|
||||
L2Process --> L2Review["Review Build<br>Plan"]
|
||||
L2Review --> L2Examine["Examine Relevant<br>Code Areas"]
|
||||
L2Examine --> L2Implement["Implement Changes<br>Sequentially"]
|
||||
L2Implement --> L2Test["Test<br>Changes"]
|
||||
L2Test --> L2Update["Update<br>tasks.md"]
|
||||
|
||||
%% Level 3-4 Implementation
|
||||
CheckLevel -->|"Level 3-4<br>Feature/System"| L34Process["LEVEL 3-4 PROCESS<br>Level3/feature-workflow.md<br>Level4/system-workflow.md"]
|
||||
L34Process --> L34Review["Review Plan &<br>Creative Decisions"]
|
||||
L34Review --> L34Phase{"Creative Phase<br>Documents<br>Complete?"}
|
||||
|
||||
L34Phase -->|"No"| L34Error["ERROR:<br>Return to CREATIVE Mode"]
|
||||
L34Phase -->|"Yes"| L34DirSetup["Create Directory<br>Structure"]
|
||||
L34DirSetup --> L34VerifyDirs["VERIFY Directories<br>Created Successfully"]
|
||||
L34VerifyDirs --> L34Implementation["Build<br>Phase"]
|
||||
|
||||
%% Implementation Phases
|
||||
L34Implementation --> L34Phase1["Phase 1<br>Build"]
|
||||
L34Phase1 --> L34VerifyFiles["VERIFY Files<br>Created Successfully"]
|
||||
L34VerifyFiles --> L34Test1["Test<br>Phase 1"]
|
||||
L34Test1 --> L34Document1["Document<br>Phase 1"]
|
||||
L34Document1 --> L34Next1{"Next<br>Phase?"}
|
||||
L34Next1 -->|"Yes"| L34Implementation
|
||||
|
||||
L34Next1 -->|"No"| L34Integration["Integration<br>Testing"]
|
||||
L34Integration --> L34Document["Document<br>Integration Points"]
|
||||
L34Document --> L34Update["Update<br>tasks.md"]
|
||||
|
||||
%% Command Execution
|
||||
L1Fix & L2Implement & L34Phase1 --> CommandExec["COMMAND EXECUTION<br>Core/command-execution.md"]
|
||||
CommandExec --> DocCommands["Document Commands<br>& Results"]
|
||||
|
||||
%% Completion & Transition
|
||||
L1Update & L2Update & L34Update --> VerifyComplete["Verify Build<br>Complete"]
|
||||
VerifyComplete --> UpdateProgress["Update progress.md<br>with Status"]
|
||||
UpdateProgress --> Transition["NEXT MODE:<br>REFLECT MODE"]
|
||||
```
|
||||
|
||||
## 📋 REQUIRED FILE STATE VERIFICATION
|
||||
|
||||
Before implementation can begin, verify file state:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["File State<br>Verification"] --> CheckTasks{"tasks.md has<br>planning complete?"}
|
||||
|
||||
CheckTasks -->|"No"| ErrorPlan["ERROR:<br>Return to PLAN Mode"]
|
||||
CheckTasks -->|"Yes"| CheckLevel{"Task<br>Complexity?"}
|
||||
|
||||
CheckLevel -->|"Level 1"| L1Ready["Ready for<br>Implementation"]
|
||||
|
||||
CheckLevel -->|"Level 2"| L2Ready["Ready for<br>Implementation"]
|
||||
|
||||
CheckLevel -->|"Level 3-4"| CheckCreative{"Creative phases<br>required?"}
|
||||
|
||||
CheckCreative -->|"No"| L34Ready["Ready for<br>Implementation"]
|
||||
CheckCreative -->|"Yes"| VerifyCreative{"Creative phases<br>completed?"}
|
||||
|
||||
VerifyCreative -->|"No"| ErrorCreative["ERROR:<br>Return to CREATIVE Mode"]
|
||||
VerifyCreative -->|"Yes"| L34Ready
|
||||
```
|
||||
|
||||
## 🔄 FILE SYSTEM VERIFICATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Start File<br>Verification"] --> CheckDir["Check Directory<br>Structure"]
|
||||
CheckDir --> DirResult{"Directories<br>Exist?"}
|
||||
|
||||
DirResult -->|"No"| ErrorDir["❌ ERROR:<br>Missing Directories"]
|
||||
DirResult -->|"Yes"| CheckFiles["Check Each<br>Created File"]
|
||||
|
||||
ErrorDir --> FixDir["Fix Directory<br>Structure"]
|
||||
FixDir --> CheckDir
|
||||
|
||||
CheckFiles --> FileResult{"All Files<br>Exist?"}
|
||||
FileResult -->|"No"| ErrorFile["❌ ERROR:<br>Missing/Wrong Path Files"]
|
||||
FileResult -->|"Yes"| Complete["✅ Verification<br>Complete"]
|
||||
|
||||
ErrorFile --> FixFile["Fix File Paths<br>or Recreate Files"]
|
||||
FixFile --> CheckFiles
|
||||
```
|
||||
|
||||
## 📋 DIRECTORY VERIFICATION STEPS
|
||||
|
||||
Before beginning any file creation:
|
||||
|
||||
```
|
||||
✓ DIRECTORY VERIFICATION PROCEDURE
|
||||
1. Create all directories first before any files
|
||||
2. Use ABSOLUTE paths: /full/path/to/directory
|
||||
3. Verify each directory after creation:
|
||||
ls -la /full/path/to/directory # Linux/Mac
|
||||
dir "C:\full\path\to\directory" # Windows
|
||||
4. Document directory structure in progress.md
|
||||
5. Only proceed to file creation AFTER verifying ALL directories exist
|
||||
```
|
||||
|
||||
## 📋 FILE CREATION VERIFICATION
|
||||
|
||||
After creating files:
|
||||
|
||||
```
|
||||
✓ FILE VERIFICATION PROCEDURE
|
||||
1. Use ABSOLUTE paths for all file operations: /full/path/to/file.ext
|
||||
2. Verify each file creation was successful:
|
||||
ls -la /full/path/to/file.ext # Linux/Mac
|
||||
dir "C:\full\path\to\file.ext" # Windows
|
||||
3. If verification fails:
|
||||
a. Check for path resolution issues
|
||||
b. Verify directory exists
|
||||
c. Try creating with corrected path
|
||||
d. Recheck file exists after correction
|
||||
4. Document all file paths in progress.md
|
||||
```
|
||||
|
||||
## 🔄 COMMAND EXECUTION WORKFLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Command<br>Execution"] --> Analyze["Analyze Command<br>Requirements"]
|
||||
Analyze --> Complexity{"Command<br>Complexity?"}
|
||||
|
||||
Complexity -->|"Simple"| Simple["Execute<br>Single Command"]
|
||||
Complexity -->|"Moderate"| Chain["Use Efficient<br>Command Chaining"]
|
||||
Complexity -->|"Complex"| Break["Break Into<br>Logical Steps"]
|
||||
|
||||
Simple & Chain & Break --> Verify["Verify<br>Results"]
|
||||
Verify --> Document["Document<br>Command & Result"]
|
||||
Document --> Next["Next<br>Command"]
|
||||
```
|
||||
|
||||
## 📋 LEVEL-SPECIFIC BUILD APPROACHES
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Level 1: Quick Bug Fix"
|
||||
L1A["Targeted Code<br>Examination"]
|
||||
L1B["Minimal<br>Change Scope"]
|
||||
L1C["Direct<br>Fix"]
|
||||
L1D["Verify<br>Fix"]
|
||||
end
|
||||
|
||||
subgraph "Level 2: Enhancement"
|
||||
L2A["Sequential<br>Build"]
|
||||
L2B["Contained<br>Changes"]
|
||||
L2C["Standard<br>Testing"]
|
||||
L2D["Component<br>Documentation"]
|
||||
end
|
||||
|
||||
subgraph "Level 3-4: Feature/System"
|
||||
L3A["Directory<br>Structure First"]
|
||||
L3B["Verify Dirs<br>Before Files"]
|
||||
L3C["Phased<br>Build"]
|
||||
L3D["Verify Files<br>After Creation"]
|
||||
L3E["Integration<br>Testing"]
|
||||
L3F["Detailed<br>Documentation"]
|
||||
end
|
||||
|
||||
L1A --> L1B --> L1C --> L1D
|
||||
L2A --> L2B --> L2C --> L2D
|
||||
L3A --> L3B --> L3C --> L3D --> L3E --> L3F
|
||||
```
|
||||
|
||||
## 📝 BUILD DOCUMENTATION FORMAT
|
||||
|
||||
Document builds with:
|
||||
|
||||
```
|
||||
## Build: [Component/Feature]
|
||||
|
||||
### Approach
|
||||
[Brief description of build approach]
|
||||
|
||||
### Directory Structure
|
||||
- [/absolute/path/to/dir1/]: [Purpose]
|
||||
- [/absolute/path/to/dir2/]: [Purpose]
|
||||
|
||||
### Code Changes
|
||||
- [/absolute/path/to/file1.ext]: [Description of changes]
|
||||
- [/absolute/path/to/file2.ext]: [Description of changes]
|
||||
|
||||
### Verification Steps
|
||||
- [✓] Directory structure created and verified
|
||||
- [✓] All files created in correct locations
|
||||
- [✓] File content verified
|
||||
|
||||
### Commands Executed
|
||||
```
|
||||
[Command 1]
|
||||
[Result]
|
||||
```
|
||||
|
||||
```
|
||||
[Command 2]
|
||||
[Result]
|
||||
```
|
||||
|
||||
### Testing
|
||||
- [Test 1]: [Result]
|
||||
- [Test 2]: [Result]
|
||||
|
||||
### Status
|
||||
- [x] Build complete
|
||||
- [x] Testing performed
|
||||
- [x] File verification completed
|
||||
- [ ] Documentation updated
|
||||
```
|
||||
|
||||
## 📊 TASKS.MD UPDATE FORMAT
|
||||
|
||||
During the build process, update tasks.md with progress:
|
||||
|
||||
```
|
||||
## Status
|
||||
- [x] Initialization complete
|
||||
- [x] Planning complete
|
||||
[For Level 3-4:]
|
||||
- [x] Creative phases complete
|
||||
- [x] Directory structure created and verified
|
||||
- [x] [Built component 1]
|
||||
- [x] [Built component 2]
|
||||
- [ ] [Remaining component]
|
||||
|
||||
## Build Progress
|
||||
- [Component 1]: Complete
|
||||
- Files: [/absolute/path/to/files]
|
||||
- [Details about implementation]
|
||||
- [Component 2]: Complete
|
||||
- Files: [/absolute/path/to/files]
|
||||
- [Details about implementation]
|
||||
- [Component 3]: In Progress
|
||||
- [Current status]
|
||||
```
|
||||
|
||||
## 📋 PROGRESS.MD UPDATE FORMAT
|
||||
|
||||
Update progress.md with:
|
||||
|
||||
```
|
||||
# Build Progress
|
||||
|
||||
## Directory Structure
|
||||
- [/absolute/path/to/dir1/]: Created and verified
|
||||
- [/absolute/path/to/dir2/]: Created and verified
|
||||
|
||||
## [Date]: [Component/Feature] Built
|
||||
- **Files Created**:
|
||||
- [/absolute/path/to/file1.ext]: Verified
|
||||
- [/absolute/path/to/file2.ext]: Verified
|
||||
- **Key Changes**:
|
||||
- [Change 1]
|
||||
- [Change 2]
|
||||
- **Testing**: [Test results]
|
||||
- **Next Steps**: [What comes next]
|
||||
```
|
||||
|
||||
## 📊 BUILD VERIFICATION CHECKLIST
|
||||
|
||||
```
|
||||
✓ BUILD VERIFICATION
|
||||
- Directory structure created correctly? [YES/NO]
|
||||
- All files created in correct locations? [YES/NO]
|
||||
- All file paths verified with absolute paths? [YES/NO]
|
||||
- All planned changes implemented? [YES/NO]
|
||||
- Testing performed for all changes? [YES/NO]
|
||||
- Code follows project standards? [YES/NO]
|
||||
- Edge cases handled appropriately? [YES/NO]
|
||||
- Build documented with absolute paths? [YES/NO]
|
||||
- tasks.md updated with progress? [YES/NO]
|
||||
- progress.md updated with details? [YES/NO]
|
||||
|
||||
→ If all YES: Build complete - ready for REFLECT mode
|
||||
→ If any NO: Complete missing build elements
|
||||
```
|
||||
|
||||
## 🔄 MODE TRANSITION NOTIFICATION
|
||||
|
||||
When the build is complete, notify user with:
|
||||
|
||||
```
|
||||
## BUILD COMPLETE
|
||||
|
||||
✅ Directory structure verified
|
||||
✅ All files created in correct locations
|
||||
✅ All planned changes implemented
|
||||
✅ Testing performed successfully
|
||||
✅ tasks.md updated with status
|
||||
✅ progress.md updated with details
|
||||
|
||||
→ NEXT RECOMMENDED MODE: REFLECT MODE
|
||||
```
|
||||
@@ -0,0 +1,224 @@
|
||||
---
|
||||
description: Visual process map for CREATIVE mode (Design Decisions)
|
||||
globs: "**/creative*/**", "**/design*/**", "**/decision*/**"
|
||||
alwaysApply: false
|
||||
---
|
||||
|
||||
# CREATIVE MODE: DESIGN PROCESS MAP
|
||||
|
||||
> **TL;DR:** This visual map guides the CREATIVE mode process, focusing on structured design decision-making for components that require deeper exploration before implementation.
|
||||
|
||||
## 🧭 CREATIVE MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["START CREATIVE MODE"] --> ReadTasks["Read tasks.md<br>For Creative Requirements"]
|
||||
|
||||
%% Initial Assessment
|
||||
ReadTasks --> VerifyPlan{"Plan Complete<br>& Creative Phases<br>Identified?"}
|
||||
VerifyPlan -->|"No"| ReturnPlan["Return to<br>PLAN Mode"]
|
||||
VerifyPlan -->|"Yes"| IdentifyPhases["Identify Creative<br>Phases Required"]
|
||||
|
||||
%% Creative Phase Selection
|
||||
IdentifyPhases --> SelectPhase["Select Next<br>Creative Phase"]
|
||||
SelectPhase --> PhaseType{"Creative<br>Phase Type?"}
|
||||
|
||||
%% Creative Phase Types
|
||||
PhaseType -->|"UI/UX<br>Design"| UIPhase["UI/UX CREATIVE PHASE<br>Core/creative-phase-uiux.md"]
|
||||
PhaseType -->|"Architecture<br>Design"| ArchPhase["ARCHITECTURE CREATIVE PHASE<br>Core/creative-phase-architecture.md"]
|
||||
PhaseType -->|"Data Model<br>Design"| DataPhase["DATA MODEL CREATIVE PHASE<br>Core/creative-phase-data.md"]
|
||||
PhaseType -->|"Algorithm<br>Design"| AlgoPhase["ALGORITHM CREATIVE PHASE<br>Core/creative-phase-algorithm.md"]
|
||||
|
||||
%% UI/UX Creative Phase
|
||||
UIPhase --> UI_Problem["Define UI/UX<br>Problem"]
|
||||
UI_Problem --> UI_Research["Research UI<br>Patterns"]
|
||||
UI_Research --> UI_Options["Explore UI<br>Options"]
|
||||
UI_Options --> UI_Evaluate["Evaluate User<br>Experience"]
|
||||
UI_Evaluate --> UI_Decision["Make Design<br>Decision"]
|
||||
UI_Decision --> UI_Document["Document UI<br>Design"]
|
||||
|
||||
%% Architecture Creative Phase
|
||||
ArchPhase --> Arch_Problem["Define Architecture<br>Challenge"]
|
||||
Arch_Problem --> Arch_Options["Explore Architecture<br>Options"]
|
||||
Arch_Options --> Arch_Analyze["Analyze Tradeoffs"]
|
||||
Arch_Analyze --> Arch_Decision["Make Architecture<br>Decision"]
|
||||
Arch_Decision --> Arch_Document["Document<br>Architecture"]
|
||||
Arch_Document --> Arch_Diagram["Create Architecture<br>Diagram"]
|
||||
|
||||
%% Data Model Creative Phase
|
||||
DataPhase --> Data_Requirements["Define Data<br>Requirements"]
|
||||
Data_Requirements --> Data_Structure["Design Data<br>Structure"]
|
||||
Data_Structure --> Data_Relations["Define<br>Relationships"]
|
||||
Data_Relations --> Data_Validation["Design<br>Validation"]
|
||||
Data_Validation --> Data_Document["Document<br>Data Model"]
|
||||
|
||||
%% Algorithm Creative Phase
|
||||
AlgoPhase --> Algo_Problem["Define Algorithm<br>Problem"]
|
||||
Algo_Problem --> Algo_Options["Explore Algorithm<br>Approaches"]
|
||||
Algo_Options --> Algo_Evaluate["Evaluate Time/Space<br>Complexity"]
|
||||
Algo_Evaluate --> Algo_Decision["Make Algorithm<br>Decision"]
|
||||
Algo_Decision --> Algo_Document["Document<br>Algorithm"]
|
||||
|
||||
%% Documentation & Completion
|
||||
UI_Document & Arch_Diagram & Data_Document & Algo_Document --> CreateDoc["Create Creative<br>Phase Document"]
|
||||
CreateDoc --> UpdateTasks["Update tasks.md<br>with Decision"]
|
||||
UpdateTasks --> MorePhases{"More Creative<br>Phases?"}
|
||||
MorePhases -->|"Yes"| SelectPhase
|
||||
MorePhases -->|"No"| VerifyComplete["Verify All<br>Phases Complete"]
|
||||
VerifyComplete --> NotifyComplete["Signal Creative<br>Phases Complete"]
|
||||
```
|
||||
|
||||
## 📋 CREATIVE PHASE DOCUMENT FORMAT
|
||||
|
||||
Each creative phase should produce a document with this structure:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Creative Phase Document"
|
||||
Header["🎨 CREATIVE PHASE: [TYPE]"]
|
||||
Problem["PROBLEM STATEMENT<br>Clear definition of the problem"]
|
||||
Options["OPTIONS ANALYSIS<br>Multiple approaches considered"]
|
||||
Pros["PROS & CONS<br>Tradeoffs for each option"]
|
||||
Decision["DECISION<br>Selected approach + rationale"]
|
||||
Impl["IMPLEMENTATION PLAN<br>Steps to implement the decision"]
|
||||
Diagram["VISUALIZATION<br>Diagrams of the solution"]
|
||||
end
|
||||
|
||||
Header --> Problem --> Options --> Pros --> Decision --> Impl --> Diagram
|
||||
```
|
||||
|
||||
## 🔍 CREATIVE TYPES AND APPROACHES
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "UI/UX Design"
|
||||
UI1["User Flow<br>Analysis"]
|
||||
UI2["Component<br>Hierarchy"]
|
||||
UI3["Interaction<br>Patterns"]
|
||||
UI4["Visual Design<br>Principles"]
|
||||
end
|
||||
|
||||
subgraph "Architecture Design"
|
||||
A1["Component<br>Structure"]
|
||||
A2["Data Flow<br>Patterns"]
|
||||
A3["Interface<br>Design"]
|
||||
A4["System<br>Integration"]
|
||||
end
|
||||
|
||||
subgraph "Data Model Design"
|
||||
D1["Entity<br>Relationships"]
|
||||
D2["Schema<br>Design"]
|
||||
D3["Validation<br>Rules"]
|
||||
D4["Query<br>Optimization"]
|
||||
end
|
||||
|
||||
subgraph "Algorithm Design"
|
||||
AL1["Complexity<br>Analysis"]
|
||||
AL2["Efficiency<br>Optimization"]
|
||||
AL3["Edge Case<br>Handling"]
|
||||
AL4["Scaling<br>Considerations"]
|
||||
end
|
||||
```
|
||||
|
||||
## 📊 REQUIRED FILE STATE VERIFICATION
|
||||
|
||||
Before creative phase work can begin, verify file state:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["File State<br>Verification"] --> CheckTasks{"tasks.md has<br>planning complete?"}
|
||||
|
||||
CheckTasks -->|"No"| ErrorPlan["ERROR:<br>Return to PLAN Mode"]
|
||||
CheckTasks -->|"Yes"| CheckCreative{"Creative phases<br>identified?"}
|
||||
|
||||
CheckCreative -->|"No"| ErrorCreative["ERROR:<br>Return to PLAN Mode"]
|
||||
CheckCreative -->|"Yes"| ReadyCreative["Ready for<br>Creative Phase"]
|
||||
```
|
||||
|
||||
## 📋 OPTIONS ANALYSIS TEMPLATE
|
||||
|
||||
For each creative phase, analyze multiple options:
|
||||
|
||||
```
|
||||
## OPTIONS ANALYSIS
|
||||
|
||||
### Option 1: [Name]
|
||||
**Description**: [Brief description]
|
||||
**Pros**:
|
||||
- [Pro 1]
|
||||
- [Pro 2]
|
||||
**Cons**:
|
||||
- [Con 1]
|
||||
- [Con 2]
|
||||
**Complexity**: [Low/Medium/High]
|
||||
**Implementation Time**: [Estimate]
|
||||
|
||||
### Option 2: [Name]
|
||||
**Description**: [Brief description]
|
||||
**Pros**:
|
||||
- [Pro 1]
|
||||
- [Pro 2]
|
||||
**Cons**:
|
||||
- [Con 1]
|
||||
- [Con 2]
|
||||
**Complexity**: [Low/Medium/High]
|
||||
**Implementation Time**: [Estimate]
|
||||
|
||||
### Option 3: [Name]
|
||||
**Description**: [Brief description]
|
||||
**Pros**:
|
||||
- [Pro 1]
|
||||
- [Pro 2]
|
||||
**Cons**:
|
||||
- [Con 1]
|
||||
- [Con 2]
|
||||
**Complexity**: [Low/Medium/High]
|
||||
**Implementation Time**: [Estimate]
|
||||
```
|
||||
|
||||
## 🎨 CREATIVE PHASE MARKERS
|
||||
|
||||
Use these visual markers for creative phases:
|
||||
|
||||
```
|
||||
🎨🎨🎨 ENTERING CREATIVE PHASE: [TYPE] 🎨🎨🎨
|
||||
|
||||
[Creative phase content]
|
||||
|
||||
🎨 CREATIVE CHECKPOINT: [Milestone]
|
||||
|
||||
[Additional content]
|
||||
|
||||
🎨🎨🎨 EXITING CREATIVE PHASE - DECISION MADE 🎨🎨🎨
|
||||
```
|
||||
|
||||
## 📊 CREATIVE PHASE VERIFICATION CHECKLIST
|
||||
|
||||
```
|
||||
✓ CREATIVE PHASE VERIFICATION
|
||||
- Problem clearly defined? [YES/NO]
|
||||
- Multiple options considered (3+)? [YES/NO]
|
||||
- Pros/cons documented for each option? [YES/NO]
|
||||
- Decision made with clear rationale? [YES/NO]
|
||||
- Implementation plan included? [YES/NO]
|
||||
- Visualization/diagrams created? [YES/NO]
|
||||
- tasks.md updated with decision? [YES/NO]
|
||||
|
||||
→ If all YES: Creative phase complete
|
||||
→ If any NO: Complete missing elements
|
||||
```
|
||||
|
||||
## 🔄 MODE TRANSITION NOTIFICATION
|
||||
|
||||
When all creative phases are complete, notify user with:
|
||||
|
||||
```
|
||||
## CREATIVE PHASES COMPLETE
|
||||
|
||||
✅ All required design decisions made
|
||||
✅ Creative phase documents created
|
||||
✅ tasks.md updated with decisions
|
||||
✅ Implementation plan updated
|
||||
|
||||
→ NEXT RECOMMENDED MODE: BUILD MODE
|
||||
```
|
||||
@@ -0,0 +1,275 @@
|
||||
---
|
||||
description: Visual process map for PLAN mode (Code Implementation)
|
||||
globs: plan-mode-map.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
|
||||
# PLAN MODE: TASK PLANNING PROCESS MAP
|
||||
|
||||
> **TL;DR:** This visual map guides the PLAN mode process, focusing on creating detailed implementation plans based on the complexity level determined during initialization, with mandatory technology validation before implementation.
|
||||
|
||||
## 🧭 PLAN MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["START PLANNING"] --> ReadTasks["Read tasks.md<br>Core/task-tracking.md"]
|
||||
|
||||
%% Complexity Level Determination
|
||||
ReadTasks --> CheckLevel{"Determine<br>Complexity Level"}
|
||||
CheckLevel -->|"Level 2"| Level2["LEVEL 2 PLANNING<br>Level2/enhancement-planning.md"]
|
||||
CheckLevel -->|"Level 3"| Level3["LEVEL 3 PLANNING<br>Level3/feature-planning.md"]
|
||||
CheckLevel -->|"Level 4"| Level4["LEVEL 4 PLANNING<br>Level4/system-planning.md"]
|
||||
|
||||
%% Level 2 Planning
|
||||
Level2 --> L2Review["Review Code<br>Structure"]
|
||||
L2Review --> L2Document["Document<br>Planned Changes"]
|
||||
L2Document --> L2Challenges["Identify<br>Challenges"]
|
||||
L2Challenges --> L2Checklist["Create Task<br>Checklist"]
|
||||
L2Checklist --> L2Update["Update tasks.md<br>with Plan"]
|
||||
L2Update --> L2Tech["TECHNOLOGY<br>VALIDATION"]
|
||||
L2Tech --> L2Verify["Verify Plan<br>Completeness"]
|
||||
|
||||
%% Level 3 Planning
|
||||
Level3 --> L3Review["Review Codebase<br>Structure"]
|
||||
L3Review --> L3Requirements["Document Detailed<br>Requirements"]
|
||||
L3Requirements --> L3Components["Identify Affected<br>Components"]
|
||||
L3Components --> L3Plan["Create Comprehensive<br>Implementation Plan"]
|
||||
L3Plan --> L3Challenges["Document Challenges<br>& Solutions"]
|
||||
L3Challenges --> L3Update["Update tasks.md<br>with Plan"]
|
||||
L3Update --> L3Tech["TECHNOLOGY<br>VALIDATION"]
|
||||
L3Tech --> L3Flag["Flag Components<br>Requiring Creative"]
|
||||
L3Flag --> L3Verify["Verify Plan<br>Completeness"]
|
||||
|
||||
%% Level 4 Planning
|
||||
Level4 --> L4Analysis["Codebase Structure<br>Analysis"]
|
||||
L4Analysis --> L4Requirements["Document Comprehensive<br>Requirements"]
|
||||
L4Requirements --> L4Diagrams["Create Architectural<br>Diagrams"]
|
||||
L4Diagrams --> L4Subsystems["Identify Affected<br>Subsystems"]
|
||||
L4Subsystems --> L4Dependencies["Document Dependencies<br>& Integration Points"]
|
||||
L4Dependencies --> L4Plan["Create Phased<br>Implementation Plan"]
|
||||
L4Plan --> L4Update["Update tasks.md<br>with Plan"]
|
||||
L4Update --> L4Tech["TECHNOLOGY<br>VALIDATION"]
|
||||
L4Tech --> L4Flag["Flag Components<br>Requiring Creative"]
|
||||
L4Flag --> L4Verify["Verify Plan<br>Completeness"]
|
||||
|
||||
%% Technology Validation Gate - NEW
|
||||
L2Tech & L3Tech & L4Tech --> TechGate["⛔ TECHNOLOGY<br>VALIDATION GATE"]
|
||||
TechGate --> TechSelection["Document Technology<br>Stack Selection"]
|
||||
TechSelection --> TechHelloWorld["Create Hello World<br>Proof of Concept"]
|
||||
TechHelloWorld --> TechDependencies["Verify Required<br>Dependencies"]
|
||||
TechDependencies --> TechConfig["Validate Build<br>Configuration"]
|
||||
TechConfig --> TechBuild["Complete Test<br>Build"]
|
||||
TechBuild --> TechVerify["⛔ TECHNOLOGY<br>CHECKPOINT"]
|
||||
|
||||
%% Verification & Completion
|
||||
L2Verify & L3Verify & L4Verify & TechVerify --> CheckCreative{"Creative<br>Phases<br>Required?"}
|
||||
|
||||
%% Mode Transition
|
||||
CheckCreative -->|"Yes"| RecCreative["NEXT MODE:<br>CREATIVE MODE"]
|
||||
CheckCreative -->|"No"| RecBuild["NEXT MODE:<br>BUILD MODE"]
|
||||
|
||||
%% Style for Technology Gate
|
||||
style TechGate fill:#ff5555,stroke:#dd3333,color:white,stroke-width:3px
|
||||
style TechVerify fill:#ff5555,stroke:#dd3333,color:white,stroke-width:3px
|
||||
style TechSelection fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TechHelloWorld fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TechDependencies fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TechConfig fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TechBuild fill:#4da6ff,stroke:#0066cc,color:white
|
||||
```
|
||||
|
||||
## 📋 LEVEL-SPECIFIC PLANNING APPROACHES
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Level 2: Enhancement"
|
||||
L2A["Basic Requirements<br>Analysis"]
|
||||
L2B["Simple Component<br>Identification"]
|
||||
L2C["Linear Implementation<br>Plan"]
|
||||
L2D["Basic Checklist<br>Creation"]
|
||||
end
|
||||
|
||||
subgraph "Level 3: Feature"
|
||||
L3A["Detailed Requirements<br>Analysis"]
|
||||
L3B["Component Mapping<br>with Dependencies"]
|
||||
L3C["Multi-Phase<br>Implementation Plan"]
|
||||
L3D["Comprehensive<br>Checklist"]
|
||||
L3E["Creative Phase<br>Identification"]
|
||||
end
|
||||
|
||||
subgraph "Level 4: System"
|
||||
L4A["Architectural<br>Requirements Analysis"]
|
||||
L4B["System Component<br>Mapping"]
|
||||
L4C["Subsystem<br>Integration Plan"]
|
||||
L4D["Phased Implementation<br>Strategy"]
|
||||
L4E["Risk Assessment<br>& Mitigation"]
|
||||
L4F["Multiple Creative<br>Phase Requirements"]
|
||||
end
|
||||
|
||||
L2A --> L2B --> L2C --> L2D
|
||||
L3A --> L3B --> L3C --> L3D --> L3E
|
||||
L4A --> L4B --> L4C --> L4D --> L4E --> L4F
|
||||
```
|
||||
|
||||
## 🔧 TECHNOLOGY VALIDATION WORKFLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Technology<br>Validation Start"] --> Select["Technology<br>Stack Selection"]
|
||||
Select --> Document["Document Chosen<br>Technologies"]
|
||||
Document --> POC["Create Minimal<br>Proof of Concept"]
|
||||
POC --> Build["Verify Build<br>Process Works"]
|
||||
Build --> Dependencies["Validate All<br>Dependencies"]
|
||||
Dependencies --> Config["Confirm Configuration<br>Files Are Correct"]
|
||||
Config --> Test["Complete Test<br>Build/Run"]
|
||||
Test --> Success{"All Checks<br>Pass?"}
|
||||
|
||||
Success -->|"Yes"| Ready["Ready for<br>Implementation"]
|
||||
Success -->|"No"| Fix["Fix Technology<br>Issues"]
|
||||
Fix --> Document
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style POC fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style Success fill:#ff5555,stroke:#dd3333,color:white
|
||||
style Fix fill:#ff5555,stroke:#dd3333,color:white
|
||||
style Ready fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
## 📊 REQUIRED FILE STATE VERIFICATION
|
||||
|
||||
Before planning can begin, verify the file state:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["File State<br>Verification"] --> CheckTasks{"tasks.md<br>initialized?"}
|
||||
|
||||
CheckTasks -->|"No"| ErrorTasks["ERROR:<br>Return to VAN Mode"]
|
||||
CheckTasks -->|"Yes"| CheckActive{"activeContext.md<br>exists?"}
|
||||
|
||||
CheckActive -->|"No"| ErrorActive["ERROR:<br>Return to VAN Mode"]
|
||||
CheckActive -->|"Yes"| ReadyPlan["Ready for<br>Planning"]
|
||||
```
|
||||
|
||||
## 📝 TASKS.MD UPDATE FORMAT
|
||||
|
||||
During planning, update tasks.md with this structure:
|
||||
|
||||
```
|
||||
# Task: [Task name]
|
||||
|
||||
## Description
|
||||
[Detailed description]
|
||||
|
||||
## Complexity
|
||||
Level: [2/3/4]
|
||||
Type: [Enhancement/Feature/Complex System]
|
||||
|
||||
## Technology Stack
|
||||
- Framework: [Selected framework]
|
||||
- Build Tool: [Selected build tool]
|
||||
- Language: [Selected language]
|
||||
- Storage: [Selected storage mechanism]
|
||||
|
||||
## Technology Validation Checkpoints
|
||||
- [ ] Project initialization command verified
|
||||
- [ ] Required dependencies identified and installed
|
||||
- [ ] Build configuration validated
|
||||
- [ ] Hello world verification completed
|
||||
- [ ] Test build passes successfully
|
||||
|
||||
## Status
|
||||
- [x] Initialization complete
|
||||
- [x] Planning complete
|
||||
- [ ] Technology validation complete
|
||||
- [ ] [Implementation steps]
|
||||
|
||||
## Implementation Plan
|
||||
1. [Step 1]
|
||||
- [Subtask 1.1]
|
||||
- [Subtask 1.2]
|
||||
2. [Step 2]
|
||||
- [Subtask 2.1]
|
||||
- [Subtask 2.2]
|
||||
|
||||
## Creative Phases Required
|
||||
- [ ] [Component 1] Design
|
||||
- [ ] [Component 2] Architecture
|
||||
- [ ] [Component 3] Data Model
|
||||
|
||||
## Dependencies
|
||||
- [Dependency 1]
|
||||
- [Dependency 2]
|
||||
|
||||
## Challenges & Mitigations
|
||||
- [Challenge 1]: [Mitigation strategy]
|
||||
- [Challenge 2]: [Mitigation strategy]
|
||||
```
|
||||
|
||||
## 📋 CREATIVE PHASE IDENTIFICATION
|
||||
|
||||
For Level 3-4 tasks, identify components requiring creative phases:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Creative Phase<br>Identification"] --> CheckComp{"Component<br>Analysis"}
|
||||
|
||||
CheckComp --> UI["UI/UX<br>Components"]
|
||||
CheckComp --> Data["Data Model<br>Components"]
|
||||
CheckComp --> Arch["Architecture<br>Components"]
|
||||
CheckComp --> Algo["Algorithm<br>Components"]
|
||||
|
||||
UI & Data & Arch & Algo --> Decision{"Design Decisions<br>Required?"}
|
||||
|
||||
Decision -->|"Yes"| Flag["Flag for<br>Creative Phase"]
|
||||
Decision -->|"No"| Skip["Standard<br>Implementation"]
|
||||
|
||||
Flag --> Document["Document in<br>tasks.md"]
|
||||
```
|
||||
|
||||
## 📊 TECHNOLOGY VALIDATION CHECKLIST
|
||||
|
||||
```
|
||||
✓ TECHNOLOGY VALIDATION CHECKLIST
|
||||
- Technology stack clearly defined? [YES/NO]
|
||||
- Project initialization command documented? [YES/NO]
|
||||
- Required dependencies identified? [YES/NO]
|
||||
- Minimal proof of concept created? [YES/NO]
|
||||
- Hello world build/run successful? [YES/NO]
|
||||
- Configuration files validated? [YES/NO]
|
||||
- Test build completes successfully? [YES/NO]
|
||||
|
||||
→ If all YES: Technology validation complete - ready for next phase
|
||||
→ If any NO: Resolve technology issues before proceeding
|
||||
```
|
||||
|
||||
## 📊 PLAN VERIFICATION CHECKLIST
|
||||
|
||||
```
|
||||
✓ PLAN VERIFICATION CHECKLIST
|
||||
- Requirements clearly documented? [YES/NO]
|
||||
- Technology stack validated? [YES/NO]
|
||||
- Affected components identified? [YES/NO]
|
||||
- Implementation steps detailed? [YES/NO]
|
||||
- Dependencies documented? [YES/NO]
|
||||
- Challenges & mitigations addressed? [YES/NO]
|
||||
- Creative phases identified (Level 3-4)? [YES/NO/NA]
|
||||
- tasks.md updated with plan? [YES/NO]
|
||||
|
||||
→ If all YES: Planning complete - ready for next mode
|
||||
→ If any NO: Complete missing plan elements
|
||||
```
|
||||
|
||||
## 🔄 MODE TRANSITION NOTIFICATION
|
||||
|
||||
When planning is complete, notify user with:
|
||||
|
||||
```
|
||||
## PLANNING COMPLETE
|
||||
|
||||
✅ Implementation plan created
|
||||
✅ Technology stack validated
|
||||
✅ tasks.md updated with plan
|
||||
✅ Challenges and mitigations documented
|
||||
[✅ Creative phases identified (for Level 3-4)]
|
||||
|
||||
→ NEXT RECOMMENDED MODE: [CREATIVE/BUILD] MODE
|
||||
@@ -0,0 +1,495 @@
|
||||
---
|
||||
description: QA Mode
|
||||
globs: qa-mode-map.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
|
||||
|
||||
> **TL;DR:** This enhanced QA mode provides comprehensive validation at any stage of development. It automatically detects the current phase, validates Memory Bank consistency, verifies task tracking, and performs phase-specific technical validation to ensure project quality throughout the development lifecycle.
|
||||
|
||||
## 🔍 ENHANCED QA MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["🚀 START QA MODE"] --> DetectPhase["🧭 PHASE DETECTION<br>Determine current project phase"]
|
||||
|
||||
%% Phase detection decision path
|
||||
DetectPhase --> PhaseDetermination{"Current Phase?"}
|
||||
PhaseDetermination -->|"VAN"| VANChecks["VAN Phase Validation"]
|
||||
PhaseDetermination -->|"PLAN"| PLANChecks["PLAN Phase Validation"]
|
||||
PhaseDetermination -->|"CREATIVE"| CREATIVEChecks["CREATIVE Phase Validation"]
|
||||
PhaseDetermination -->|"BUILD"| BUILDChecks["BUILD Phase Validation"]
|
||||
|
||||
%% Universal checks that apply to all phases
|
||||
DetectPhase --> UniversalChecks["🔍 UNIVERSAL VALIDATION"]
|
||||
UniversalChecks --> MemoryBankCheck["1️⃣ MEMORY BANK VERIFICATION<br>Check consistency & updates"]
|
||||
MemoryBankCheck --> TaskTrackingCheck["2️⃣ TASK TRACKING VERIFICATION<br>Validate tasks.md as source of truth"]
|
||||
TaskTrackingCheck --> ReferenceCheck["3️⃣ REFERENCE VALIDATION<br>Verify cross-references between docs"]
|
||||
|
||||
%% Phase-specific validations feed into comprehensive report
|
||||
VANChecks & PLANChecks & CREATIVEChecks & BUILDChecks --> PhaseSpecificResults["Phase-Specific Results"]
|
||||
ReferenceCheck & PhaseSpecificResults --> ValidationResults{"✅ All Checks<br>Passed?"}
|
||||
|
||||
%% Results Processing
|
||||
ValidationResults -->|"Yes"| SuccessReport["📝 GENERATE SUCCESS REPORT<br>All validations passed"]
|
||||
ValidationResults -->|"No"| FailureReport["⚠️ GENERATE FAILURE REPORT<br>With specific fix instructions"]
|
||||
|
||||
%% Success Path
|
||||
SuccessReport --> UpdateMB["📚 Update Memory Bank<br>Record successful validation"]
|
||||
UpdateMB --> ContinueProcess["🚦 CONTINUE: Phase processes<br>can proceed"]
|
||||
|
||||
%% Failure Path
|
||||
FailureReport --> IdentifyFixes["🔧 IDENTIFY REQUIRED FIXES"]
|
||||
IdentifyFixes --> ApplyFixes["🛠️ APPLY FIXES"]
|
||||
ApplyFixes --> Revalidate["🔄 Re-run validation"]
|
||||
Revalidate --> ValidationResults
|
||||
|
||||
%% Style nodes for clarity
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style DetectPhase fill:#f6ad55,stroke:#c27022,color:white
|
||||
style UniversalChecks fill:#f6546a,stroke:#c30052,color:white
|
||||
style MemoryBankCheck fill:#10b981,stroke:#059669,color:white
|
||||
style TaskTrackingCheck fill:#10b981,stroke:#059669,color:white
|
||||
style ReferenceCheck fill:#10b981,stroke:#059669,color:white
|
||||
style ValidationResults fill:#f6546a,stroke:#c30052,color:white
|
||||
style SuccessReport fill:#10b981,stroke:#059669,color:white
|
||||
style FailureReport fill:#f6ad55,stroke:#c27022,color:white
|
||||
style ContinueProcess fill:#10b981,stroke:#059669,color:white,stroke-width:2px
|
||||
style IdentifyFixes fill:#f6ad55,stroke:#c27022,color:white
|
||||
```
|
||||
|
||||
## 🧭 PHASE DETECTION PROCESS
|
||||
|
||||
The enhanced QA mode first determines which phase the project is currently in:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
PD["Phase Detection"] --> CheckMB["Analyze Memory Bank Files"]
|
||||
CheckMB --> CheckActive["Check activeContext.md<br>for current phase"]
|
||||
CheckActive --> CheckProgress["Check progress.md<br>for recent activities"]
|
||||
CheckProgress --> CheckTasks["Check tasks.md<br>for task status"]
|
||||
|
||||
CheckTasks --> PhaseResult{"Determine<br>Current Phase"}
|
||||
PhaseResult -->|"VAN"| VAN["VAN Phase<br>Initialization"]
|
||||
PhaseResult -->|"PLAN"| PLAN["PLAN Phase<br>Task Planning"]
|
||||
PhaseResult -->|"CREATIVE"| CREATIVE["CREATIVE Phase<br>Design Decisions"]
|
||||
PhaseResult -->|"BUILD"| BUILD["BUILD Phase<br>Implementation"]
|
||||
|
||||
VAN & PLAN & CREATIVE & BUILD --> LoadChecks["Load Phase-Specific<br>Validation Checks"]
|
||||
|
||||
style PD fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style PhaseResult fill:#f6546a,stroke:#c30052,color:white
|
||||
style LoadChecks fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
## 📝 UNIVERSAL MEMORY BANK VERIFICATION
|
||||
|
||||
This process ensures Memory Bank files are consistent and up-to-date regardless of phase:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
MBVS["Memory Bank<br>Verification"] --> CoreCheck["Check Core Files Exist"]
|
||||
CoreCheck --> CoreFiles["Verify Required Files:<br>projectbrief.md<br>activeContext.md<br>tasks.md<br>progress.md"]
|
||||
|
||||
CoreFiles --> ContentCheck["Verify Content<br>Consistency"]
|
||||
ContentCheck --> LastModified["Check Last Modified<br>Timestamps"]
|
||||
LastModified --> CrossRef["Validate Cross-<br>References"]
|
||||
|
||||
CrossRef --> ConsistencyCheck{"All Files<br>Consistent?"}
|
||||
ConsistencyCheck -->|"Yes"| PassMB["✅ Memory Bank<br>Verification Passed"]
|
||||
ConsistencyCheck -->|"No"| FailMB["❌ Memory Bank<br>Inconsistencies Found"]
|
||||
|
||||
FailMB --> FixSuggestions["Generate Fix<br>Suggestions"]
|
||||
|
||||
style MBVS fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ConsistencyCheck fill:#f6546a,stroke:#c30052,color:white
|
||||
style PassMB fill:#10b981,stroke:#059669,color:white
|
||||
style FailMB fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 📋 TASK TRACKING VERIFICATION
|
||||
|
||||
This process validates tasks.md as the single source of truth:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
TTV["Task Tracking<br>Verification"] --> CheckTasksFile["Check tasks.md<br>Existence & Format"]
|
||||
CheckTasksFile --> VerifyReferences["Verify Task References<br>in Other Documents"]
|
||||
VerifyReferences --> ProgressCheck["Check Consistency with<br>progress.md"]
|
||||
ProgressCheck --> StatusCheck["Verify Task Status<br>Accuracy"]
|
||||
|
||||
StatusCheck --> TaskConsistency{"Tasks Properly<br>Tracked?"}
|
||||
TaskConsistency -->|"Yes"| PassTasks["✅ Task Tracking<br>Verification Passed"]
|
||||
TaskConsistency -->|"No"| FailTasks["❌ Task Tracking<br>Issues Found"]
|
||||
|
||||
FailTasks --> TaskFixSuggestions["Generate Task Tracking<br>Fix Suggestions"]
|
||||
|
||||
style TTV fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TaskConsistency fill:#f6546a,stroke:#c30052,color:white
|
||||
style PassTasks fill:#10b981,stroke:#059669,color:white
|
||||
style FailTasks fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 🔄 REFERENCE VALIDATION PROCESS
|
||||
|
||||
This process ensures proper cross-referencing between documents:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
RV["Reference<br>Validation"] --> FindRefs["Find Cross-References<br>in Documents"]
|
||||
FindRefs --> VerifyRefs["Verify Reference<br>Accuracy"]
|
||||
VerifyRefs --> CheckBackRefs["Check Bidirectional<br>References"]
|
||||
|
||||
CheckBackRefs --> RefConsistency{"References<br>Consistent?"}
|
||||
RefConsistency -->|"Yes"| PassRefs["✅ Reference Validation<br>Passed"]
|
||||
RefConsistency -->|"No"| FailRefs["❌ Reference<br>Issues Found"]
|
||||
|
||||
FailRefs --> RefFixSuggestions["Generate Reference<br>Fix Suggestions"]
|
||||
|
||||
style RV fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style RefConsistency fill:#f6546a,stroke:#c30052,color:white
|
||||
style PassRefs fill:#10b981,stroke:#059669,color:white
|
||||
style FailRefs fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 🚨 PHASE-SPECIFIC VALIDATION PROCESSES
|
||||
|
||||
### VAN Phase Validation
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
VAN["VAN Phase<br>Validation"] --> InitCheck["Check Initialization<br>Completeness"]
|
||||
InitCheck --> PlatformCheck["Verify Platform<br>Detection"]
|
||||
PlatformCheck --> ComplexityCheck["Validate Complexity<br>Determination"]
|
||||
|
||||
ComplexityCheck --> VANConsistency{"VAN Phase<br>Complete?"}
|
||||
VANConsistency -->|"Yes"| PassVAN["✅ VAN Phase<br>Validation Passed"]
|
||||
VANConsistency -->|"No"| FailVAN["❌ VAN Phase<br>Issues Found"]
|
||||
|
||||
style VAN fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style VANConsistency fill:#f6546a,stroke:#c30052,color:white
|
||||
style PassVAN fill:#10b981,stroke:#059669,color:white
|
||||
style FailVAN fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
### PLAN Phase Validation
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
PLAN["PLAN Phase<br>Validation"] --> PlanCheck["Check Planning<br>Documentation"]
|
||||
PlanCheck --> TaskBreakdown["Verify Task<br>Breakdown"]
|
||||
TaskBreakdown --> ScopeCheck["Validate Scope<br>Definition"]
|
||||
|
||||
ScopeCheck --> PLANConsistency{"PLAN Phase<br>Complete?"}
|
||||
PLANConsistency -->|"Yes"| PassPLAN["✅ PLAN Phase<br>Validation Passed"]
|
||||
PLANConsistency -->|"No"| FailPLAN["❌ PLAN Phase<br>Issues Found"]
|
||||
|
||||
style PLAN fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style PLANConsistency fill:#f6546a,stroke:#c30052,color:white
|
||||
style PassPLAN fill:#10b981,stroke:#059669,color:white
|
||||
style FailPLAN fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
### CREATIVE Phase Validation
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
CREATIVE["CREATIVE Phase<br>Validation"] --> DesignCheck["Check Design<br>Documents"]
|
||||
DesignCheck --> ArchCheck["Verify Architectural<br>Decisions"]
|
||||
ArchCheck --> PatternCheck["Validate Design<br>Patterns"]
|
||||
|
||||
PatternCheck --> CREATIVEConsistency{"CREATIVE Phase<br>Complete?"}
|
||||
CREATIVEConsistency -->|"Yes"| PassCREATIVE["✅ CREATIVE Phase<br>Validation Passed"]
|
||||
CREATIVEConsistency -->|"No"| FailCREATIVE["❌ CREATIVE Phase<br>Issues Found"]
|
||||
|
||||
style CREATIVE fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style CREATIVEConsistency fill:#f6546a,stroke:#c30052,color:white
|
||||
style PassCREATIVE fill:#10b981,stroke:#059669,color:white
|
||||
style FailCREATIVE fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
### BUILD Phase Technical Validation
|
||||
|
||||
This retains the original QA validation from the previous version:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
BUILD["BUILD Phase<br>Validation"] --> ReadDesign["Read Design Decisions"]
|
||||
ReadDesign --> FourChecks["Four-Point Technical<br>Validation"]
|
||||
|
||||
FourChecks --> DepCheck["1️⃣ Dependency<br>Verification"]
|
||||
DepCheck --> ConfigCheck["2️⃣ Configuration<br>Validation"]
|
||||
ConfigCheck --> EnvCheck["3️⃣ Environment<br>Validation"]
|
||||
EnvCheck --> MinBuildCheck["4️⃣ Minimal Build<br>Test"]
|
||||
|
||||
MinBuildCheck --> BUILDConsistency{"Technical<br>Prerequisites Met?"}
|
||||
BUILDConsistency -->|"Yes"| PassBUILD["✅ BUILD Phase<br>Validation Passed"]
|
||||
BUILDConsistency -->|"No"| FailBUILD["❌ BUILD Phase<br>Issues Found"]
|
||||
|
||||
style BUILD fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FourChecks fill:#f6546a,stroke:#c30052,color:white
|
||||
style BUILDConsistency fill:#f6546a,stroke:#c30052,color:white
|
||||
style PassBUILD fill:#10b981,stroke:#059669,color:white
|
||||
style FailBUILD fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 📋 UNIVERSAL VALIDATION COMMAND EXECUTION
|
||||
|
||||
### Memory Bank Verification Commands:
|
||||
|
||||
```bash
|
||||
# Check Memory Bank file existence and recency
|
||||
ls -la memory-bank/
|
||||
find memory-bank/ -type f -mtime -7 | sort
|
||||
|
||||
# Check for consistency between files
|
||||
grep -r "task" memory-bank/
|
||||
grep -r "requirement" memory-bank/
|
||||
```
|
||||
|
||||
### Task Tracking Verification Commands:
|
||||
|
||||
```bash
|
||||
# Verify tasks.md as source of truth
|
||||
test -f tasks.md && echo "✅ tasks.md exists" || echo "❌ tasks.md missing"
|
||||
|
||||
# Check references to tasks in other files
|
||||
grep -r "Task" --include="*.md" .
|
||||
grep -r "task" --include="*.md" . | grep -v "tasks.md" | wc -l
|
||||
|
||||
# Verify task status consistency
|
||||
grep -i "completed\|done\|finished" tasks.md
|
||||
grep -i "in progress\|started" tasks.md
|
||||
```
|
||||
|
||||
### Reference Validation Commands:
|
||||
|
||||
```bash
|
||||
# Find cross-references between files
|
||||
grep -r "see\|refer\|reference" --include="*.md" .
|
||||
|
||||
# Check for broken references
|
||||
for file in $(grep -l "see\|refer\|reference" --include="*.md" .); do
|
||||
for ref in $(grep -o '[a-zA-Z0-9_-]*\.md' $file); do
|
||||
test -f $ref || echo "❌ Broken reference: $ref in $file"
|
||||
done
|
||||
done
|
||||
```
|
||||
|
||||
## 📋 1️⃣ DEPENDENCY VERIFICATION PROCESS (Original)
|
||||
|
||||
This validation point ensures all required packages are correctly installed.
|
||||
|
||||
### Command Execution:
|
||||
|
||||
```bash
|
||||
# Check if packages are installed
|
||||
npm list react react-dom tailwindcss postcss autoprefixer
|
||||
|
||||
# Verify package versions match requirements
|
||||
npm list | grep -E "react|tailwind|postcss"
|
||||
|
||||
# Check for peer dependency warnings
|
||||
npm ls --depth=0
|
||||
```
|
||||
|
||||
### Validation Criteria:
|
||||
- All required packages must be installed
|
||||
- Versions must be compatible with requirements
|
||||
- No critical peer dependency warnings
|
||||
- Required dev dependencies must be present
|
||||
|
||||
### Common Fixes:
|
||||
- `npm install [missing-package]` - Install missing packages
|
||||
- `npm install [package]@[version]` - Fix version mismatches
|
||||
- `npm install --save-dev [dev-dependency]` - Add development dependencies
|
||||
|
||||
## 📝 2️⃣ CONFIGURATION VALIDATION PROCESS (Original)
|
||||
|
||||
This validation point ensures configuration files are in the correct format for the project.
|
||||
|
||||
### Command Execution:
|
||||
|
||||
```bash
|
||||
# Check package.json for module type
|
||||
grep "\"type\":" package.json
|
||||
|
||||
# Verify configuration file extensions match module type
|
||||
find . -name "*.config.*" | grep -E "\.(js|cjs|mjs)$"
|
||||
|
||||
# Test configuration syntax
|
||||
node -c *.config.js || node -c *.config.cjs || node -c *.config.mjs
|
||||
```
|
||||
|
||||
### Validation Criteria:
|
||||
- Configuration file extensions must match module type in package.json
|
||||
- File syntax must be valid
|
||||
- Configuration must reference installed packages
|
||||
|
||||
### Common Fixes:
|
||||
- Rename `.js` to `.cjs` for CommonJS in ES module projects
|
||||
- Fix syntax errors in configuration files
|
||||
- Adjust configuration to reference installed packages
|
||||
|
||||
## 🌐 3️⃣ ENVIRONMENT VALIDATION PROCESS (Original)
|
||||
|
||||
This validation point ensures the development environment is correctly set up.
|
||||
|
||||
### Command Execution:
|
||||
|
||||
```bash
|
||||
# Check build tools
|
||||
npm run --help
|
||||
|
||||
# Verify node version compatibility
|
||||
node -v
|
||||
|
||||
# Check for environment variables
|
||||
printenv | grep -E "NODE_|PATH|HOME"
|
||||
|
||||
# Verify access permissions
|
||||
ls -la .
|
||||
```
|
||||
|
||||
### Validation Criteria:
|
||||
- Node.js version must be compatible with requirements
|
||||
- Build commands must be defined in package.json
|
||||
- Environment must have necessary access permissions
|
||||
- Required environment variables must be set
|
||||
|
||||
### Common Fixes:
|
||||
- Update Node.js version
|
||||
- Add missing scripts to package.json
|
||||
- Fix file permissions with chmod/icacls
|
||||
- Set required environment variables
|
||||
|
||||
## 🔥 4️⃣ MINIMAL BUILD TEST PROCESS (Original)
|
||||
|
||||
This validation point tests a minimal build to ensure basic functionality works.
|
||||
|
||||
### Command Execution:
|
||||
|
||||
```bash
|
||||
# Run a minimal build
|
||||
npm run build -- --dry-run || npm run dev -- --dry-run
|
||||
|
||||
# Test entry point file existence
|
||||
find src -name "main.*" -o -name "index.*"
|
||||
|
||||
# Validate HTML entry point
|
||||
grep -i "script.*src=" index.html
|
||||
```
|
||||
|
||||
### Validation Criteria:
|
||||
- Build process must complete without errors
|
||||
- Entry point files must exist and be correctly referenced
|
||||
- HTML must reference the correct JavaScript entry point
|
||||
- Basic rendering must work in a test environment
|
||||
|
||||
### Common Fixes:
|
||||
- Fix entry point references in HTML
|
||||
- Correct import paths in JavaScript
|
||||
- Fix build configuration errors
|
||||
- Update incorrect paths or references
|
||||
|
||||
## 📊 ENHANCED COMPREHENSIVE QA REPORT FORMAT
|
||||
|
||||
```
|
||||
╔═════════════════════════ 🔍 ENHANCED QA VALIDATION REPORT ═════════════════════╗
|
||||
│ │
|
||||
│ Project: [Project Name] Date: [Current Date] │
|
||||
│ Platform: [OS Platform] Detected Phase: [Current Phase] │
|
||||
│ │
|
||||
│ ━━━━━━━━━━━━━━━━━━━━━━━━ UNIVERSAL VALIDATION RESULTS ━━━━━━━━━━━━━━━━━━━━━━━ │
|
||||
│ │
|
||||
│ 1️⃣ MEMORY BANK VERIFICATION │
|
||||
│ ✓ Core Files: [Status] │
|
||||
│ ✓ Content Consistency: [Status] │
|
||||
│ ✓ Last Modified: [Status] │
|
||||
│ │
|
||||
│ 2️⃣ TASK TRACKING VERIFICATION │
|
||||
│ ✓ tasks.md Status: [Status] │
|
||||
│ ✓ Task References: [Status] │
|
||||
│ ✓ Status Consistency: [Status] │
|
||||
│ │
|
||||
│ 3️⃣ REFERENCE VALIDATION │
|
||||
│ ✓ Cross-References: [Status] │
|
||||
│ ✓ Reference Accuracy: [Status] │
|
||||
│ │
|
||||
│ ━━━━━━━━━━━━━━━━━━━━━━━ PHASE-SPECIFIC VALIDATION ━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
|
||||
│ │
|
||||
│ [VAN/PLAN/CREATIVE/BUILD] PHASE VALIDATION │
|
||||
│ ✓ [Phase-specific check 1]: [Status] │
|
||||
│ ✓ [Phase-specific check 2]: [Status] │
|
||||
│ ✓ [Phase-specific check 3]: [Status] │
|
||||
│ │
|
||||
│ [Technical validation section shown only for BUILD phase] │
|
||||
│ │
|
||||
│ ━━━━━━━━━━━━━━━━━━━━━━━━━━━ OVERALL STATUS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
|
||||
│ │
|
||||
│ ✅ VALIDATION PASSED - Project quality verified for current phase │
|
||||
│ │
|
||||
╚═══════════════════════════════════════════════════════════════════════════════╝
|
||||
```
|
||||
|
||||
## 🚫 ENHANCED FAILURE REPORT FORMAT
|
||||
|
||||
If validation fails, a detailed failure report is generated:
|
||||
|
||||
```
|
||||
╔═════════════════════════ ⚠️ QA VALIDATION FAILURES ═════════════════════════════╗
|
||||
│ │
|
||||
│ Project: [Project Name] Date: [Current Date] │
|
||||
│ Platform: [OS Platform] Detected Phase: [Current Phase] │
|
||||
│ │
|
||||
│ ━━━━━━━━━━━━━━━━━━━━━━━━━━ FAILED CHECKS ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
|
||||
│ │
|
||||
│ ❌ MEMORY BANK ISSUES │
|
||||
│ • [Specific issue details] │
|
||||
│ • [Specific issue details] │
|
||||
│ │
|
||||
│ ❌ TASK TRACKING ISSUES │
|
||||
│ • [Specific issue details] │
|
||||
│ • [Specific issue details] │
|
||||
│ │
|
||||
│ ❌ REFERENCE ISSUES │
|
||||
│ • [Specific issue details] │
|
||||
│ • [Specific issue details] │
|
||||
│ │
|
||||
│ ❌ [PHASE]-SPECIFIC ISSUES │
|
||||
│ • [Specific issue details] │
|
||||
│ • [Specific issue details] │
|
||||
│ │
|
||||
│ ━━━━━━━━━━━━━━━━━━━━━━━━━━━ REQUIRED FIXES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ │
|
||||
│ │
|
||||
│ 1. [Specific fix instruction with command] │
|
||||
│ 2. [Specific fix instruction with command] │
|
||||
│ 3. [Specific fix instruction with command] │
|
||||
│ │
|
||||
│ ⚠️ VALIDATION FAILED - Please resolve issues before proceeding │
|
||||
│ │
|
||||
╚═════════════════════════════════════════════════════════════════════════════════╝
|
||||
```
|
||||
|
||||
## 🔄 QA-ANYTIME ACTIVATION PROTOCOL
|
||||
|
||||
The enhanced QA mode can be activated at any time in the development process:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["User Types: QA"] --> DetectContext["Detect Current Context"]
|
||||
DetectContext --> RunQA["Run QA with Context-Aware Checks"]
|
||||
RunQA --> GenerateReport["Generate Appropriate QA Report"]
|
||||
GenerateReport --> UserResponse["Present Report to User"]
|
||||
|
||||
UserResponse --> FixNeeded{"Fixes<br>Needed?"}
|
||||
FixNeeded -->|"Yes"| SuggestFixes["Display Fix Instructions"]
|
||||
FixNeeded -->|"No"| ContinueWork["Continue Current Phase Work"]
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FixNeeded fill:#f6546a,stroke:#c30052,color:white
|
||||
style SuggestFixes fill:#ff5555,stroke:#dd3333,color:white
|
||||
style ContinueWork fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
This enhanced QA mode serves as a "quality guardian" throughout the development process, ensuring documentation is consistently maintained and all phase requirements are met before proceeding to the next phase.
|
||||
@@ -0,0 +1,229 @@
|
||||
---
|
||||
description: Visual process map for REFLECT mode (Task Reflection)
|
||||
globs: "**/reflect*/**", "**/review*/**", "**/retrospect*/**"
|
||||
alwaysApply: false
|
||||
---
|
||||
|
||||
# REFLECT MODE: TASK REVIEW PROCESS MAP
|
||||
|
||||
> **TL;DR:** This visual map guides the REFLECT mode process, focusing on structured review of the implementation, documenting lessons learned, and preparing insights for future reference.
|
||||
|
||||
## 🧭 REFLECT MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["START REFLECT MODE"] --> ReadTasks["Read tasks.md<br>and progress.md"]
|
||||
|
||||
%% Initial Assessment
|
||||
ReadTasks --> VerifyImplement{"Implementation<br>Complete?"}
|
||||
VerifyImplement -->|"No"| ReturnBuild["Return to<br>BUILD Mode"]
|
||||
VerifyImplement -->|"Yes"| AssessLevel{"Determine<br>Complexity Level"}
|
||||
|
||||
%% Level-Based Reflection
|
||||
AssessLevel -->|"Level 1"| L1Reflect["LEVEL 1 REFLECTION<br>Level1/reflection-basic.md"]
|
||||
AssessLevel -->|"Level 2"| L2Reflect["LEVEL 2 REFLECTION<br>Level2/reflection-standard.md"]
|
||||
AssessLevel -->|"Level 3"| L3Reflect["LEVEL 3 REFLECTION<br>Level3/reflection-comprehensive.md"]
|
||||
AssessLevel -->|"Level 4"| L4Reflect["LEVEL 4 REFLECTION<br>Level4/reflection-advanced.md"]
|
||||
|
||||
%% Level 1 Reflection (Quick)
|
||||
L1Reflect --> L1Review["Review<br>Bug Fix"]
|
||||
L1Review --> L1Document["Document<br>Solution"]
|
||||
L1Document --> L1Update["Update<br>tasks.md"]
|
||||
|
||||
%% Level 2 Reflection (Standard)
|
||||
L2Reflect --> L2Review["Review<br>Enhancement"]
|
||||
L2Review --> L2WWW["Document<br>What Went Well"]
|
||||
L2WWW --> L2Challenges["Document<br>Challenges"]
|
||||
L2Challenges --> L2Lessons["Document<br>Lessons Learned"]
|
||||
L2Lessons --> L2Update["Update<br>tasks.md"]
|
||||
|
||||
%% Level 3-4 Reflection (Comprehensive)
|
||||
L3Reflect & L4Reflect --> L34Review["Review Implementation<br>& Creative Phases"]
|
||||
L34Review --> L34Plan["Compare Against<br>Original Plan"]
|
||||
L34Plan --> L34WWW["Document<br>What Went Well"]
|
||||
L34WWW --> L34Challenges["Document<br>Challenges"]
|
||||
L34Challenges --> L34Lessons["Document<br>Lessons Learned"]
|
||||
L34Lessons --> L34ImproveProcess["Document Process<br>Improvements"]
|
||||
L34ImproveProcess --> L34Update["Update<br>tasks.md"]
|
||||
|
||||
%% Completion & Transition
|
||||
L1Update & L2Update & L34Update --> CreateReflection["Create<br>reflection.md"]
|
||||
CreateReflection --> UpdateSystem["Update System<br>Documentation"]
|
||||
UpdateSystem --> Transition["NEXT MODE:<br>ARCHIVE MODE"]
|
||||
```
|
||||
|
||||
## 📋 REFLECTION STRUCTURE
|
||||
|
||||
The reflection should follow this structured format:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Reflection Document Structure"
|
||||
Header["# TASK REFLECTION: [Task Name]"]
|
||||
Summary["## SUMMARY<br>Brief summary of completed task"]
|
||||
WWW["## WHAT WENT WELL<br>Successful aspects of implementation"]
|
||||
Challenges["## CHALLENGES<br>Difficulties encountered during implementation"]
|
||||
Lessons["## LESSONS LEARNED<br>Key insights gained from the experience"]
|
||||
ProcessImp["## PROCESS IMPROVEMENTS<br>How to improve for future tasks"]
|
||||
TechImp["## TECHNICAL IMPROVEMENTS<br>Better approaches for similar tasks"]
|
||||
NextSteps["## NEXT STEPS<br>Follow-up actions or future work"]
|
||||
end
|
||||
|
||||
Header --> Summary --> WWW --> Challenges --> Lessons --> ProcessImp --> TechImp --> NextSteps
|
||||
```
|
||||
|
||||
## 📊 REQUIRED FILE STATE VERIFICATION
|
||||
|
||||
Before reflection can begin, verify file state:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["File State<br>Verification"] --> CheckTasks{"tasks.md has<br>implementation<br>complete?"}
|
||||
|
||||
CheckTasks -->|"No"| ErrorBuild["ERROR:<br>Return to BUILD Mode"]
|
||||
CheckTasks -->|"Yes"| CheckProgress{"progress.md<br>has implementation<br>details?"}
|
||||
|
||||
CheckProgress -->|"No"| ErrorProgress["ERROR:<br>Update progress.md first"]
|
||||
CheckProgress -->|"Yes"| ReadyReflect["Ready for<br>Reflection"]
|
||||
```
|
||||
|
||||
## 🔍 IMPLEMENTATION REVIEW APPROACH
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Implementation Review"
|
||||
Original["Review Original<br>Requirements"]
|
||||
Plan["Compare Against<br>Implementation Plan"]
|
||||
Actual["Assess Actual<br>Implementation"]
|
||||
Creative["Review Creative<br>Phase Decisions"]
|
||||
Changes["Identify Deviations<br>from Plan"]
|
||||
Results["Evaluate<br>Results"]
|
||||
end
|
||||
|
||||
Original --> Plan --> Actual
|
||||
Plan --> Creative --> Changes
|
||||
Actual --> Results
|
||||
Changes --> Results
|
||||
```
|
||||
|
||||
## 📝 REFLECTION DOCUMENT TEMPLATES
|
||||
|
||||
### Level 1 (Basic) Reflection
|
||||
```
|
||||
# Bug Fix Reflection: [Bug Name]
|
||||
|
||||
## Summary
|
||||
[Brief description of the bug and solution]
|
||||
|
||||
## Implementation
|
||||
[Description of the fix implemented]
|
||||
|
||||
## Testing
|
||||
[Description of testing performed]
|
||||
|
||||
## Additional Notes
|
||||
[Any other relevant information]
|
||||
```
|
||||
|
||||
### Levels 2-4 (Comprehensive) Reflection
|
||||
```
|
||||
# Task Reflection: [Task Name]
|
||||
|
||||
## Summary
|
||||
[Brief summary of the task and what was achieved]
|
||||
|
||||
## What Went Well
|
||||
- [Success point 1]
|
||||
- [Success point 2]
|
||||
- [Success point 3]
|
||||
|
||||
## Challenges
|
||||
- [Challenge 1]: [How it was addressed]
|
||||
- [Challenge 2]: [How it was addressed]
|
||||
- [Challenge 3]: [How it was addressed]
|
||||
|
||||
## Lessons Learned
|
||||
- [Lesson 1]
|
||||
- [Lesson 2]
|
||||
- [Lesson 3]
|
||||
|
||||
## Process Improvements
|
||||
- [Process improvement 1]
|
||||
- [Process improvement 2]
|
||||
|
||||
## Technical Improvements
|
||||
- [Technical improvement 1]
|
||||
- [Technical improvement 2]
|
||||
|
||||
## Next Steps
|
||||
- [Follow-up task 1]
|
||||
- [Follow-up task 2]
|
||||
```
|
||||
|
||||
## 📊 REFLECTION QUALITY METRICS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
subgraph "Reflection Quality Metrics"
|
||||
Specific["Specific<br>Not general or vague"]
|
||||
Actionable["Actionable<br>Provides clear direction"]
|
||||
Honest["Honest<br>Acknowledges successes and failures"]
|
||||
Forward["Forward-Looking<br>Focuses on future improvement"]
|
||||
Evidence["Evidence-Based<br>Based on concrete examples"]
|
||||
end
|
||||
```
|
||||
|
||||
## 📋 TASKS.MD UPDATE FORMAT
|
||||
|
||||
During reflection, update tasks.md with:
|
||||
|
||||
```
|
||||
## Status
|
||||
- [x] Initialization complete
|
||||
- [x] Planning complete
|
||||
[For Level 3-4:]
|
||||
- [x] Creative phases complete
|
||||
- [x] Implementation complete
|
||||
- [x] Reflection complete
|
||||
- [ ] Archiving
|
||||
|
||||
## Reflection Highlights
|
||||
- **What Went Well**: [Key successes]
|
||||
- **Challenges**: [Key challenges]
|
||||
- **Lessons Learned**: [Key lessons]
|
||||
- **Next Steps**: [Follow-up actions]
|
||||
```
|
||||
|
||||
## 📊 REFLECTION VERIFICATION CHECKLIST
|
||||
|
||||
```
|
||||
✓ REFLECTION VERIFICATION
|
||||
- Implementation thoroughly reviewed? [YES/NO]
|
||||
- What Went Well section completed? [YES/NO]
|
||||
- Challenges section completed? [YES/NO]
|
||||
- Lessons Learned section completed? [YES/NO]
|
||||
- Process Improvements identified? [YES/NO]
|
||||
- Technical Improvements identified? [YES/NO]
|
||||
- Next Steps documented? [YES/NO]
|
||||
- reflection.md created? [YES/NO]
|
||||
- tasks.md updated with reflection status? [YES/NO]
|
||||
|
||||
→ If all YES: Reflection complete - ready for ARCHIVE mode
|
||||
→ If any NO: Complete missing reflection elements
|
||||
```
|
||||
|
||||
## 🔄 MODE TRANSITION NOTIFICATION
|
||||
|
||||
When reflection is complete, notify user with:
|
||||
|
||||
```
|
||||
## REFLECTION COMPLETE
|
||||
|
||||
✅ Implementation thoroughly reviewed
|
||||
✅ Reflection document created
|
||||
✅ Lessons learned documented
|
||||
✅ Process improvements identified
|
||||
✅ tasks.md updated with reflection status
|
||||
|
||||
→ NEXT RECOMMENDED MODE: ARCHIVE MODE
|
||||
```
|
||||
@@ -0,0 +1,902 @@
|
||||
---
|
||||
description: Visual process map for VAN mode (Initialization)
|
||||
globs: van-mode-map.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN MODE: INITIALIZATION PROCESS MAP
|
||||
|
||||
> **TL;DR:** This visual map defines the VAN mode process for project initialization, task analysis, and technical validation. It guides users through platform detection, file verification, complexity determination, and technical validation to ensure proper setup before implementation.
|
||||
|
||||
## 🧭 VAN MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["START VAN MODE"] --> PlatformDetect["PLATFORM DETECTION"]
|
||||
PlatformDetect --> DetectOS["Detect Operating System"]
|
||||
DetectOS --> CheckPath["Check Path Separator Format"]
|
||||
CheckPath --> AdaptCmds["Adapt Commands if Needed"]
|
||||
AdaptCmds --> PlatformCP["⛔ PLATFORM CHECKPOINT"]
|
||||
|
||||
%% Basic File Verification with checkpoint
|
||||
PlatformCP --> BasicFileVerify["BASIC FILE VERIFICATION"]
|
||||
BasicFileVerify --> BatchCheck["Batch Check Essential Components"]
|
||||
BatchCheck --> BatchCreate["Batch Create Essential Structure"]
|
||||
BatchCreate --> BasicFileCP["⛔ BASIC FILE CHECKPOINT"]
|
||||
|
||||
%% Early Complexity Determination
|
||||
BasicFileCP --> EarlyComplexity["EARLY COMPLEXITY DETERMINATION"]
|
||||
EarlyComplexity --> AnalyzeTask["Analyze Task Requirements"]
|
||||
AnalyzeTask --> EarlyLevelCheck{"Complexity Level?"}
|
||||
|
||||
%% Level handling paths
|
||||
EarlyLevelCheck -->|"Level 1"| ComplexityCP["⛔ COMPLEXITY CHECKPOINT"]
|
||||
EarlyLevelCheck -->|"Level 2-4"| CRITICALGATE["🚫 CRITICAL GATE: FORCE MODE SWITCH"]
|
||||
CRITICALGATE --> ForceExit["Exit to PLAN mode"]
|
||||
|
||||
%% Level 1 continues normally
|
||||
ComplexityCP --> InitSystem["INITIALIZE MEMORY BANK"]
|
||||
InitSystem --> Complete1["LEVEL 1 INITIALIZATION COMPLETE"]
|
||||
|
||||
%% For Level 2+ tasks after PLAN and CREATIVE modes
|
||||
ForceExit -.-> OtherModes["PLAN → CREATIVE modes"]
|
||||
OtherModes -.-> VANQA["VAN QA MODE"]
|
||||
VANQA --> QAProcess["Technical Validation Process"]
|
||||
QAProcess --> QACheck{"All Checks Pass?"}
|
||||
QACheck -->|"Yes"| BUILD["To BUILD MODE"]
|
||||
QACheck -->|"No"| FixIssues["Fix Technical Issues"]
|
||||
FixIssues --> QAProcess
|
||||
|
||||
%% Style nodes
|
||||
style PlatformCP fill:#f55,stroke:#d44,color:white
|
||||
style BasicFileCP fill:#f55,stroke:#d44,color:white
|
||||
style ComplexityCP fill:#f55,stroke:#d44,color:white
|
||||
style CRITICALGATE fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style ForceExit fill:#ff0000,stroke:#990000,color:white,stroke-width:2px
|
||||
style VANQA fill:#4da6ff,stroke:#0066cc,color:white,stroke-width:3px
|
||||
style QAProcess fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style QACheck fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FixIssues fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 🌐 PLATFORM DETECTION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
PD["Platform Detection"] --> CheckOS["Detect Operating System"]
|
||||
CheckOS --> Win["Windows"]
|
||||
CheckOS --> Mac["macOS"]
|
||||
CheckOS --> Lin["Linux"]
|
||||
|
||||
Win & Mac & Lin --> Adapt["Adapt Commands<br>for Platform"]
|
||||
|
||||
Win --> WinPath["Path: Backslash (\\)"]
|
||||
Mac --> MacPath["Path: Forward Slash (/)"]
|
||||
Lin --> LinPath["Path: Forward Slash (/)"]
|
||||
|
||||
Win --> WinCmd["Command Adaptations:<br>dir, icacls, etc."]
|
||||
Mac --> MacCmd["Command Adaptations:<br>ls, chmod, etc."]
|
||||
Lin --> LinCmd["Command Adaptations:<br>ls, chmod, etc."]
|
||||
|
||||
WinPath & MacPath & LinPath --> PathCP["Path Separator<br>Checkpoint"]
|
||||
WinCmd & MacCmd & LinCmd --> CmdCP["Command<br>Checkpoint"]
|
||||
|
||||
PathCP & CmdCP --> PlatformComplete["Platform Detection<br>Complete"]
|
||||
|
||||
style PD fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style PlatformComplete fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
## 📁 FILE VERIFICATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
FV["File Verification"] --> CheckFiles["Check Essential Files"]
|
||||
CheckFiles --> CheckMB["Check Memory Bank<br>Structure"]
|
||||
CheckMB --> MBExists{"Memory Bank<br>Exists?"}
|
||||
|
||||
MBExists -->|"Yes"| VerifyMB["Verify Memory Bank<br>Contents"]
|
||||
MBExists -->|"No"| CreateMB["Create Memory Bank<br>Structure"]
|
||||
|
||||
CheckFiles --> CheckDocs["Check Documentation<br>Files"]
|
||||
CheckDocs --> DocsExist{"Docs<br>Exist?"}
|
||||
|
||||
DocsExist -->|"Yes"| VerifyDocs["Verify Documentation<br>Structure"]
|
||||
DocsExist -->|"No"| CreateDocs["Create Documentation<br>Structure"]
|
||||
|
||||
VerifyMB & CreateMB --> MBCP["Memory Bank<br>Checkpoint"]
|
||||
VerifyDocs & CreateDocs --> DocsCP["Documentation<br>Checkpoint"]
|
||||
|
||||
MBCP & DocsCP --> FileComplete["File Verification<br>Complete"]
|
||||
|
||||
style FV fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FileComplete fill:#10b981,stroke:#059669,color:white
|
||||
style MBCP fill:#f6546a,stroke:#c30052,color:white
|
||||
style DocsCP fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
## 🧩 COMPLEXITY DETERMINATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
CD["Complexity<br>Determination"] --> AnalyzeTask["Analyze Task<br>Requirements"]
|
||||
|
||||
AnalyzeTask --> CheckKeywords["Check Task<br>Keywords"]
|
||||
CheckKeywords --> ScopeCheck["Assess<br>Scope Impact"]
|
||||
ScopeCheck --> RiskCheck["Evaluate<br>Risk Level"]
|
||||
RiskCheck --> EffortCheck["Estimate<br>Implementation Effort"]
|
||||
|
||||
EffortCheck --> DetermineLevel{"Determine<br>Complexity Level"}
|
||||
DetermineLevel -->|"Level 1"| L1["Level 1:<br>Quick Bug Fix"]
|
||||
DetermineLevel -->|"Level 2"| L2["Level 2:<br>Simple Enhancement"]
|
||||
DetermineLevel -->|"Level 3"| L3["Level 3:<br>Intermediate Feature"]
|
||||
DetermineLevel -->|"Level 4"| L4["Level 4:<br>Complex System"]
|
||||
|
||||
L1 --> CDComplete["Complexity Determination<br>Complete"]
|
||||
L2 & L3 & L4 --> ModeSwitch["Force Mode Switch<br>to PLAN"]
|
||||
|
||||
style CD fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style CDComplete fill:#10b981,stroke:#059669,color:white
|
||||
style ModeSwitch fill:#ff0000,stroke:#990000,color:white
|
||||
style DetermineLevel fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
## 🔄 COMPLETE WORKFLOW WITH QA VALIDATION
|
||||
|
||||
The full workflow includes technical validation before implementation:
|
||||
|
||||
```mermaid
|
||||
flowchart LR
|
||||
VAN1["VAN MODE
|
||||
(Initial Analysis)"] --> PLAN["PLAN MODE
|
||||
(Task Planning)"]
|
||||
PLAN --> CREATIVE["CREATIVE MODE
|
||||
(Design Decisions)"]
|
||||
CREATIVE --> VANQA["VAN QA MODE
|
||||
(Technical Validation)"]
|
||||
VANQA --> BUILD["BUILD MODE
|
||||
(Implementation)"]
|
||||
```
|
||||
|
||||
## 🔍 TECHNICAL VALIDATION OVERVIEW
|
||||
|
||||
The VAN QA technical validation process consists of four key validation points:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
VANQA["VAN QA MODE"] --> FourChecks["FOUR-POINT VALIDATION"]
|
||||
|
||||
FourChecks --> DepCheck["1️⃣ DEPENDENCY VERIFICATION<br>Check all required packages"]
|
||||
DepCheck --> ConfigCheck["2️⃣ CONFIGURATION VALIDATION<br>Verify format & compatibility"]
|
||||
ConfigCheck --> EnvCheck["3️⃣ ENVIRONMENT VALIDATION<br>Check build environment"]
|
||||
EnvCheck --> MinBuildCheck["4️⃣ MINIMAL BUILD TEST<br>Test core functionality"]
|
||||
|
||||
MinBuildCheck --> ValidationResults{"All Checks<br>Passed?"}
|
||||
ValidationResults -->|"Yes"| SuccessReport["GENERATE SUCCESS REPORT"]
|
||||
ValidationResults -->|"No"| FailureReport["GENERATE FAILURE REPORT"]
|
||||
|
||||
SuccessReport --> BUILD["Proceed to BUILD MODE"]
|
||||
FailureReport --> FixIssues["Fix Technical Issues"]
|
||||
FixIssues --> ReValidate["Re-validate"]
|
||||
ReValidate --> ValidationResults
|
||||
|
||||
style VANQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FourChecks fill:#f6546a,stroke:#c30052,color:white
|
||||
style ValidationResults fill:#f6546a,stroke:#c30052,color:white
|
||||
style BUILD fill:#10b981,stroke:#059669,color:white
|
||||
style FixIssues fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 📝 VALIDATION STATUS FORMAT
|
||||
|
||||
The QA Validation step includes clear status indicators:
|
||||
|
||||
```
|
||||
╔═════════════════ 🔍 QA VALIDATION STATUS ═════════════════╗
|
||||
│ ✓ Design Decisions │ Verified as implementable │
|
||||
│ ✓ Dependencies │ All required packages installed │
|
||||
│ ✓ Configurations │ Format verified for platform │
|
||||
│ ✓ Environment │ Suitable for implementation │
|
||||
╚════════════════════════════════════════════════════════════╝
|
||||
✅ VERIFIED - Clear to proceed to BUILD mode
|
||||
```
|
||||
|
||||
## 🚨 MODE TRANSITION TRIGGERS
|
||||
|
||||
### VAN to PLAN Transition
|
||||
For complexity levels 2-4:
|
||||
```
|
||||
🚫 LEVEL [2-4] TASK DETECTED
|
||||
Implementation in VAN mode is BLOCKED
|
||||
This task REQUIRES PLAN mode
|
||||
You MUST switch to PLAN mode for proper documentation and planning
|
||||
Type 'PLAN' to switch to planning mode
|
||||
```
|
||||
|
||||
### CREATIVE to VAN QA Transition
|
||||
After completing the CREATIVE mode:
|
||||
```
|
||||
⏭️ NEXT MODE: VAN QA
|
||||
To validate technical requirements before implementation, please type 'VAN QA'
|
||||
```
|
||||
|
||||
### VAN QA to BUILD Transition
|
||||
After successful validation:
|
||||
```
|
||||
✅ TECHNICAL VALIDATION COMPLETE
|
||||
All prerequisites verified successfully
|
||||
You may now proceed to BUILD mode
|
||||
Type 'BUILD' to begin implementation
|
||||
```
|
||||
|
||||
## 🔒 BUILD MODE PREVENTION MECHANISM
|
||||
|
||||
The system prevents moving to BUILD mode without passing QA validation:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["User Types: BUILD"] --> CheckQA{"QA Validation<br>Completed?"}
|
||||
CheckQA -->|"Yes and Passed"| AllowBuild["Allow BUILD Mode"]
|
||||
CheckQA -->|"No or Failed"| BlockBuild["BLOCK BUILD MODE"]
|
||||
BlockBuild --> Message["Display:<br>⚠️ QA VALIDATION REQUIRED"]
|
||||
Message --> ReturnToVANQA["Prompt: Type VAN QA"]
|
||||
|
||||
style CheckQA fill:#f6546a,stroke:#c30052,color:white
|
||||
style BlockBuild fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style Message fill:#ff5555,stroke:#dd3333,color:white
|
||||
style ReturnToVANQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
```
|
||||
|
||||
## 🔄 QA COMMAND PRECEDENCE
|
||||
|
||||
QA validation can be called at any point in the process flow, and takes immediate precedence over any other current steps, including forced mode switches:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
UserQA["User Types: QA"] --> HighPriority["⚠️ HIGH PRIORITY COMMAND"]
|
||||
HighPriority --> CurrentTask["Pause Current Task/Process"]
|
||||
CurrentTask --> LoadQA["Load QA Mode Map"]
|
||||
LoadQA --> RunQA["Execute QA Validation Process"]
|
||||
RunQA --> QAResults{"QA Results"}
|
||||
|
||||
QAResults -->|"PASS"| ResumeFlow["Resume Prior Process Flow"]
|
||||
QAResults -->|"FAIL"| FixIssues["Fix Identified Issues"]
|
||||
FixIssues --> ReRunQA["Re-run QA Validation"]
|
||||
ReRunQA --> QAResults
|
||||
|
||||
style UserQA fill:#f8d486,stroke:#e8b84d,color:black
|
||||
style HighPriority fill:#ff0000,stroke:#cc0000,color:white,stroke-width:3px
|
||||
style LoadQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style RunQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style QAResults fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### QA Interruption Rules
|
||||
|
||||
When a user types **QA** at any point:
|
||||
|
||||
1. **The QA command MUST take immediate precedence** over any current operation, including the "FORCE MODE SWITCH" triggered by complexity assessment.
|
||||
2. The system MUST:
|
||||
- Immediately load the QA mode map
|
||||
- Execute the full QA validation process
|
||||
- Address any failures before continuing
|
||||
3. **Required remediation steps take priority** over any pending mode switches or complexity rules
|
||||
4. After QA validation is complete and passes:
|
||||
- Resume the previously determined process flow
|
||||
- Continue with any required mode switches
|
||||
|
||||
```
|
||||
⚠️ QA OVERRIDE ACTIVATED
|
||||
All other processes paused
|
||||
QA validation checks now running...
|
||||
Any issues found MUST be remediated before continuing with normal process flow
|
||||
```
|
||||
|
||||
## 📋 CHECKPOINT VERIFICATION TEMPLATE
|
||||
|
||||
Each major checkpoint in VAN mode uses this format:
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: [SECTION NAME]
|
||||
- Requirement 1? [YES/NO]
|
||||
- Requirement 2? [YES/NO]
|
||||
- Requirement 3? [YES/NO]
|
||||
|
||||
→ If all YES: Ready for next section
|
||||
→ If any NO: Fix missing items before proceeding
|
||||
```
|
||||
|
||||
## 🚀 VAN MODE ACTIVATION
|
||||
|
||||
When the user types "VAN", respond with a confirmation and start the process:
|
||||
|
||||
```
|
||||
User: VAN
|
||||
|
||||
Response: OK VAN - Beginning Initialization Process
|
||||
```
|
||||
|
||||
After completing CREATIVE mode, when the user types "VAN QA", respond:
|
||||
|
||||
```
|
||||
User: VAN QA
|
||||
|
||||
Response: OK VAN QA - Beginning Technical Validation
|
||||
```
|
||||
|
||||
This ensures clear communication about which phase of VAN mode is active.
|
||||
|
||||
## 🔍 DETAILED QA VALIDATION PROCESS
|
||||
|
||||
### 1️⃣ DEPENDENCY VERIFICATION
|
||||
|
||||
This step verifies that all required packages are installed and compatible:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Dependency Verification"] --> ReadDeps["Read Required Dependencies<br>from Creative Phase"]
|
||||
ReadDeps --> CheckInstalled["Check if Dependencies<br>are Installed"]
|
||||
CheckInstalled --> DepStatus{"All Dependencies<br>Installed?"}
|
||||
|
||||
DepStatus -->|"Yes"| VerifyVersions["Verify Versions<br>and Compatibility"]
|
||||
DepStatus -->|"No"| InstallMissing["Install Missing<br>Dependencies"]
|
||||
InstallMissing --> VerifyVersions
|
||||
|
||||
VerifyVersions --> VersionStatus{"Versions<br>Compatible?"}
|
||||
VersionStatus -->|"Yes"| DepSuccess["Dependencies Verified<br>✅ PASS"]
|
||||
VersionStatus -->|"No"| UpgradeVersions["Upgrade/Downgrade<br>as Needed"]
|
||||
UpgradeVersions --> RetryVerify["Retry Verification"]
|
||||
RetryVerify --> VersionStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style DepSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style DepStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style VersionStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Windows (PowerShell) Implementation:
|
||||
```powershell
|
||||
# Example: Verify Node.js dependencies for a React project
|
||||
function Verify-Dependencies {
|
||||
$requiredDeps = @{
|
||||
"node" = ">=14.0.0"
|
||||
"npm" = ">=6.0.0"
|
||||
}
|
||||
|
||||
$missingDeps = @()
|
||||
$incompatibleDeps = @()
|
||||
|
||||
# Check Node.js version
|
||||
$nodeVersion = $null
|
||||
try {
|
||||
$nodeVersion = node -v
|
||||
if ($nodeVersion -match "v(\d+)\.(\d+)\.(\d+)") {
|
||||
$major = [int]$Matches[1]
|
||||
if ($major -lt 14) {
|
||||
$incompatibleDeps += "node (found $nodeVersion, required >=14.0.0)"
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
$missingDeps += "node"
|
||||
}
|
||||
|
||||
# Check npm version
|
||||
$npmVersion = $null
|
||||
try {
|
||||
$npmVersion = npm -v
|
||||
if ($npmVersion -match "(\d+)\.(\d+)\.(\d+)") {
|
||||
$major = [int]$Matches[1]
|
||||
if ($major -lt 6) {
|
||||
$incompatibleDeps += "npm (found $npmVersion, required >=6.0.0)"
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
$missingDeps += "npm"
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($missingDeps.Count -eq 0 -and $incompatibleDeps.Count -eq 0) {
|
||||
Write-Output "✅ All dependencies verified and compatible"
|
||||
return $true
|
||||
} else {
|
||||
if ($missingDeps.Count -gt 0) {
|
||||
Write-Output "❌ Missing dependencies: $($missingDeps -join ', ')"
|
||||
}
|
||||
if ($incompatibleDeps.Count -gt 0) {
|
||||
Write-Output "❌ Incompatible versions: $($incompatibleDeps -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Mac/Linux (Bash) Implementation:
|
||||
```bash
|
||||
#!/bin/bash
|
||||
|
||||
# Example: Verify Node.js dependencies for a React project
|
||||
verify_dependencies() {
|
||||
local missing_deps=()
|
||||
local incompatible_deps=()
|
||||
|
||||
# Check Node.js version
|
||||
if command -v node &> /dev/null; then
|
||||
local node_version=$(node -v)
|
||||
if [[ $node_version =~ v([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
|
||||
local major=${BASH_REMATCH[1]}
|
||||
if (( major < 14 )); then
|
||||
incompatible_deps+=("node (found $node_version, required >=14.0.0)")
|
||||
fi
|
||||
fi
|
||||
else
|
||||
missing_deps+=("node")
|
||||
fi
|
||||
|
||||
# Check npm version
|
||||
if command -v npm &> /dev/null; then
|
||||
local npm_version=$(npm -v)
|
||||
if [[ $npm_version =~ ([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
|
||||
local major=${BASH_REMATCH[1]}
|
||||
if (( major < 6 )); then
|
||||
incompatible_deps+=("npm (found $npm_version, required >=6.0.0)")
|
||||
fi
|
||||
fi
|
||||
else
|
||||
missing_deps+=("npm")
|
||||
fi
|
||||
|
||||
# Display results
|
||||
if [ ${#missing_deps[@]} -eq 0 ] && [ ${#incompatible_deps[@]} -eq 0 ]; then
|
||||
echo "✅ All dependencies verified and compatible"
|
||||
return 0
|
||||
else
|
||||
if [ ${#missing_deps[@]} -gt 0 ]; then
|
||||
echo "❌ Missing dependencies: ${missing_deps[*]}"
|
||||
fi
|
||||
if [ ${#incompatible_deps[@]} -gt 0 ]; then
|
||||
echo "❌ Incompatible versions: ${incompatible_deps[*]}"
|
||||
fi
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
```
|
||||
|
||||
### 2️⃣ CONFIGURATION VALIDATION
|
||||
|
||||
This step validates configuration files format and compatibility:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Configuration Validation"] --> IdentifyConfigs["Identify Configuration<br>Files"]
|
||||
IdentifyConfigs --> ReadConfigs["Read Configuration<br>Files"]
|
||||
ReadConfigs --> ValidateSyntax["Validate Syntax<br>and Format"]
|
||||
ValidateSyntax --> SyntaxStatus{"Syntax<br>Valid?"}
|
||||
|
||||
SyntaxStatus -->|"Yes"| CheckCompatibility["Check Compatibility<br>with Platform"]
|
||||
SyntaxStatus -->|"No"| FixSyntax["Fix Syntax<br>Errors"]
|
||||
FixSyntax --> RetryValidate["Retry Validation"]
|
||||
RetryValidate --> SyntaxStatus
|
||||
|
||||
CheckCompatibility --> CompatStatus{"Compatible with<br>Platform?"}
|
||||
CompatStatus -->|"Yes"| ConfigSuccess["Configurations Validated<br>✅ PASS"]
|
||||
CompatStatus -->|"No"| AdaptConfigs["Adapt Configurations<br>for Platform"]
|
||||
AdaptConfigs --> RetryCompat["Retry Compatibility<br>Check"]
|
||||
RetryCompat --> CompatStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ConfigSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style SyntaxStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style CompatStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Configuration Validation Implementation:
|
||||
```powershell
|
||||
# Example: Validate configuration files for a web project
|
||||
function Validate-Configurations {
|
||||
$configFiles = @(
|
||||
"package.json",
|
||||
"tsconfig.json",
|
||||
"vite.config.js"
|
||||
)
|
||||
|
||||
$invalidConfigs = @()
|
||||
$incompatibleConfigs = @()
|
||||
|
||||
foreach ($configFile in $configFiles) {
|
||||
if (Test-Path $configFile) {
|
||||
# Check JSON syntax for JSON files
|
||||
if ($configFile -match "\.json$") {
|
||||
try {
|
||||
Get-Content $configFile -Raw | ConvertFrom-Json | Out-Null
|
||||
} catch {
|
||||
$invalidConfigs += "$configFile (JSON syntax error: $($_.Exception.Message))"
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
# Specific configuration compatibility checks
|
||||
if ($configFile -eq "vite.config.js") {
|
||||
$content = Get-Content $configFile -Raw
|
||||
# Check for React plugin in Vite config
|
||||
if ($content -notmatch "react\(\)") {
|
||||
$incompatibleConfigs += "$configFile (Missing React plugin for React project)"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$invalidConfigs += "$configFile (file not found)"
|
||||
}
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($invalidConfigs.Count -eq 0 -and $incompatibleConfigs.Count -eq 0) {
|
||||
Write-Output "✅ All configurations validated and compatible"
|
||||
return $true
|
||||
} else {
|
||||
if ($invalidConfigs.Count -gt 0) {
|
||||
Write-Output "❌ Invalid configurations: $($invalidConfigs -join ', ')"
|
||||
}
|
||||
if ($incompatibleConfigs.Count -gt 0) {
|
||||
Write-Output "❌ Incompatible configurations: $($incompatibleConfigs -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 3️⃣ ENVIRONMENT VALIDATION
|
||||
|
||||
This step checks if the environment is properly set up for the implementation:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Environment Validation"] --> CheckEnv["Check Build Environment"]
|
||||
CheckEnv --> VerifyBuildTools["Verify Build Tools"]
|
||||
VerifyBuildTools --> ToolsStatus{"Build Tools<br>Available?"}
|
||||
|
||||
ToolsStatus -->|"Yes"| CheckPerms["Check Permissions<br>and Access"]
|
||||
ToolsStatus -->|"No"| InstallTools["Install Required<br>Build Tools"]
|
||||
InstallTools --> RetryTools["Retry Verification"]
|
||||
RetryTools --> ToolsStatus
|
||||
|
||||
CheckPerms --> PermsStatus{"Permissions<br>Sufficient?"}
|
||||
PermsStatus -->|"Yes"| EnvSuccess["Environment Validated<br>✅ PASS"]
|
||||
PermsStatus -->|"No"| FixPerms["Fix Permission<br>Issues"]
|
||||
FixPerms --> RetryPerms["Retry Permission<br>Check"]
|
||||
RetryPerms --> PermsStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style EnvSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style ToolsStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style PermsStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Environment Validation Implementation:
|
||||
```powershell
|
||||
# Example: Validate environment for a web project
|
||||
function Validate-Environment {
|
||||
$requiredTools = @(
|
||||
@{Name = "git"; Command = "git --version"},
|
||||
@{Name = "node"; Command = "node --version"},
|
||||
@{Name = "npm"; Command = "npm --version"}
|
||||
)
|
||||
|
||||
$missingTools = @()
|
||||
$permissionIssues = @()
|
||||
|
||||
# Check build tools
|
||||
foreach ($tool in $requiredTools) {
|
||||
try {
|
||||
Invoke-Expression $tool.Command | Out-Null
|
||||
} catch {
|
||||
$missingTools += $tool.Name
|
||||
}
|
||||
}
|
||||
|
||||
# Check write permissions in project directory
|
||||
try {
|
||||
$testFile = ".__permission_test"
|
||||
New-Item -Path $testFile -ItemType File -Force | Out-Null
|
||||
Remove-Item -Path $testFile -Force
|
||||
} catch {
|
||||
$permissionIssues += "Current directory (write permission denied)"
|
||||
}
|
||||
|
||||
# Check if port 3000 is available (commonly used for dev servers)
|
||||
try {
|
||||
$listener = New-Object System.Net.Sockets.TcpListener([System.Net.IPAddress]::Loopback, 3000)
|
||||
$listener.Start()
|
||||
$listener.Stop()
|
||||
} catch {
|
||||
$permissionIssues += "Port 3000 (already in use or access denied)"
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($missingTools.Count -eq 0 -and $permissionIssues.Count -eq 0) {
|
||||
Write-Output "✅ Environment validated successfully"
|
||||
return $true
|
||||
} else {
|
||||
if ($missingTools.Count -gt 0) {
|
||||
Write-Output "❌ Missing tools: $($missingTools -join ', ')"
|
||||
}
|
||||
if ($permissionIssues.Count -gt 0) {
|
||||
Write-Output "❌ Permission issues: $($permissionIssues -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 4️⃣ MINIMAL BUILD TEST
|
||||
|
||||
This step performs a minimal build test to ensure core functionality:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Minimal Build Test"] --> CreateTest["Create Minimal<br>Test Project"]
|
||||
CreateTest --> BuildTest["Attempt<br>Build"]
|
||||
BuildTest --> BuildStatus{"Build<br>Successful?"}
|
||||
|
||||
BuildStatus -->|"Yes"| RunTest["Run Basic<br>Functionality Test"]
|
||||
BuildStatus -->|"No"| FixBuild["Fix Build<br>Issues"]
|
||||
FixBuild --> RetryBuild["Retry Build"]
|
||||
RetryBuild --> BuildStatus
|
||||
|
||||
RunTest --> TestStatus{"Test<br>Passed?"}
|
||||
TestStatus -->|"Yes"| TestSuccess["Minimal Build Test<br>✅ PASS"]
|
||||
TestStatus -->|"No"| FixTest["Fix Test<br>Issues"]
|
||||
FixTest --> RetryTest["Retry Test"]
|
||||
RetryTest --> TestStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TestSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style BuildStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style TestStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Minimal Build Test Implementation:
|
||||
```powershell
|
||||
# Example: Perform minimal build test for a React project
|
||||
function Perform-MinimalBuildTest {
|
||||
$buildSuccess = $false
|
||||
$testSuccess = $false
|
||||
|
||||
# Create minimal test project
|
||||
$testDir = ".__build_test"
|
||||
if (Test-Path $testDir) {
|
||||
Remove-Item -Path $testDir -Recurse -Force
|
||||
}
|
||||
|
||||
try {
|
||||
# Create minimal test directory
|
||||
New-Item -Path $testDir -ItemType Directory | Out-Null
|
||||
Push-Location $testDir
|
||||
|
||||
# Initialize minimal package.json
|
||||
@"
|
||||
{
|
||||
"name": "build-test",
|
||||
"version": "1.0.0",
|
||||
"description": "Minimal build test",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"build": "echo Build test successful"
|
||||
}
|
||||
}
|
||||
"@ | Set-Content -Path "package.json"
|
||||
|
||||
# Attempt build
|
||||
npm run build | Out-Null
|
||||
$buildSuccess = $true
|
||||
|
||||
# Create minimal test file
|
||||
@"
|
||||
console.log('Test successful');
|
||||
"@ | Set-Content -Path "index.js"
|
||||
|
||||
# Run basic test
|
||||
node index.js | Out-Null
|
||||
$testSuccess = $true
|
||||
|
||||
} catch {
|
||||
Write-Output "❌ Build test failed: $($_.Exception.Message)"
|
||||
} finally {
|
||||
Pop-Location
|
||||
if (Test-Path $testDir) {
|
||||
Remove-Item -Path $testDir -Recurse -Force
|
||||
}
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($buildSuccess -and $testSuccess) {
|
||||
Write-Output "✅ Minimal build test passed successfully"
|
||||
return $true
|
||||
} else {
|
||||
if (-not $buildSuccess) {
|
||||
Write-Output "❌ Build process failed"
|
||||
}
|
||||
if (-not $testSuccess) {
|
||||
Write-Output "❌ Basic functionality test failed"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 COMPREHENSIVE QA REPORT FORMAT
|
||||
|
||||
After running all validation steps, a comprehensive report is generated:
|
||||
|
||||
```
|
||||
╔═════════════════════ 🔍 QA VALIDATION REPORT ══════════════════════╗
|
||||
│ │
|
||||
│ PROJECT: [Project Name] │
|
||||
│ TIMESTAMP: [Current Date/Time] │
|
||||
│ │
|
||||
│ 1️⃣ DEPENDENCY VERIFICATION │
|
||||
│ ✓ Required: [List of required dependencies] │
|
||||
│ ✓ Installed: [List of installed dependencies] │
|
||||
│ ✓ Compatible: [Yes/No] │
|
||||
│ │
|
||||
│ 2️⃣ CONFIGURATION VALIDATION │
|
||||
│ ✓ Config Files: [List of configuration files] │
|
||||
│ ✓ Syntax Valid: [Yes/No] │
|
||||
│ ✓ Platform Compatible: [Yes/No] │
|
||||
│ │
|
||||
│ 3️⃣ ENVIRONMENT VALIDATION │
|
||||
│ ✓ Build Tools: [Available/Missing] │
|
||||
│ ✓ Permissions: [Sufficient/Insufficient] │
|
||||
│ ✓ Environment Ready: [Yes/No] │
|
||||
│ │
|
||||
│ 4️⃣ MINIMAL BUILD TEST │
|
||||
│ ✓ Build Process: [Successful/Failed] │
|
||||
│ ✓ Functionality Test: [Passed/Failed] │
|
||||
│ ✓ Build Ready: [Yes/No] │
|
||||
│ │
|
||||
│ 🚨 FINAL VERDICT: [PASS/FAIL] │
|
||||
│ ➡️ [Success message or error details] │
|
||||
╚═════════════════════════════════════════════════════════════════════╝
|
||||
```
|
||||
|
||||
## ❌ FAILURE REPORT FORMAT
|
||||
|
||||
If any validation step fails, a detailed failure report is generated:
|
||||
|
||||
```
|
||||
⚠️⚠️⚠️ QA VALIDATION FAILED ⚠️⚠️⚠️
|
||||
|
||||
The following issues must be resolved before proceeding to BUILD mode:
|
||||
|
||||
1️⃣ DEPENDENCY ISSUES:
|
||||
- [Detailed description of dependency issues]
|
||||
- [Recommended fix]
|
||||
|
||||
2️⃣ CONFIGURATION ISSUES:
|
||||
- [Detailed description of configuration issues]
|
||||
- [Recommended fix]
|
||||
|
||||
3️⃣ ENVIRONMENT ISSUES:
|
||||
- [Detailed description of environment issues]
|
||||
- [Recommended fix]
|
||||
|
||||
4️⃣ BUILD TEST ISSUES:
|
||||
- [Detailed description of build test issues]
|
||||
- [Recommended fix]
|
||||
|
||||
⚠️ BUILD MODE IS BLOCKED until these issues are resolved.
|
||||
Type 'VAN QA' after fixing the issues to re-validate.
|
||||
```
|
||||
|
||||
## 🔄 INTEGRATION WITH DESIGN DECISIONS
|
||||
|
||||
The VAN QA mode reads and validates design decisions from the CREATIVE phase:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Read Design Decisions"] --> ReadCreative["Parse Creative Phase<br>Documentation"]
|
||||
ReadCreative --> ExtractTech["Extract Technology<br>Choices"]
|
||||
ExtractTech --> ExtractDeps["Extract Required<br>Dependencies"]
|
||||
ExtractDeps --> BuildValidationPlan["Build Validation<br>Plan"]
|
||||
BuildValidationPlan --> StartValidation["Start Four-Point<br>Validation Process"]
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ExtractTech fill:#f6546a,stroke:#c30052,color:white
|
||||
style BuildValidationPlan fill:#10b981,stroke:#059669,color:white
|
||||
style StartValidation fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### Technology Extraction Process:
|
||||
```powershell
|
||||
# Example: Extract technology choices from creative phase documentation
|
||||
function Extract-TechnologyChoices {
|
||||
$techChoices = @{}
|
||||
|
||||
# Read from systemPatterns.md
|
||||
if (Test-Path "memory-bank\systemPatterns.md") {
|
||||
$content = Get-Content "memory-bank\systemPatterns.md" -Raw
|
||||
|
||||
# Extract framework choice
|
||||
if ($content -match "Framework:\s*(\w+)") {
|
||||
$techChoices["framework"] = $Matches[1]
|
||||
}
|
||||
|
||||
# Extract UI library choice
|
||||
if ($content -match "UI Library:\s*(\w+)") {
|
||||
$techChoices["ui_library"] = $Matches[1]
|
||||
}
|
||||
|
||||
# Extract state management choice
|
||||
if ($content -match "State Management:\s*([^\\n]+)") {
|
||||
$techChoices["state_management"] = $Matches[1].Trim()
|
||||
}
|
||||
}
|
||||
|
||||
return $techChoices
|
||||
}
|
||||
```
|
||||
|
||||
## 🚨 IMPLEMENTATION PREVENTION MECHANISM
|
||||
|
||||
If QA validation fails, the system prevents moving to BUILD mode:
|
||||
|
||||
```powershell
|
||||
# Example: Enforce QA validation before allowing BUILD mode
|
||||
function Check-QAValidationStatus {
|
||||
$qaStatusFile = "memory-bank\.qa_validation_status"
|
||||
|
||||
if (Test-Path $qaStatusFile) {
|
||||
$status = Get-Content $qaStatusFile -Raw
|
||||
if ($status -match "PASS") {
|
||||
return $true
|
||||
}
|
||||
}
|
||||
|
||||
# Display block message
|
||||
Write-Output "`n`n"
|
||||
Write-Output "🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫"
|
||||
Write-Output "⛔️ BUILD MODE BLOCKED: QA VALIDATION REQUIRED"
|
||||
Write-Output "⛔️ You must complete QA validation before proceeding to BUILD mode"
|
||||
Write-Output "`n"
|
||||
Write-Output "Type 'VAN QA' to perform technical validation"
|
||||
Write-Output "`n"
|
||||
Write-Output "🚫 NO IMPLEMENTATION CAN PROCEED WITHOUT VALIDATION 🚫"
|
||||
Write-Output "🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫"
|
||||
|
||||
return $false
|
||||
}
|
||||
```
|
||||
|
||||
## 🧪 COMMON QA VALIDATION FIXES
|
||||
|
||||
Here are common fixes for issues encountered during QA validation:
|
||||
|
||||
### Dependency Issues:
|
||||
- **Missing Node.js**: Install Node.js from https://nodejs.org/
|
||||
- **Outdated npm**: Run `npm install -g npm@latest` to update
|
||||
- **Missing packages**: Run `npm install` or `npm install [package-name]`
|
||||
|
||||
### Configuration Issues:
|
||||
- **Invalid JSON**: Use a JSON validator to check syntax
|
||||
- **Missing React plugin**: Add `import react from '@vitejs/plugin-react'` and `plugins: [react()]` to vite.config.js
|
||||
- **Incompatible TypeScript config**: Update `tsconfig.json` with correct React settings
|
||||
|
||||
### Environment Issues:
|
||||
- **Permission denied**: Run terminal as administrator (Windows) or use sudo (Mac/Linux)
|
||||
- **Port already in use**: Kill process using the port or change the port in configuration
|
||||
- **Missing build tools**: Install required command-line tools
|
||||
|
||||
### Build Test Issues:
|
||||
- **Build fails**: Check console for specific error messages
|
||||
- **Test fails**: Verify minimal configuration is correct
|
||||
- **Path issues**: Ensure paths use correct separators for the platform
|
||||
|
||||
## 🔒 FINAL QA VALIDATION CHECKPOINT
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: QA VALIDATION
|
||||
- Dependency Verification Passed? [YES/NO]
|
||||
- Configuration Validation Passed? [YES/NO]
|
||||
- Environment Validation Passed? [YES/NO]
|
||||
- Minimal Build Test Passed? [YES/NO]
|
||||
|
||||
→ If all YES: Ready for BUILD mode
|
||||
→ If any NO: Fix identified issues before proceeding
|
||||
```
|
||||
+142
@@ -0,0 +1,142 @@
|
||||
---
|
||||
description: Visual process map for VAN mode complexity determination
|
||||
globs: van-complexity-determination.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN MODE: COMPLEXITY DETERMINATION
|
||||
|
||||
> **TL;DR:** This component determines the appropriate complexity level (1-4) for the current task and directs the workflow accordingly.
|
||||
|
||||
## 🔍 COMPLEXITY DECISION TREE
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["New Task"] --> Q1{"Bug fix or<br>error correction?"}
|
||||
Q1 -->|Yes| Q1a{"Affects single<br>component?"}
|
||||
Q1a -->|Yes| L1["Level 1:<br>Quick Bug Fix"]
|
||||
Q1a -->|No| Q1b{"Affects multiple<br>components?"}
|
||||
Q1b -->|Yes| L2["Level 2:<br>Simple Enhancement"]
|
||||
Q1b -->|No| Q1c{"Affects system<br>architecture?"}
|
||||
Q1c -->|Yes| L3["Level 3:<br>Intermediate Feature"]
|
||||
Q1c -->|No| L2
|
||||
|
||||
Q1 -->|No| Q2{"Adding small<br>feature or<br>enhancement?"}
|
||||
Q2 -->|Yes| Q2a{"Self-contained<br>change?"}
|
||||
Q2a -->|Yes| L2
|
||||
Q2a -->|No| Q2b{"Affects multiple<br>components?"}
|
||||
Q2b -->|Yes| L3
|
||||
Q2b -->|No| L2
|
||||
|
||||
Q2 -->|No| Q3{"Complete feature<br>requiring multiple<br>components?"}
|
||||
Q3 -->|Yes| Q3a{"Architectural<br>implications?"}
|
||||
Q3a -->|Yes| L4["Level 4:<br>Complex System"]
|
||||
Q3a -->|No| L3
|
||||
|
||||
Q3 -->|No| Q4{"System-wide or<br>architectural<br>change?"}
|
||||
Q4 -->|Yes| L4
|
||||
Q4 -->|No| L3
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style L1 fill:#10b981,stroke:#059669,color:white
|
||||
style L2 fill:#f6546a,stroke:#c30052,color:white
|
||||
style L3 fill:#f6546a,stroke:#c30052,color:white
|
||||
style L4 fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
## 📋 LEVEL INDICATORS
|
||||
|
||||
### Level 1: Quick Bug Fix
|
||||
- **Keywords**: fix, bug, error, crash, issue
|
||||
- **Scope**: Single component
|
||||
- **Time**: Minutes to hours
|
||||
- **Risk**: Low, isolated
|
||||
- **Example**: Button not working, styling issue
|
||||
|
||||
### Level 2: Simple Enhancement
|
||||
- **Keywords**: add, improve, update, enhance
|
||||
- **Scope**: Single component/subsystem
|
||||
- **Time**: Hours to 1-2 days
|
||||
- **Risk**: Moderate, contained
|
||||
- **Example**: Add form field, improve validation
|
||||
|
||||
### Level 3: Intermediate Feature
|
||||
- **Keywords**: implement, create, develop
|
||||
- **Scope**: Multiple components
|
||||
- **Time**: Days to 1-2 weeks
|
||||
- **Risk**: Significant
|
||||
- **Example**: User authentication, dashboard
|
||||
|
||||
### Level 4: Complex System
|
||||
- **Keywords**: system, architecture, redesign
|
||||
- **Scope**: Multiple subsystems
|
||||
- **Time**: Weeks to months
|
||||
- **Risk**: High, architectural
|
||||
- **Example**: Payment system, microservices
|
||||
|
||||
## 📋 COMPLEXITY CHECKLIST
|
||||
|
||||
```
|
||||
✓ COMPLEXITY DETERMINATION
|
||||
- Task type identified? [YES/NO]
|
||||
- Scope assessed? [YES/NO]
|
||||
- Time estimated? [YES/NO]
|
||||
- Risk evaluated? [YES/NO]
|
||||
- Dependencies mapped? [YES/NO]
|
||||
|
||||
→ If all YES: Proceed with level-specific workflow
|
||||
→ If any NO: Complete assessment
|
||||
```
|
||||
|
||||
## 🔄 LEVEL TRANSITION TRIGGERS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Current["Current Level"] --> Higher["Level Up Triggers"]
|
||||
Current --> Lower["Level Down Triggers"]
|
||||
|
||||
Higher --> H1["Multiple Components"]
|
||||
Higher --> H2["Design Decisions"]
|
||||
Higher --> H3["System Impact"]
|
||||
|
||||
Lower --> L1["Isolated Change"]
|
||||
Lower --> L2["Simple Fix"]
|
||||
Lower --> L3["No Design Needed"]
|
||||
|
||||
style Current fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style Higher fill:#f6546a,stroke:#c30052,color:white
|
||||
style Lower fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
## 📋 WORKFLOW LOADING
|
||||
|
||||
Based on determined level:
|
||||
- Level 1: Continue in VAN mode
|
||||
- Level 2-4: Transition to PLAN mode
|
||||
|
||||
**Next Step:** Load appropriate level-specific workflow
|
||||
|
||||
## 🚨 MODE TRANSITION TRIGGER (VAN to PLAN)
|
||||
|
||||
If complexity is determined to be Level 2, 3, or 4:
|
||||
|
||||
```
|
||||
🚫 LEVEL [2-4] TASK DETECTED
|
||||
Implementation in VAN mode is BLOCKED
|
||||
This task REQUIRES PLAN mode
|
||||
You MUST switch to PLAN mode for proper documentation and planning
|
||||
Type 'PLAN' to switch to planning mode
|
||||
```
|
||||
|
||||
## 📋 CHECKPOINT VERIFICATION TEMPLATE (Example)
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: COMPLEXITY DETERMINATION
|
||||
- Task Analyzed? [YES/NO]
|
||||
- Complexity Level Determined? [YES/NO]
|
||||
|
||||
→ If Level 1: Proceed to VAN Mode Completion.
|
||||
→ If Level 2-4: Trigger PLAN Mode transition.
|
||||
```
|
||||
|
||||
**Next Step (Level 1):** Complete VAN Initialization (e.g., initialize Memory Bank if needed).
|
||||
**Next Step (Level 2-4):** Exit VAN mode and initiate PLAN mode.
|
||||
@@ -0,0 +1,302 @@
|
||||
---
|
||||
description: Visual process map for VAN mode file verification
|
||||
globs: van-file-verification.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# OPTIMIZED FILE VERIFICATION SYSTEM
|
||||
|
||||
🚨 CRITICAL: MEMORY BANK VERIFICATION REQUIRED 🚨
|
||||
Memory Bank structure MUST exist before any file operations
|
||||
This check MUST be executed first in all verification processes
|
||||
|
||||
> **TL;DR:** This system provides a structured approach to verify file structure integrity before task implementation, with emphasis on efficient checks and clear status reporting.
|
||||
|
||||
## 🔍 FILE VERIFICATION WORKFLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
%% Critical Memory Bank verification - MUST be first
|
||||
Start["Start File Verification"] --> MemBankCheck{"Memory Bank<br>Exists?"}
|
||||
MemBankCheck -->|"No"| CreateMemBank["CREATE MEMORY BANK<br>[CRITICAL]"]
|
||||
MemBankCheck -->|"Yes"| VerifyMemBankComplete["Verify Memory Bank<br>Structure Complete"]
|
||||
CreateMemBank --> VerifyMemBankComplete
|
||||
|
||||
VerifyMemBankComplete --> PassCheck{"All Critical<br>Checks Pass?"}
|
||||
PassCheck -->|"No"| AbortAll["⛔ ABORT ALL OPERATIONS<br>Fix Memory Bank First"]
|
||||
PassCheck -->|"Yes"| MainVerification
|
||||
|
||||
%% Regular verification flow continues here
|
||||
MainVerification["Start Full<br>File Verification"] --> BatchVerify["Batch Verification<br>Using Patterns"]
|
||||
BatchVerify --> BrokenLinks["Check for<br>Broken References"]
|
||||
BrokenLinks --> DirectoryStructure["Verify Directory<br>Structure"]
|
||||
DirectoryStructure --> Status{"All Verifications<br>Successful?"}
|
||||
|
||||
Status -->|"Yes"| Complete["Verification<br>Complete ✓"]
|
||||
Status -->|"No"| Diagnose["Diagnose<br>Issues"]
|
||||
Diagnose --> Attempt{"Attempt Auto<br>Resolution?"}
|
||||
|
||||
Attempt -->|"Yes"| AutoFix["Auto-Fix<br>Issues"]
|
||||
Attempt -->|"No"| ReportIssue["Report Issues to<br>User"]
|
||||
|
||||
AutoFix --> Recheck{"Issues<br>Resolved?"}
|
||||
Recheck -->|"Yes"| ReportSuccess["Report Success<br>to User"]
|
||||
Recheck -->|"No"| ReportIssue
|
||||
|
||||
ReportSuccess --> Complete
|
||||
ReportIssue --> UserAction["Wait for<br>User Action"]
|
||||
UserAction --> ReVerify["Re-Verify<br>After User Action"]
|
||||
ReVerify --> Status
|
||||
|
||||
style MemBankCheck fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style CreateMemBank fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style VerifyMemBankComplete fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style PassCheck fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style AbortAll fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style Status fill:#f6546a,stroke:#c30052,color:white
|
||||
style Complete fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
## 🧩 MEMORY BANK VERIFICATION - CRITICAL COMPONENT
|
||||
|
||||
Memory Bank verification MUST be executed first in any file verification process:
|
||||
|
||||
```javascript
|
||||
function verifyMemoryBank() {
|
||||
// Check if Memory Bank exists
|
||||
const memoryBankExists = checkDirectoryExists("memory-bank");
|
||||
if (!memoryBankExists) {
|
||||
console.error("⛔ CRITICAL ERROR: Memory Bank does not exist");
|
||||
createMemoryBankStructure();
|
||||
return verifyMemoryBankCreation();
|
||||
}
|
||||
|
||||
// Check required subdirectories
|
||||
const requiredDirs = [
|
||||
"memory-bank/active-context",
|
||||
"memory-bank/system-patterns",
|
||||
"memory-bank/creative-phase",
|
||||
"memory-bank/implementation"
|
||||
];
|
||||
|
||||
const missingDirs = requiredDirs.filter(dir => !checkDirectoryExists(dir));
|
||||
if (missingDirs.length > 0) {
|
||||
console.error(`⛔ CRITICAL ERROR: Missing Memory Bank directories: ${missingDirs.join(", ")}`);
|
||||
createMissingDirectories(missingDirs);
|
||||
return verifyMemoryBankCreation();
|
||||
}
|
||||
|
||||
// Check critical files
|
||||
const criticalFiles = [
|
||||
"memory-bank/active-context/activeContext.md",
|
||||
"memory-bank/system-patterns/systemPatterns.md"
|
||||
];
|
||||
|
||||
const missingFiles = criticalFiles.filter(file => !checkFileExists(file));
|
||||
if (missingFiles.length > 0) {
|
||||
console.error(`⛔ CRITICAL ERROR: Missing critical files: ${missingFiles.join(", ")}`);
|
||||
createMissingFiles(missingFiles);
|
||||
return verifyMemoryBankCreation();
|
||||
}
|
||||
|
||||
return true; // Memory Bank verification successful
|
||||
}
|
||||
|
||||
// MANDATORY: This must be called before any other verification
|
||||
const memoryBankVerified = verifyMemoryBank();
|
||||
if (!memoryBankVerified) {
|
||||
throw new Error("⛔ MEMORY BANK VERIFICATION FAILED - CANNOT PROCEED");
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 MEMORY BANK VERIFICATION CHECKLIST
|
||||
|
||||
```
|
||||
✓ MEMORY BANK VERIFICATION CHECKLIST
|
||||
- Memory Bank directory exists? [YES/NO]
|
||||
- Required subdirectories exist? [YES/NO]
|
||||
- Critical files exist? [YES/NO]
|
||||
- File content is valid? [YES/NO]
|
||||
|
||||
→ If ALL YES: Memory Bank verification passed - Continue file verification
|
||||
→ If ANY NO: STOP ALL PROCESSING and FIX MEMORY BANK
|
||||
```
|
||||
|
||||
## 🔍 BATCH VERIFICATION WORKFLOW
|
||||
|
||||
## 📋 OPTIMIZED DIRECTORY CREATION
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Directory<br>Creation"] --> DetectOS["Detect Operating<br>System"]
|
||||
DetectOS -->|"Windows"| WinCmd["Batch Create<br>Windows Command"]
|
||||
DetectOS -->|"Mac/Linux"| UnixCmd["Batch Create<br>Unix Command"]
|
||||
WinCmd & UnixCmd --> Verify["Verify<br>Creation Success"]
|
||||
Verify --> Complete["Directory Setup<br>Complete"]
|
||||
```
|
||||
|
||||
### Platform-Specific Commands
|
||||
|
||||
#### Windows (PowerShell)
|
||||
```powershell
|
||||
# Create all directories in one command
|
||||
mkdir memory-bank, docs, docs\archive -ErrorAction SilentlyContinue
|
||||
|
||||
# Create all required files
|
||||
$files = @(".cursorrules", "tasks.md",
|
||||
"memory-bank\projectbrief.md",
|
||||
"memory-bank\productContext.md",
|
||||
"memory-bank\systemPatterns.md",
|
||||
"memory-bank\techContext.md",
|
||||
"memory-bank\activeContext.md",
|
||||
"memory-bank\progress.md")
|
||||
|
||||
foreach ($file in $files) {
|
||||
if (-not (Test-Path $file)) {
|
||||
New-Item -Path $file -ItemType File -Force
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Mac/Linux (Bash)
|
||||
```bash
|
||||
# Create all directories in one command
|
||||
mkdir -p memory-bank docs/archive
|
||||
|
||||
# Create all required files
|
||||
touch .cursorrules tasks.md \
|
||||
memory-bank/projectbrief.md \
|
||||
memory-bank/productContext.md \
|
||||
memory-bank/systemPatterns.md \
|
||||
memory-bank/techContext.md \
|
||||
memory-bank/activeContext.md \
|
||||
memory-bank/progress.md
|
||||
```
|
||||
|
||||
## 📝 STREAMLINED VERIFICATION PROCESS
|
||||
|
||||
Instead of checking each component separately, perform batch verification:
|
||||
|
||||
```powershell
|
||||
# Windows - PowerShell
|
||||
$requiredDirs = @("memory-bank", "docs", "docs\archive")
|
||||
$requiredFiles = @(".cursorrules", "tasks.md")
|
||||
$mbFiles = @("projectbrief.md", "productContext.md", "systemPatterns.md",
|
||||
"techContext.md", "activeContext.md", "progress.md")
|
||||
|
||||
$missingDirs = $requiredDirs | Where-Object { -not (Test-Path $_) -or -not (Test-Path $_ -PathType Container) }
|
||||
$missingFiles = $requiredFiles | Where-Object { -not (Test-Path $_) -or (Test-Path $_ -PathType Container) }
|
||||
$missingMBFiles = $mbFiles | ForEach-Object { "memory-bank\$_" } |
|
||||
Where-Object { -not (Test-Path $_) -or (Test-Path $_ -PathType Container) }
|
||||
|
||||
if ($missingDirs.Count -eq 0 -and $missingFiles.Count -eq 0 -and $missingMBFiles.Count -eq 0) {
|
||||
Write-Output "✓ All required components verified"
|
||||
} else {
|
||||
# Create all missing items at once
|
||||
if ($missingDirs.Count -gt 0) {
|
||||
$missingDirs | ForEach-Object { mkdir $_ -Force }
|
||||
}
|
||||
if ($missingFiles.Count -gt 0 -or $missingMBFiles.Count -gt 0) {
|
||||
$allMissingFiles = $missingFiles + $missingMBFiles
|
||||
$allMissingFiles | ForEach-Object { New-Item -Path $_ -ItemType File -Force }
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 📝 TEMPLATE INITIALIZATION
|
||||
|
||||
Optimize template creation with a single script:
|
||||
|
||||
```powershell
|
||||
# Windows - PowerShell
|
||||
$templates = @{
|
||||
"tasks.md" = @"
|
||||
# Memory Bank: Tasks
|
||||
|
||||
## Current Task
|
||||
[Task not yet defined]
|
||||
|
||||
## Status
|
||||
- [ ] Task definition
|
||||
- [ ] Implementation plan
|
||||
- [ ] Execution
|
||||
- [ ] Documentation
|
||||
|
||||
## Requirements
|
||||
[No requirements defined yet]
|
||||
"@
|
||||
|
||||
"memory-bank\activeContext.md" = @"
|
||||
# Memory Bank: Active Context
|
||||
|
||||
## Current Focus
|
||||
[No active focus defined]
|
||||
|
||||
## Status
|
||||
[No status defined]
|
||||
|
||||
## Latest Changes
|
||||
[No changes recorded]
|
||||
"@
|
||||
|
||||
# Add other templates here
|
||||
}
|
||||
|
||||
foreach ($file in $templates.Keys) {
|
||||
if (Test-Path $file) {
|
||||
Set-Content -Path $file -Value $templates[$file]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 🔍 PERFORMANCE OPTIMIZATION BEST PRACTICES
|
||||
|
||||
1. **Batch Operations**: Always use batch operations instead of individual commands
|
||||
```
|
||||
# GOOD: Create all directories at once
|
||||
mkdir memory-bank docs docs\archive
|
||||
|
||||
# BAD: Create directories one at a time
|
||||
mkdir memory-bank
|
||||
mkdir docs
|
||||
mkdir docs\archive
|
||||
```
|
||||
|
||||
2. **Pre-Check Optimization**: Check all requirements first, then create only what's missing
|
||||
```
|
||||
# First check what's missing
|
||||
$missingItems = ...
|
||||
|
||||
# Then create only what's missing
|
||||
if ($missingItems) { ... }
|
||||
```
|
||||
|
||||
3. **Error Handling**: Include error handling in all commands
|
||||
```
|
||||
mkdir memory-bank, docs, docs\archive -ErrorAction SilentlyContinue
|
||||
```
|
||||
|
||||
4. **Platform Adaptation**: Auto-detect platform and use appropriate commands
|
||||
```
|
||||
if ($IsWindows) {
|
||||
# Windows commands
|
||||
} else {
|
||||
# Unix commands
|
||||
}
|
||||
```
|
||||
|
||||
5. **One-Pass Verification**: Verify directory structure in a single pass
|
||||
```
|
||||
$requiredPaths = @("memory-bank", "docs", "docs\archive", ".cursorrules", "tasks.md")
|
||||
$missingPaths = $requiredPaths | Where-Object { -not (Test-Path $_) }
|
||||
```
|
||||
|
||||
## 📝 VERIFICATION REPORT FORMAT
|
||||
|
||||
```
|
||||
✅ VERIFICATION COMPLETE
|
||||
- Created directories: [list]
|
||||
- Created files: [list]
|
||||
- All components verified
|
||||
|
||||
Memory Bank system ready for use.
|
||||
```
|
||||
@@ -0,0 +1,914 @@
|
||||
---
|
||||
description: Visual process map for VAN mode (Index/Entry Point)
|
||||
globs: van-mode-map.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN MODE: INITIALIZATION PROCESS MAP
|
||||
|
||||
🚨 MANDATORY FIRST STEP: MEMORY BANK CREATION 🚨
|
||||
NO OPERATION CAN PROCEED WITHOUT MEMORY BANK STRUCTURE
|
||||
|
||||
> **TL;DR:** This visual map defines the VAN mode process for project initialization, task analysis, and technical validation. It guides users through platform detection, file verification, complexity determination, and technical validation to ensure proper setup before implementation.
|
||||
|
||||
## 🧭 VAN MODE PROCESS FLOW
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["START VAN MODE"] --> PlatformDetect["PLATFORM DETECTION"]
|
||||
PlatformDetect --> DetectOS["Detect Operating System"]
|
||||
DetectOS --> CheckPath["Check Path Separator Format"]
|
||||
CheckPath --> AdaptCmds["Adapt Commands if Needed"]
|
||||
AdaptCmds --> PlatformCP["⛔ PLATFORM CHECKPOINT"]
|
||||
|
||||
%% Add Critical Memory Bank Checkpoint
|
||||
PlatformCP --> MemoryBankCheck{"Memory Bank<br>Exists?"}
|
||||
MemoryBankCheck -->|"No"| CreateMemoryBank["CREATE MEMORY BANK<br>[CRITICAL STEP]"]
|
||||
MemoryBankCheck -->|"Yes"| BasicFileVerify["BASIC FILE VERIFICATION"]
|
||||
CreateMemoryBank --> MemoryBankCP["⛔ MEMORY BANK VERIFICATION [REQUIRED]"]
|
||||
MemoryBankCP --> BasicFileVerify
|
||||
|
||||
%% Basic File Verification with checkpoint
|
||||
BasicFileVerify --> BatchCheck["Batch Check Essential Components"]
|
||||
BatchCheck --> BatchCreate["Batch Create Essential Structure"]
|
||||
BatchCreate --> BasicFileCP["⛔ BASIC FILE CHECKPOINT"]
|
||||
|
||||
%% Early Complexity Determination
|
||||
BasicFileCP --> EarlyComplexity["EARLY COMPLEXITY DETERMINATION"]
|
||||
EarlyComplexity --> AnalyzeTask["Analyze Task Requirements"]
|
||||
AnalyzeTask --> EarlyLevelCheck{"Complexity Level?"}
|
||||
|
||||
%% Level handling paths
|
||||
EarlyLevelCheck -->|"Level 1"| ComplexityCP["⛔ COMPLEXITY CHECKPOINT"]
|
||||
EarlyLevelCheck -->|"Level 2-4"| CRITICALGATE["🚫 CRITICAL GATE: FORCE MODE SWITCH"]
|
||||
CRITICALGATE --> ForceExit["Exit to PLAN mode"]
|
||||
|
||||
%% Level 1 continues normally
|
||||
ComplexityCP --> InitSystem["INITIALIZE MEMORY BANK"]
|
||||
InitSystem --> Complete1["LEVEL 1 INITIALIZATION COMPLETE"]
|
||||
|
||||
%% For Level 2+ tasks after PLAN and CREATIVE modes
|
||||
ForceExit -.-> OtherModes["PLAN → CREATIVE modes"]
|
||||
OtherModes -.-> VANQA["VAN QA MODE"]
|
||||
VANQA --> QAProcess["Technical Validation Process"]
|
||||
QAProcess --> QACheck{"All Checks Pass?"}
|
||||
QACheck -->|"Yes"| BUILD["To BUILD MODE"]
|
||||
QACheck -->|"No"| FixIssues["Fix Technical Issues"]
|
||||
FixIssues --> QAProcess
|
||||
|
||||
%% Style nodes
|
||||
style PlatformCP fill:#f55,stroke:#d44,color:white
|
||||
style MemoryBankCP fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style MemoryBankCheck fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style CreateMemoryBank fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style BasicFileCP fill:#f55,stroke:#d44,color:white
|
||||
style ComplexityCP fill:#f55,stroke:#d44,color:white
|
||||
style CRITICALGATE fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style ForceExit fill:#ff0000,stroke:#990000,color:white,stroke-width:2px
|
||||
style VANQA fill:#4da6ff,stroke:#0066cc,color:white,stroke-width:3px
|
||||
style QAProcess fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style QACheck fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FixIssues fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 🌐 PLATFORM DETECTION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
PD["Platform Detection"] --> CheckOS["Detect Operating System"]
|
||||
CheckOS --> Win["Windows"]
|
||||
CheckOS --> Mac["macOS"]
|
||||
CheckOS --> Lin["Linux"]
|
||||
|
||||
Win & Mac & Lin --> Adapt["Adapt Commands<br>for Platform"]
|
||||
|
||||
Win --> WinPath["Path: Backslash (\\)"]
|
||||
Mac --> MacPath["Path: Forward Slash (/)"]
|
||||
Lin --> LinPath["Path: Forward Slash (/)"]
|
||||
|
||||
Win --> WinCmd["Command Adaptations:<br>dir, icacls, etc."]
|
||||
Mac --> MacCmd["Command Adaptations:<br>ls, chmod, etc."]
|
||||
Lin --> LinCmd["Command Adaptations:<br>ls, chmod, etc."]
|
||||
|
||||
WinPath & MacPath & LinPath --> PathCP["Path Separator<br>Checkpoint"]
|
||||
WinCmd & MacCmd & LinCmd --> CmdCP["Command<br>Checkpoint"]
|
||||
|
||||
PathCP & CmdCP --> PlatformComplete["Platform Detection<br>Complete"]
|
||||
|
||||
style PD fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style PlatformComplete fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
## 📁 FILE VERIFICATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
FV["File Verification"] --> CheckFiles["Check Essential Files"]
|
||||
CheckFiles --> CheckMB["Check Memory Bank<br>Structure"]
|
||||
CheckMB --> MBExists{"Memory Bank<br>Exists?"}
|
||||
|
||||
MBExists -->|"Yes"| VerifyMB["Verify Memory Bank<br>Contents"]
|
||||
MBExists -->|"No"| CreateMB["Create Memory Bank<br>Structure"]
|
||||
|
||||
CheckFiles --> CheckDocs["Check Documentation<br>Files"]
|
||||
CheckDocs --> DocsExist{"Docs<br>Exist?"}
|
||||
|
||||
DocsExist -->|"Yes"| VerifyDocs["Verify Documentation<br>Structure"]
|
||||
DocsExist -->|"No"| CreateDocs["Create Documentation<br>Structure"]
|
||||
|
||||
VerifyMB & CreateMB --> MBCP["Memory Bank<br>Checkpoint"]
|
||||
VerifyDocs & CreateDocs --> DocsCP["Documentation<br>Checkpoint"]
|
||||
|
||||
MBCP & DocsCP --> FileComplete["File Verification<br>Complete"]
|
||||
|
||||
style FV fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FileComplete fill:#10b981,stroke:#059669,color:white
|
||||
style MBCP fill:#f6546a,stroke:#c30052,color:white
|
||||
style DocsCP fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
## 🧩 COMPLEXITY DETERMINATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
CD["Complexity<br>Determination"] --> AnalyzeTask["Analyze Task<br>Requirements"]
|
||||
|
||||
AnalyzeTask --> CheckKeywords["Check Task<br>Keywords"]
|
||||
CheckKeywords --> ScopeCheck["Assess<br>Scope Impact"]
|
||||
ScopeCheck --> RiskCheck["Evaluate<br>Risk Level"]
|
||||
RiskCheck --> EffortCheck["Estimate<br>Implementation Effort"]
|
||||
|
||||
EffortCheck --> DetermineLevel{"Determine<br>Complexity Level"}
|
||||
DetermineLevel -->|"Level 1"| L1["Level 1:<br>Quick Bug Fix"]
|
||||
DetermineLevel -->|"Level 2"| L2["Level 2:<br>Simple Enhancement"]
|
||||
DetermineLevel -->|"Level 3"| L3["Level 3:<br>Intermediate Feature"]
|
||||
DetermineLevel -->|"Level 4"| L4["Level 4:<br>Complex System"]
|
||||
|
||||
L1 --> CDComplete["Complexity Determination<br>Complete"]
|
||||
L2 & L3 & L4 --> ModeSwitch["Force Mode Switch<br>to PLAN"]
|
||||
|
||||
style CD fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style CDComplete fill:#10b981,stroke:#059669,color:white
|
||||
style ModeSwitch fill:#ff0000,stroke:#990000,color:white
|
||||
style DetermineLevel fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
## 🔄 COMPLETE WORKFLOW WITH QA VALIDATION
|
||||
|
||||
The full workflow includes technical validation before implementation:
|
||||
|
||||
```mermaid
|
||||
flowchart LR
|
||||
VAN1["VAN MODE
|
||||
(Initial Analysis)"] --> PLAN["PLAN MODE
|
||||
(Task Planning)"]
|
||||
PLAN --> CREATIVE["CREATIVE MODE
|
||||
(Design Decisions)"]
|
||||
CREATIVE --> VANQA["VAN QA MODE
|
||||
(Technical Validation)"]
|
||||
VANQA --> BUILD["BUILD MODE
|
||||
(Implementation)"]
|
||||
```
|
||||
|
||||
## 🔍 TECHNICAL VALIDATION OVERVIEW
|
||||
|
||||
The VAN QA technical validation process consists of four key validation points:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
VANQA["VAN QA MODE"] --> FourChecks["FOUR-POINT VALIDATION"]
|
||||
|
||||
FourChecks --> DepCheck["1️⃣ DEPENDENCY VERIFICATION<br>Check all required packages"]
|
||||
DepCheck --> ConfigCheck["2️⃣ CONFIGURATION VALIDATION<br>Verify format & compatibility"]
|
||||
ConfigCheck --> EnvCheck["3️⃣ ENVIRONMENT VALIDATION<br>Check build environment"]
|
||||
EnvCheck --> MinBuildCheck["4️⃣ MINIMAL BUILD TEST<br>Test core functionality"]
|
||||
|
||||
MinBuildCheck --> ValidationResults{"All Checks<br>Passed?"}
|
||||
ValidationResults -->|"Yes"| SuccessReport["GENERATE SUCCESS REPORT"]
|
||||
ValidationResults -->|"No"| FailureReport["GENERATE FAILURE REPORT"]
|
||||
|
||||
SuccessReport --> BUILD["Proceed to BUILD MODE"]
|
||||
FailureReport --> FixIssues["Fix Technical Issues"]
|
||||
FixIssues --> ReValidate["Re-validate"]
|
||||
ReValidate --> ValidationResults
|
||||
|
||||
style VANQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FourChecks fill:#f6546a,stroke:#c30052,color:white
|
||||
style ValidationResults fill:#f6546a,stroke:#c30052,color:white
|
||||
style BUILD fill:#10b981,stroke:#059669,color:white
|
||||
style FixIssues fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 📝 VALIDATION STATUS FORMAT
|
||||
|
||||
The QA Validation step includes clear status indicators:
|
||||
|
||||
```
|
||||
╔═════════════════ 🔍 QA VALIDATION STATUS ═════════════════╗
|
||||
│ ✓ Design Decisions │ Verified as implementable │
|
||||
│ ✓ Dependencies │ All required packages installed │
|
||||
│ ✓ Configurations │ Format verified for platform │
|
||||
│ ✓ Environment │ Suitable for implementation │
|
||||
╚════════════════════════════════════════════════════════════╝
|
||||
✅ VERIFIED - Clear to proceed to BUILD mode
|
||||
```
|
||||
|
||||
## 🚨 MODE TRANSITION TRIGGERS
|
||||
|
||||
### VAN to PLAN Transition
|
||||
For complexity levels 2-4:
|
||||
```
|
||||
🚫 LEVEL [2-4] TASK DETECTED
|
||||
Implementation in VAN mode is BLOCKED
|
||||
This task REQUIRES PLAN mode
|
||||
You MUST switch to PLAN mode for proper documentation and planning
|
||||
Type 'PLAN' to switch to planning mode
|
||||
```
|
||||
|
||||
### CREATIVE to VAN QA Transition
|
||||
After completing the CREATIVE mode:
|
||||
```
|
||||
⏭️ NEXT MODE: VAN QA
|
||||
To validate technical requirements before implementation, please type 'VAN QA'
|
||||
```
|
||||
|
||||
### VAN QA to BUILD Transition
|
||||
After successful validation:
|
||||
```
|
||||
✅ TECHNICAL VALIDATION COMPLETE
|
||||
All prerequisites verified successfully
|
||||
You may now proceed to BUILD mode
|
||||
Type 'BUILD' to begin implementation
|
||||
```
|
||||
|
||||
## 🔒 BUILD MODE PREVENTION MECHANISM
|
||||
|
||||
The system prevents moving to BUILD mode without passing QA validation:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["User Types: BUILD"] --> CheckQA{"QA Validation<br>Completed?"}
|
||||
CheckQA -->|"Yes and Passed"| AllowBuild["Allow BUILD Mode"]
|
||||
CheckQA -->|"No or Failed"| BlockBuild["BLOCK BUILD MODE"]
|
||||
BlockBuild --> Message["Display:<br>⚠️ QA VALIDATION REQUIRED"]
|
||||
Message --> ReturnToVANQA["Prompt: Type VAN QA"]
|
||||
|
||||
style CheckQA fill:#f6546a,stroke:#c30052,color:white
|
||||
style BlockBuild fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style Message fill:#ff5555,stroke:#dd3333,color:white
|
||||
style ReturnToVANQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
```
|
||||
|
||||
## 🔄 QA COMMAND PRECEDENCE
|
||||
|
||||
QA validation can be called at any point in the process flow, and takes immediate precedence over any other current steps, including forced mode switches:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
UserQA["User Types: QA"] --> HighPriority["⚠️ HIGH PRIORITY COMMAND"]
|
||||
HighPriority --> CurrentTask["Pause Current Task/Process"]
|
||||
CurrentTask --> LoadQA["Load QA Mode Map"]
|
||||
LoadQA --> RunQA["Execute QA Validation Process"]
|
||||
RunQA --> QAResults{"QA Results"}
|
||||
|
||||
QAResults -->|"PASS"| ResumeFlow["Resume Prior Process Flow"]
|
||||
QAResults -->|"FAIL"| FixIssues["Fix Identified Issues"]
|
||||
FixIssues --> ReRunQA["Re-run QA Validation"]
|
||||
ReRunQA --> QAResults
|
||||
|
||||
style UserQA fill:#f8d486,stroke:#e8b84d,color:black
|
||||
style HighPriority fill:#ff0000,stroke:#cc0000,color:white,stroke-width:3px
|
||||
style LoadQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style RunQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style QAResults fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### QA Interruption Rules
|
||||
|
||||
When a user types **QA** at any point:
|
||||
|
||||
1. **The QA command MUST take immediate precedence** over any current operation, including the "FORCE MODE SWITCH" triggered by complexity assessment.
|
||||
2. The system MUST:
|
||||
- Immediately load the QA mode map
|
||||
- Execute the full QA validation process
|
||||
- Address any failures before continuing
|
||||
3. **Required remediation steps take priority** over any pending mode switches or complexity rules
|
||||
4. After QA validation is complete and passes:
|
||||
- Resume the previously determined process flow
|
||||
- Continue with any required mode switches
|
||||
|
||||
```
|
||||
⚠️ QA OVERRIDE ACTIVATED
|
||||
All other processes paused
|
||||
QA validation checks now running...
|
||||
Any issues found MUST be remediated before continuing with normal process flow
|
||||
```
|
||||
|
||||
## 📋 CHECKPOINT VERIFICATION TEMPLATE
|
||||
|
||||
Each major checkpoint in VAN mode uses this format:
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: [SECTION NAME]
|
||||
- Requirement 1? [YES/NO]
|
||||
- Requirement 2? [YES/NO]
|
||||
- Requirement 3? [YES/NO]
|
||||
|
||||
→ If all YES: Ready for next section
|
||||
→ If any NO: Fix missing items before proceeding
|
||||
```
|
||||
|
||||
## 🚀 VAN MODE ACTIVATION
|
||||
|
||||
When the user types "VAN", respond with a confirmation and start the process:
|
||||
|
||||
```
|
||||
User: VAN
|
||||
|
||||
Response: OK VAN - Beginning Initialization Process
|
||||
```
|
||||
|
||||
After completing CREATIVE mode, when the user types "VAN QA", respond:
|
||||
|
||||
```
|
||||
User: VAN QA
|
||||
|
||||
Response: OK VAN QA - Beginning Technical Validation
|
||||
```
|
||||
|
||||
This ensures clear communication about which phase of VAN mode is active.
|
||||
|
||||
## 🔍 DETAILED QA VALIDATION PROCESS
|
||||
|
||||
### 1️⃣ DEPENDENCY VERIFICATION
|
||||
|
||||
This step verifies that all required packages are installed and compatible:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Dependency Verification"] --> ReadDeps["Read Required Dependencies<br>from Creative Phase"]
|
||||
ReadDeps --> CheckInstalled["Check if Dependencies<br>are Installed"]
|
||||
CheckInstalled --> DepStatus{"All Dependencies<br>Installed?"}
|
||||
|
||||
DepStatus -->|"Yes"| VerifyVersions["Verify Versions<br>and Compatibility"]
|
||||
DepStatus -->|"No"| InstallMissing["Install Missing<br>Dependencies"]
|
||||
InstallMissing --> VerifyVersions
|
||||
|
||||
VerifyVersions --> VersionStatus{"Versions<br>Compatible?"}
|
||||
VersionStatus -->|"Yes"| DepSuccess["Dependencies Verified<br>✅ PASS"]
|
||||
VersionStatus -->|"No"| UpgradeVersions["Upgrade/Downgrade<br>as Needed"]
|
||||
UpgradeVersions --> RetryVerify["Retry Verification"]
|
||||
RetryVerify --> VersionStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style DepSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style DepStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style VersionStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Windows (PowerShell) Implementation:
|
||||
```powershell
|
||||
# Example: Verify Node.js dependencies for a React project
|
||||
function Verify-Dependencies {
|
||||
$requiredDeps = @{
|
||||
"node" = ">=14.0.0"
|
||||
"npm" = ">=6.0.0"
|
||||
}
|
||||
|
||||
$missingDeps = @()
|
||||
$incompatibleDeps = @()
|
||||
|
||||
# Check Node.js version
|
||||
$nodeVersion = $null
|
||||
try {
|
||||
$nodeVersion = node -v
|
||||
if ($nodeVersion -match "v(\d+)\.(\d+)\.(\d+)") {
|
||||
$major = [int]$Matches[1]
|
||||
if ($major -lt 14) {
|
||||
$incompatibleDeps += "node (found $nodeVersion, required >=14.0.0)"
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
$missingDeps += "node"
|
||||
}
|
||||
|
||||
# Check npm version
|
||||
$npmVersion = $null
|
||||
try {
|
||||
$npmVersion = npm -v
|
||||
if ($npmVersion -match "(\d+)\.(\d+)\.(\d+)") {
|
||||
$major = [int]$Matches[1]
|
||||
if ($major -lt 6) {
|
||||
$incompatibleDeps += "npm (found $npmVersion, required >=6.0.0)"
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
$missingDeps += "npm"
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($missingDeps.Count -eq 0 -and $incompatibleDeps.Count -eq 0) {
|
||||
Write-Output "✅ All dependencies verified and compatible"
|
||||
return $true
|
||||
} else {
|
||||
if ($missingDeps.Count -gt 0) {
|
||||
Write-Output "❌ Missing dependencies: $($missingDeps -join ', ')"
|
||||
}
|
||||
if ($incompatibleDeps.Count -gt 0) {
|
||||
Write-Output "❌ Incompatible versions: $($incompatibleDeps -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Mac/Linux (Bash) Implementation:
|
||||
```bash
|
||||
#!/bin/bash
|
||||
|
||||
# Example: Verify Node.js dependencies for a React project
|
||||
verify_dependencies() {
|
||||
local missing_deps=()
|
||||
local incompatible_deps=()
|
||||
|
||||
# Check Node.js version
|
||||
if command -v node &> /dev/null; then
|
||||
local node_version=$(node -v)
|
||||
if [[ $node_version =~ v([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
|
||||
local major=${BASH_REMATCH[1]}
|
||||
if (( major < 14 )); then
|
||||
incompatible_deps+=("node (found $node_version, required >=14.0.0)")
|
||||
fi
|
||||
fi
|
||||
else
|
||||
missing_deps+=("node")
|
||||
fi
|
||||
|
||||
# Check npm version
|
||||
if command -v npm &> /dev/null; then
|
||||
local npm_version=$(npm -v)
|
||||
if [[ $npm_version =~ ([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
|
||||
local major=${BASH_REMATCH[1]}
|
||||
if (( major < 6 )); then
|
||||
incompatible_deps+=("npm (found $npm_version, required >=6.0.0)")
|
||||
fi
|
||||
fi
|
||||
else
|
||||
missing_deps+=("npm")
|
||||
fi
|
||||
|
||||
# Display results
|
||||
if [ ${#missing_deps[@]} -eq 0 ] && [ ${#incompatible_deps[@]} -eq 0 ]; then
|
||||
echo "✅ All dependencies verified and compatible"
|
||||
return 0
|
||||
else
|
||||
if [ ${#missing_deps[@]} -gt 0 ]; then
|
||||
echo "❌ Missing dependencies: ${missing_deps[*]}"
|
||||
fi
|
||||
if [ ${#incompatible_deps[@]} -gt 0 ]; then
|
||||
echo "❌ Incompatible versions: ${incompatible_deps[*]}"
|
||||
fi
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
```
|
||||
|
||||
### 2️⃣ CONFIGURATION VALIDATION
|
||||
|
||||
This step validates configuration files format and compatibility:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Configuration Validation"] --> IdentifyConfigs["Identify Configuration<br>Files"]
|
||||
IdentifyConfigs --> ReadConfigs["Read Configuration<br>Files"]
|
||||
ReadConfigs --> ValidateSyntax["Validate Syntax<br>and Format"]
|
||||
ValidateSyntax --> SyntaxStatus{"Syntax<br>Valid?"}
|
||||
|
||||
SyntaxStatus -->|"Yes"| CheckCompatibility["Check Compatibility<br>with Platform"]
|
||||
SyntaxStatus -->|"No"| FixSyntax["Fix Syntax<br>Errors"]
|
||||
FixSyntax --> RetryValidate["Retry Validation"]
|
||||
RetryValidate --> SyntaxStatus
|
||||
|
||||
CheckCompatibility --> CompatStatus{"Compatible with<br>Platform?"}
|
||||
CompatStatus -->|"Yes"| ConfigSuccess["Configurations Validated<br>✅ PASS"]
|
||||
CompatStatus -->|"No"| AdaptConfigs["Adapt Configurations<br>for Platform"]
|
||||
AdaptConfigs --> RetryCompat["Retry Compatibility<br>Check"]
|
||||
RetryCompat --> CompatStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ConfigSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style SyntaxStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style CompatStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Configuration Validation Implementation:
|
||||
```powershell
|
||||
# Example: Validate configuration files for a web project
|
||||
function Validate-Configurations {
|
||||
$configFiles = @(
|
||||
"package.json",
|
||||
"tsconfig.json",
|
||||
"vite.config.js"
|
||||
)
|
||||
|
||||
$invalidConfigs = @()
|
||||
$incompatibleConfigs = @()
|
||||
|
||||
foreach ($configFile in $configFiles) {
|
||||
if (Test-Path $configFile) {
|
||||
# Check JSON syntax for JSON files
|
||||
if ($configFile -match "\.json$") {
|
||||
try {
|
||||
Get-Content $configFile -Raw | ConvertFrom-Json | Out-Null
|
||||
} catch {
|
||||
$invalidConfigs += "$configFile (JSON syntax error: $($_.Exception.Message))"
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
# Specific configuration compatibility checks
|
||||
if ($configFile -eq "vite.config.js") {
|
||||
$content = Get-Content $configFile -Raw
|
||||
# Check for React plugin in Vite config
|
||||
if ($content -notmatch "react\(\)") {
|
||||
$incompatibleConfigs += "$configFile (Missing React plugin for React project)"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$invalidConfigs += "$configFile (file not found)"
|
||||
}
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($invalidConfigs.Count -eq 0 -and $incompatibleConfigs.Count -eq 0) {
|
||||
Write-Output "✅ All configurations validated and compatible"
|
||||
return $true
|
||||
} else {
|
||||
if ($invalidConfigs.Count -gt 0) {
|
||||
Write-Output "❌ Invalid configurations: $($invalidConfigs -join ', ')"
|
||||
}
|
||||
if ($incompatibleConfigs.Count -gt 0) {
|
||||
Write-Output "❌ Incompatible configurations: $($incompatibleConfigs -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 3️⃣ ENVIRONMENT VALIDATION
|
||||
|
||||
This step checks if the environment is properly set up for the implementation:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Environment Validation"] --> CheckEnv["Check Build Environment"]
|
||||
CheckEnv --> VerifyBuildTools["Verify Build Tools"]
|
||||
VerifyBuildTools --> ToolsStatus{"Build Tools<br>Available?"}
|
||||
|
||||
ToolsStatus -->|"Yes"| CheckPerms["Check Permissions<br>and Access"]
|
||||
ToolsStatus -->|"No"| InstallTools["Install Required<br>Build Tools"]
|
||||
InstallTools --> RetryTools["Retry Verification"]
|
||||
RetryTools --> ToolsStatus
|
||||
|
||||
CheckPerms --> PermsStatus{"Permissions<br>Sufficient?"}
|
||||
PermsStatus -->|"Yes"| EnvSuccess["Environment Validated<br>✅ PASS"]
|
||||
PermsStatus -->|"No"| FixPerms["Fix Permission<br>Issues"]
|
||||
FixPerms --> RetryPerms["Retry Permission<br>Check"]
|
||||
RetryPerms --> PermsStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style EnvSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style ToolsStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style PermsStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Environment Validation Implementation:
|
||||
```powershell
|
||||
# Example: Validate environment for a web project
|
||||
function Validate-Environment {
|
||||
$requiredTools = @(
|
||||
@{Name = "git"; Command = "git --version"},
|
||||
@{Name = "node"; Command = "node --version"},
|
||||
@{Name = "npm"; Command = "npm --version"}
|
||||
)
|
||||
|
||||
$missingTools = @()
|
||||
$permissionIssues = @()
|
||||
|
||||
# Check build tools
|
||||
foreach ($tool in $requiredTools) {
|
||||
try {
|
||||
Invoke-Expression $tool.Command | Out-Null
|
||||
} catch {
|
||||
$missingTools += $tool.Name
|
||||
}
|
||||
}
|
||||
|
||||
# Check write permissions in project directory
|
||||
try {
|
||||
$testFile = ".__permission_test"
|
||||
New-Item -Path $testFile -ItemType File -Force | Out-Null
|
||||
Remove-Item -Path $testFile -Force
|
||||
} catch {
|
||||
$permissionIssues += "Current directory (write permission denied)"
|
||||
}
|
||||
|
||||
# Check if port 3000 is available (commonly used for dev servers)
|
||||
try {
|
||||
$listener = New-Object System.Net.Sockets.TcpListener([System.Net.IPAddress]::Loopback, 3000)
|
||||
$listener.Start()
|
||||
$listener.Stop()
|
||||
} catch {
|
||||
$permissionIssues += "Port 3000 (already in use or access denied)"
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($missingTools.Count -eq 0 -and $permissionIssues.Count -eq 0) {
|
||||
Write-Output "✅ Environment validated successfully"
|
||||
return $true
|
||||
} else {
|
||||
if ($missingTools.Count -gt 0) {
|
||||
Write-Output "❌ Missing tools: $($missingTools -join ', ')"
|
||||
}
|
||||
if ($permissionIssues.Count -gt 0) {
|
||||
Write-Output "❌ Permission issues: $($permissionIssues -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 4️⃣ MINIMAL BUILD TEST
|
||||
|
||||
This step performs a minimal build test to ensure core functionality:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Minimal Build Test"] --> CreateTest["Create Minimal<br>Test Project"]
|
||||
CreateTest --> BuildTest["Attempt<br>Build"]
|
||||
BuildTest --> BuildStatus{"Build<br>Successful?"}
|
||||
|
||||
BuildStatus -->|"Yes"| RunTest["Run Basic<br>Functionality Test"]
|
||||
BuildStatus -->|"No"| FixBuild["Fix Build<br>Issues"]
|
||||
FixBuild --> RetryBuild["Retry Build"]
|
||||
RetryBuild --> BuildStatus
|
||||
|
||||
RunTest --> TestStatus{"Test<br>Passed?"}
|
||||
TestStatus -->|"Yes"| TestSuccess["Minimal Build Test<br>✅ PASS"]
|
||||
TestStatus -->|"No"| FixTest["Fix Test<br>Issues"]
|
||||
FixTest --> RetryTest["Retry Test"]
|
||||
RetryTest --> TestStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TestSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style BuildStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style TestStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
#### Minimal Build Test Implementation:
|
||||
```powershell
|
||||
# Example: Perform minimal build test for a React project
|
||||
function Perform-MinimalBuildTest {
|
||||
$buildSuccess = $false
|
||||
$testSuccess = $false
|
||||
|
||||
# Create minimal test project
|
||||
$testDir = ".__build_test"
|
||||
if (Test-Path $testDir) {
|
||||
Remove-Item -Path $testDir -Recurse -Force
|
||||
}
|
||||
|
||||
try {
|
||||
# Create minimal test directory
|
||||
New-Item -Path $testDir -ItemType Directory | Out-Null
|
||||
Push-Location $testDir
|
||||
|
||||
# Initialize minimal package.json
|
||||
@"
|
||||
{
|
||||
"name": "build-test",
|
||||
"version": "1.0.0",
|
||||
"description": "Minimal build test",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"build": "echo Build test successful"
|
||||
}
|
||||
}
|
||||
"@ | Set-Content -Path "package.json"
|
||||
|
||||
# Attempt build
|
||||
npm run build | Out-Null
|
||||
$buildSuccess = $true
|
||||
|
||||
# Create minimal test file
|
||||
@"
|
||||
console.log('Test successful');
|
||||
"@ | Set-Content -Path "index.js"
|
||||
|
||||
# Run basic test
|
||||
node index.js | Out-Null
|
||||
$testSuccess = $true
|
||||
|
||||
} catch {
|
||||
Write-Output "❌ Build test failed: $($_.Exception.Message)"
|
||||
} finally {
|
||||
Pop-Location
|
||||
if (Test-Path $testDir) {
|
||||
Remove-Item -Path $testDir -Recurse -Force
|
||||
}
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($buildSuccess -and $testSuccess) {
|
||||
Write-Output "✅ Minimal build test passed successfully"
|
||||
return $true
|
||||
} else {
|
||||
if (-not $buildSuccess) {
|
||||
Write-Output "❌ Build process failed"
|
||||
}
|
||||
if (-not $testSuccess) {
|
||||
Write-Output "❌ Basic functionality test failed"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 COMPREHENSIVE QA REPORT FORMAT
|
||||
|
||||
After running all validation steps, a comprehensive report is generated:
|
||||
|
||||
```
|
||||
╔═════════════════════ 🔍 QA VALIDATION REPORT ══════════════════════╗
|
||||
│ │
|
||||
│ PROJECT: [Project Name] │
|
||||
│ TIMESTAMP: [Current Date/Time] │
|
||||
│ │
|
||||
│ 1️⃣ DEPENDENCY VERIFICATION │
|
||||
│ ✓ Required: [List of required dependencies] │
|
||||
│ ✓ Installed: [List of installed dependencies] │
|
||||
│ ✓ Compatible: [Yes/No] │
|
||||
│ │
|
||||
│ 2️⃣ CONFIGURATION VALIDATION │
|
||||
│ ✓ Config Files: [List of configuration files] │
|
||||
│ ✓ Syntax Valid: [Yes/No] │
|
||||
│ ✓ Platform Compatible: [Yes/No] │
|
||||
│ │
|
||||
│ 3️⃣ ENVIRONMENT VALIDATION │
|
||||
│ ✓ Build Tools: [Available/Missing] │
|
||||
│ ✓ Permissions: [Sufficient/Insufficient] │
|
||||
│ ✓ Environment Ready: [Yes/No] │
|
||||
│ │
|
||||
│ 4️⃣ MINIMAL BUILD TEST │
|
||||
│ ✓ Build Process: [Successful/Failed] │
|
||||
│ ✓ Functionality Test: [Passed/Failed] │
|
||||
│ ✓ Build Ready: [Yes/No] │
|
||||
│ │
|
||||
│ 🚨 FINAL VERDICT: [PASS/FAIL] │
|
||||
│ ➡️ [Success message or error details] │
|
||||
╚═════════════════════════════════════════════════════════════════════╝
|
||||
```
|
||||
|
||||
## ❌ FAILURE REPORT FORMAT
|
||||
|
||||
If any validation step fails, a detailed failure report is generated:
|
||||
|
||||
```
|
||||
⚠️⚠️⚠️ QA VALIDATION FAILED ⚠️⚠️⚠️
|
||||
|
||||
The following issues must be resolved before proceeding to BUILD mode:
|
||||
|
||||
1️⃣ DEPENDENCY ISSUES:
|
||||
- [Detailed description of dependency issues]
|
||||
- [Recommended fix]
|
||||
|
||||
2️⃣ CONFIGURATION ISSUES:
|
||||
- [Detailed description of configuration issues]
|
||||
- [Recommended fix]
|
||||
|
||||
3️⃣ ENVIRONMENT ISSUES:
|
||||
- [Detailed description of environment issues]
|
||||
- [Recommended fix]
|
||||
|
||||
4️⃣ BUILD TEST ISSUES:
|
||||
- [Detailed description of build test issues]
|
||||
- [Recommended fix]
|
||||
|
||||
⚠️ BUILD MODE IS BLOCKED until these issues are resolved.
|
||||
Type 'VAN QA' after fixing the issues to re-validate.
|
||||
```
|
||||
|
||||
## 🔄 INTEGRATION WITH DESIGN DECISIONS
|
||||
|
||||
The VAN QA mode reads and validates design decisions from the CREATIVE phase:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Read Design Decisions"] --> ReadCreative["Parse Creative Phase<br>Documentation"]
|
||||
ReadCreative --> ExtractTech["Extract Technology<br>Choices"]
|
||||
ExtractTech --> ExtractDeps["Extract Required<br>Dependencies"]
|
||||
ExtractDeps --> BuildValidationPlan["Build Validation<br>Plan"]
|
||||
BuildValidationPlan --> StartValidation["Start Four-Point<br>Validation Process"]
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ExtractTech fill:#f6546a,stroke:#c30052,color:white
|
||||
style BuildValidationPlan fill:#10b981,stroke:#059669,color:white
|
||||
style StartValidation fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### Technology Extraction Process:
|
||||
```powershell
|
||||
# Example: Extract technology choices from creative phase documentation
|
||||
function Extract-TechnologyChoices {
|
||||
$techChoices = @{}
|
||||
|
||||
# Read from systemPatterns.md
|
||||
if (Test-Path "memory-bank\systemPatterns.md") {
|
||||
$content = Get-Content "memory-bank\systemPatterns.md" -Raw
|
||||
|
||||
# Extract framework choice
|
||||
if ($content -match "Framework:\s*(\w+)") {
|
||||
$techChoices["framework"] = $Matches[1]
|
||||
}
|
||||
|
||||
# Extract UI library choice
|
||||
if ($content -match "UI Library:\s*(\w+)") {
|
||||
$techChoices["ui_library"] = $Matches[1]
|
||||
}
|
||||
|
||||
# Extract state management choice
|
||||
if ($content -match "State Management:\s*([^\\n]+)") {
|
||||
$techChoices["state_management"] = $Matches[1].Trim()
|
||||
}
|
||||
}
|
||||
|
||||
return $techChoices
|
||||
}
|
||||
```
|
||||
|
||||
## 🚨 IMPLEMENTATION PREVENTION MECHANISM
|
||||
|
||||
If QA validation fails, the system prevents moving to BUILD mode:
|
||||
|
||||
```powershell
|
||||
# Example: Enforce QA validation before allowing BUILD mode
|
||||
function Check-QAValidationStatus {
|
||||
$qaStatusFile = "memory-bank\.qa_validation_status"
|
||||
|
||||
if (Test-Path $qaStatusFile) {
|
||||
$status = Get-Content $qaStatusFile -Raw
|
||||
if ($status -match "PASS") {
|
||||
return $true
|
||||
}
|
||||
}
|
||||
|
||||
# Display block message
|
||||
Write-Output "`n`n"
|
||||
Write-Output "🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫"
|
||||
Write-Output "⛔️ BUILD MODE BLOCKED: QA VALIDATION REQUIRED"
|
||||
Write-Output "⛔️ You must complete QA validation before proceeding to BUILD mode"
|
||||
Write-Output "`n"
|
||||
Write-Output "Type 'VAN QA' to perform technical validation"
|
||||
Write-Output "`n"
|
||||
Write-Output "🚫 NO IMPLEMENTATION CAN PROCEED WITHOUT VALIDATION 🚫"
|
||||
Write-Output "🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫"
|
||||
|
||||
return $false
|
||||
}
|
||||
```
|
||||
|
||||
## 🧪 COMMON QA VALIDATION FIXES
|
||||
|
||||
Here are common fixes for issues encountered during QA validation:
|
||||
|
||||
### Dependency Issues:
|
||||
- **Missing Node.js**: Install Node.js from https://nodejs.org/
|
||||
- **Outdated npm**: Run `npm install -g npm@latest` to update
|
||||
- **Missing packages**: Run `npm install` or `npm install [package-name]`
|
||||
|
||||
### Configuration Issues:
|
||||
- **Invalid JSON**: Use a JSON validator to check syntax
|
||||
- **Missing React plugin**: Add `import react from '@vitejs/plugin-react'` and `plugins: [react()]` to vite.config.js
|
||||
- **Incompatible TypeScript config**: Update `tsconfig.json` with correct React settings
|
||||
|
||||
### Environment Issues:
|
||||
- **Permission denied**: Run terminal as administrator (Windows) or use sudo (Mac/Linux)
|
||||
- **Port already in use**: Kill process using the port or change the port in configuration
|
||||
- **Missing build tools**: Install required command-line tools
|
||||
|
||||
### Build Test Issues:
|
||||
- **Build fails**: Check console for specific error messages
|
||||
- **Test fails**: Verify minimal configuration is correct
|
||||
- **Path issues**: Ensure paths use correct separators for the platform
|
||||
|
||||
## 🔒 FINAL QA VALIDATION CHECKPOINT
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: QA VALIDATION
|
||||
- Dependency Verification Passed? [YES/NO]
|
||||
- Configuration Validation Passed? [YES/NO]
|
||||
- Environment Validation Passed? [YES/NO]
|
||||
- Minimal Build Test Passed? [YES/NO]
|
||||
|
||||
→ If all YES: Ready for BUILD mode
|
||||
→ If any NO: Fix identified issues before proceeding
|
||||
```
|
||||
@@ -0,0 +1,50 @@
|
||||
---
|
||||
description: Visual process map for VAN mode platform detection
|
||||
globs: van-platform-detection.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN MODE: PLATFORM DETECTION
|
||||
|
||||
> **TL;DR:** Detects the OS, determines path separators, and notes command adaptations required.
|
||||
|
||||
## 🌐 PLATFORM DETECTION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
PD["Platform Detection"] --> CheckOS["Detect Operating System"]
|
||||
CheckOS --> Win["Windows"]
|
||||
CheckOS --> Mac["macOS"]
|
||||
CheckOS --> Lin["Linux"]
|
||||
|
||||
Win & Mac & Lin --> Adapt["Adapt Commands<br>for Platform"]
|
||||
|
||||
Win --> WinPath["Path: Backslash (\\)"]
|
||||
Mac --> MacPath["Path: Forward Slash (/)"]
|
||||
Lin --> LinPath["Path: Forward Slash (/)"]
|
||||
|
||||
Win --> WinCmd["Command Adaptations:<br>dir, icacls, etc."]
|
||||
Mac --> MacCmd["Command Adaptations:<br>ls, chmod, etc."]
|
||||
Lin --> LinCmd["Command Adaptations:<br>ls, chmod, etc."]
|
||||
|
||||
WinPath & MacPath & LinPath --> PathCP["Path Separator<br>Checkpoint"]
|
||||
WinCmd & MacCmd & LinCmd --> CmdCP["Command<br>Checkpoint"]
|
||||
|
||||
PathCP & CmdCP --> PlatformComplete["Platform Detection<br>Complete"]
|
||||
|
||||
style PD fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style PlatformComplete fill:#10b981,stroke:#059669,color:white
|
||||
```
|
||||
|
||||
## 📋 CHECKPOINT VERIFICATION TEMPLATE (Example)
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: PLATFORM DETECTION
|
||||
- Operating System Detected? [YES/NO]
|
||||
- Path Separator Confirmed? [YES/NO]
|
||||
- Command Adaptations Noted? [YES/NO]
|
||||
|
||||
→ If all YES: Platform Detection Complete.
|
||||
→ If any NO: Resolve before proceeding.
|
||||
```
|
||||
|
||||
**Next Step:** Load and process `van-file-verification.mdc`.
|
||||
+117
@@ -0,0 +1,117 @@
|
||||
---
|
||||
description: Process map for VAN QA minimal build test
|
||||
globs: van-qa-checks/build-test.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: MINIMAL BUILD TEST
|
||||
|
||||
> **TL;DR:** This component performs a minimal build test to ensure core build functionality works properly.
|
||||
|
||||
## 4️⃣ MINIMAL BUILD TEST PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Minimal Build Test"] --> CreateTest["Create Minimal<br>Test Project"]
|
||||
CreateTest --> BuildTest["Attempt<br>Build"]
|
||||
BuildTest --> BuildStatus{"Build<br>Successful?"}
|
||||
|
||||
BuildStatus -->|"Yes"| RunTest["Run Basic<br>Functionality Test"]
|
||||
BuildStatus -->|"No"| FixBuild["Fix Build<br>Issues"]
|
||||
FixBuild --> RetryBuild["Retry Build"]
|
||||
RetryBuild --> BuildStatus
|
||||
|
||||
RunTest --> TestStatus{"Test<br>Passed?"}
|
||||
TestStatus -->|"Yes"| TestSuccess["Minimal Build Test<br>✅ PASS"]
|
||||
TestStatus -->|"No"| FixTest["Fix Test<br>Issues"]
|
||||
FixTest --> RetryTest["Retry Test"]
|
||||
RetryTest --> TestStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style TestSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style BuildStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style TestStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### Minimal Build Test Implementation:
|
||||
```powershell
|
||||
# Example: Perform minimal build test for a React project
|
||||
function Perform-MinimalBuildTest {
|
||||
$buildSuccess = $false
|
||||
$testSuccess = $false
|
||||
|
||||
# Create minimal test project
|
||||
$testDir = ".__build_test"
|
||||
if (Test-Path $testDir) {
|
||||
Remove-Item -Path $testDir -Recurse -Force
|
||||
}
|
||||
|
||||
try {
|
||||
# Create minimal test directory
|
||||
New-Item -Path $testDir -ItemType Directory | Out-Null
|
||||
Push-Location $testDir
|
||||
|
||||
# Initialize minimal package.json
|
||||
@"
|
||||
{
|
||||
"name": "build-test",
|
||||
"version": "1.0.0",
|
||||
"description": "Minimal build test",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"build": "echo Build test successful"
|
||||
}
|
||||
}
|
||||
"@ | Set-Content -Path "package.json"
|
||||
|
||||
# Attempt build
|
||||
npm run build | Out-Null
|
||||
$buildSuccess = $true
|
||||
|
||||
# Create minimal test file
|
||||
@"
|
||||
console.log('Test successful');
|
||||
"@ | Set-Content -Path "index.js"
|
||||
|
||||
# Run basic test
|
||||
node index.js | Out-Null
|
||||
$testSuccess = $true
|
||||
|
||||
} catch {
|
||||
Write-Output "❌ Build test failed: $($_.Exception.Message)"
|
||||
} finally {
|
||||
Pop-Location
|
||||
if (Test-Path $testDir) {
|
||||
Remove-Item -Path $testDir -Recurse -Force
|
||||
}
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($buildSuccess -and $testSuccess) {
|
||||
Write-Output "✅ Minimal build test passed successfully"
|
||||
return $true
|
||||
} else {
|
||||
if (-not $buildSuccess) {
|
||||
Write-Output "❌ Build process failed"
|
||||
}
|
||||
if (-not $testSuccess) {
|
||||
Write-Output "❌ Basic functionality test failed"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 MINIMAL BUILD TEST CHECKPOINT
|
||||
|
||||
```
|
||||
✓ CHECKPOINT: MINIMAL BUILD TEST
|
||||
- Test project creation successful? [YES/NO]
|
||||
- Build process completed successfully? [YES/NO]
|
||||
- Basic functionality test passed? [YES/NO]
|
||||
|
||||
→ If all YES: QA Validation complete, proceed to generate success report.
|
||||
→ If any NO: Fix build issues before continuing.
|
||||
```
|
||||
|
||||
**Next Step (on PASS):** Load `van-qa-utils/reports.mdc` to generate success report.
|
||||
**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for build test fixes.
|
||||
+103
@@ -0,0 +1,103 @@
|
||||
---
|
||||
description: Process map for VAN QA configuration validation
|
||||
globs: van-qa-checks/config-check.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: CONFIGURATION VALIDATION
|
||||
|
||||
> **TL;DR:** This component validates configuration files for proper syntax and compatibility with the project and platform.
|
||||
|
||||
## 2️⃣ CONFIGURATION VALIDATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Configuration Validation"] --> IdentifyConfigs["Identify Configuration<br>Files"]
|
||||
IdentifyConfigs --> ReadConfigs["Read Configuration<br>Files"]
|
||||
ReadConfigs --> ValidateSyntax["Validate Syntax<br>and Format"]
|
||||
ValidateSyntax --> SyntaxStatus{"Syntax<br>Valid?"}
|
||||
|
||||
SyntaxStatus -->|"Yes"| CheckCompatibility["Check Compatibility<br>with Platform"]
|
||||
SyntaxStatus -->|"No"| FixSyntax["Fix Syntax<br>Errors"]
|
||||
FixSyntax --> RetryValidate["Retry Validation"]
|
||||
RetryValidate --> SyntaxStatus
|
||||
|
||||
CheckCompatibility --> CompatStatus{"Compatible with<br>Platform?"}
|
||||
CompatStatus -->|"Yes"| ConfigSuccess["Configurations Validated<br>✅ PASS"]
|
||||
CompatStatus -->|"No"| AdaptConfigs["Adapt Configurations<br>for Platform"]
|
||||
AdaptConfigs --> RetryCompat["Retry Compatibility<br>Check"]
|
||||
RetryCompat --> CompatStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ConfigSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style SyntaxStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style CompatStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### Configuration Validation Implementation:
|
||||
```powershell
|
||||
# Example: Validate configuration files for a web project
|
||||
function Validate-Configurations {
|
||||
$configFiles = @(
|
||||
"package.json",
|
||||
"tsconfig.json",
|
||||
"vite.config.js"
|
||||
)
|
||||
|
||||
$invalidConfigs = @()
|
||||
$incompatibleConfigs = @()
|
||||
|
||||
foreach ($configFile in $configFiles) {
|
||||
if (Test-Path $configFile) {
|
||||
# Check JSON syntax for JSON files
|
||||
if ($configFile -match "\.json$") {
|
||||
try {
|
||||
Get-Content $configFile -Raw | ConvertFrom-Json | Out-Null
|
||||
} catch {
|
||||
$invalidConfigs += "$configFile (JSON syntax error: $($_.Exception.Message))"
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
# Specific configuration compatibility checks
|
||||
if ($configFile -eq "vite.config.js") {
|
||||
$content = Get-Content $configFile -Raw
|
||||
# Check for React plugin in Vite config
|
||||
if ($content -notmatch "react\(\)") {
|
||||
$incompatibleConfigs += "$configFile (Missing React plugin for React project)"
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$invalidConfigs += "$configFile (file not found)"
|
||||
}
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($invalidConfigs.Count -eq 0 -and $incompatibleConfigs.Count -eq 0) {
|
||||
Write-Output "✅ All configurations validated and compatible"
|
||||
return $true
|
||||
} else {
|
||||
if ($invalidConfigs.Count -gt 0) {
|
||||
Write-Output "❌ Invalid configurations: $($invalidConfigs -join ', ')"
|
||||
}
|
||||
if ($incompatibleConfigs.Count -gt 0) {
|
||||
Write-Output "❌ Incompatible configurations: $($incompatibleConfigs -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 CONFIGURATION VALIDATION CHECKPOINT
|
||||
|
||||
```
|
||||
✓ CHECKPOINT: CONFIGURATION VALIDATION
|
||||
- All configuration files found? [YES/NO]
|
||||
- All configuration syntax valid? [YES/NO]
|
||||
- All configurations compatible with platform? [YES/NO]
|
||||
|
||||
→ If all YES: Continue to Environment Validation.
|
||||
→ If any NO: Fix configuration issues before continuing.
|
||||
```
|
||||
|
||||
**Next Step (on PASS):** Load `van-qa-checks/environment-check.mdc`.
|
||||
**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for configuration fixes.
|
||||
+147
@@ -0,0 +1,147 @@
|
||||
---
|
||||
description: Process map for VAN QA dependency verification
|
||||
globs: van-qa-checks/dependency-check.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: DEPENDENCY VERIFICATION
|
||||
|
||||
> **TL;DR:** This component verifies that all required dependencies are installed and compatible with the project requirements.
|
||||
|
||||
## 1️⃣ DEPENDENCY VERIFICATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Dependency Verification"] --> ReadDeps["Read Required Dependencies<br>from Creative Phase"]
|
||||
ReadDeps --> CheckInstalled["Check if Dependencies<br>are Installed"]
|
||||
CheckInstalled --> DepStatus{"All Dependencies<br>Installed?"}
|
||||
|
||||
DepStatus -->|"Yes"| VerifyVersions["Verify Versions<br>and Compatibility"]
|
||||
DepStatus -->|"No"| InstallMissing["Install Missing<br>Dependencies"]
|
||||
InstallMissing --> VerifyVersions
|
||||
|
||||
VerifyVersions --> VersionStatus{"Versions<br>Compatible?"}
|
||||
VersionStatus -->|"Yes"| DepSuccess["Dependencies Verified<br>✅ PASS"]
|
||||
VersionStatus -->|"No"| UpgradeVersions["Upgrade/Downgrade<br>as Needed"]
|
||||
UpgradeVersions --> RetryVerify["Retry Verification"]
|
||||
RetryVerify --> VersionStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style DepSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style DepStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style VersionStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### Windows (PowerShell) Implementation:
|
||||
```powershell
|
||||
# Example: Verify Node.js dependencies for a React project
|
||||
function Verify-Dependencies {
|
||||
$requiredDeps = @{ "node" = ">=14.0.0"; "npm" = ">=6.0.0" }
|
||||
$missingDeps = @(); $incompatibleDeps = @()
|
||||
|
||||
# Check Node.js version
|
||||
try {
|
||||
$nodeVersion = node -v
|
||||
if ($nodeVersion -match "v(\d+)\.(\d+)\.(\d+)") {
|
||||
$major = [int]$Matches[1]
|
||||
if ($major -lt 14) {
|
||||
$incompatibleDeps += "node (found $nodeVersion, required >=14.0.0)"
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
$missingDeps += "node"
|
||||
}
|
||||
|
||||
# Check npm version
|
||||
try {
|
||||
$npmVersion = npm -v
|
||||
if ($npmVersion -match "(\d+)\.(\d+)\.(\d+)") {
|
||||
$major = [int]$Matches[1]
|
||||
if ($major -lt 6) {
|
||||
$incompatibleDeps += "npm (found $npmVersion, required >=6.0.0)"
|
||||
}
|
||||
}
|
||||
} catch {
|
||||
$missingDeps += "npm"
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($missingDeps.Count -eq 0 -and $incompatibleDeps.Count -eq 0) {
|
||||
Write-Output "✅ All dependencies verified and compatible"
|
||||
return $true
|
||||
} else {
|
||||
if ($missingDeps.Count -gt 0) {
|
||||
Write-Output "❌ Missing dependencies: $($missingDeps -join ', ')"
|
||||
}
|
||||
if ($incompatibleDeps.Count -gt 0) {
|
||||
Write-Output "❌ Incompatible versions: $($incompatibleDeps -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Mac/Linux (Bash) Implementation:
|
||||
```bash
|
||||
#!/bin/bash
|
||||
|
||||
# Example: Verify Node.js dependencies for a React project
|
||||
verify_dependencies() {
|
||||
local missing_deps=()
|
||||
local incompatible_deps=()
|
||||
|
||||
# Check Node.js version
|
||||
if command -v node &> /dev/null; then
|
||||
local node_version=$(node -v)
|
||||
if [[ $node_version =~ v([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
|
||||
local major=${BASH_REMATCH[1]}
|
||||
if (( major < 14 )); then
|
||||
incompatible_deps+=("node (found $node_version, required >=14.0.0)")
|
||||
fi
|
||||
fi
|
||||
else
|
||||
missing_deps+=("node")
|
||||
fi
|
||||
|
||||
# Check npm version
|
||||
if command -v npm &> /dev/null; then
|
||||
local npm_version=$(npm -v)
|
||||
if [[ $npm_version =~ ([0-9]+)\.([0-9]+)\.([0-9]+) ]]; then
|
||||
local major=${BASH_REMATCH[1]}
|
||||
if (( major < 6 )); then
|
||||
incompatible_deps+=("npm (found $npm_version, required >=6.0.0)")
|
||||
fi
|
||||
fi
|
||||
else
|
||||
missing_deps+=("npm")
|
||||
fi
|
||||
|
||||
# Display results
|
||||
if [ ${#missing_deps[@]} -eq 0 ] && [ ${#incompatible_deps[@]} -eq 0 ]; then
|
||||
echo "✅ All dependencies verified and compatible"
|
||||
return 0
|
||||
else
|
||||
if [ ${#missing_deps[@]} -gt 0 ]; then
|
||||
echo "❌ Missing dependencies: ${missing_deps[*]}"
|
||||
fi
|
||||
if [ ${#incompatible_deps[@]} -gt 0 ]; then
|
||||
echo "❌ Incompatible versions: ${incompatible_deps[*]}"
|
||||
fi
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 DEPENDENCY VERIFICATION CHECKPOINT
|
||||
|
||||
```
|
||||
✓ CHECKPOINT: DEPENDENCY VERIFICATION
|
||||
- Required dependencies identified? [YES/NO]
|
||||
- All dependencies installed? [YES/NO]
|
||||
- All versions compatible? [YES/NO]
|
||||
|
||||
→ If all YES: Continue to Configuration Validation.
|
||||
→ If any NO: Fix dependency issues before continuing.
|
||||
```
|
||||
|
||||
**Next Step (on PASS):** Load `van-qa-checks/config-check.mdc`.
|
||||
**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for dependency fixes.
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
---
|
||||
description: Process map for VAN QA environment validation
|
||||
globs: van-qa-checks/environment-check.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: ENVIRONMENT VALIDATION
|
||||
|
||||
> **TL;DR:** This component verifies that the build environment is properly set up with required tools and permissions.
|
||||
|
||||
## 3️⃣ ENVIRONMENT VALIDATION PROCESS
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Environment Validation"] --> CheckEnv["Check Build Environment"]
|
||||
CheckEnv --> VerifyBuildTools["Verify Build Tools"]
|
||||
VerifyBuildTools --> ToolsStatus{"Build Tools<br>Available?"}
|
||||
|
||||
ToolsStatus -->|"Yes"| CheckPerms["Check Permissions<br>and Access"]
|
||||
ToolsStatus -->|"No"| InstallTools["Install Required<br>Build Tools"]
|
||||
InstallTools --> RetryTools["Retry Verification"]
|
||||
RetryTools --> ToolsStatus
|
||||
|
||||
CheckPerms --> PermsStatus{"Permissions<br>Sufficient?"}
|
||||
PermsStatus -->|"Yes"| EnvSuccess["Environment Validated<br>✅ PASS"]
|
||||
PermsStatus -->|"No"| FixPerms["Fix Permission<br>Issues"]
|
||||
FixPerms --> RetryPerms["Retry Permission<br>Check"]
|
||||
RetryPerms --> PermsStatus
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style EnvSuccess fill:#10b981,stroke:#059669,color:white
|
||||
style ToolsStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
style PermsStatus fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### Environment Validation Implementation:
|
||||
```powershell
|
||||
# Example: Validate environment for a web project
|
||||
function Validate-Environment {
|
||||
$requiredTools = @(
|
||||
@{Name = "git"; Command = "git --version"},
|
||||
@{Name = "node"; Command = "node --version"},
|
||||
@{Name = "npm"; Command = "npm --version"}
|
||||
)
|
||||
|
||||
$missingTools = @()
|
||||
$permissionIssues = @()
|
||||
|
||||
# Check build tools
|
||||
foreach ($tool in $requiredTools) {
|
||||
try {
|
||||
Invoke-Expression $tool.Command | Out-Null
|
||||
} catch {
|
||||
$missingTools += $tool.Name
|
||||
}
|
||||
}
|
||||
|
||||
# Check write permissions in project directory
|
||||
try {
|
||||
$testFile = ".__permission_test"
|
||||
New-Item -Path $testFile -ItemType File -Force | Out-Null
|
||||
Remove-Item -Path $testFile -Force
|
||||
} catch {
|
||||
$permissionIssues += "Current directory (write permission denied)"
|
||||
}
|
||||
|
||||
# Check if port 3000 is available (commonly used for dev servers)
|
||||
try {
|
||||
$listener = New-Object System.Net.Sockets.TcpListener([System.Net.IPAddress]::Loopback, 3000)
|
||||
$listener.Start()
|
||||
$listener.Stop()
|
||||
} catch {
|
||||
$permissionIssues += "Port 3000 (already in use or access denied)"
|
||||
}
|
||||
|
||||
# Display results
|
||||
if ($missingTools.Count -eq 0 -and $permissionIssues.Count -eq 0) {
|
||||
Write-Output "✅ Environment validated successfully"
|
||||
return $true
|
||||
} else {
|
||||
if ($missingTools.Count -gt 0) {
|
||||
Write-Output "❌ Missing tools: $($missingTools -join ', ')"
|
||||
}
|
||||
if ($permissionIssues.Count -gt 0) {
|
||||
Write-Output "❌ Permission issues: $($permissionIssues -join ', ')"
|
||||
}
|
||||
return $false
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## 📋 ENVIRONMENT VALIDATION CHECKPOINT
|
||||
|
||||
```
|
||||
✓ CHECKPOINT: ENVIRONMENT VALIDATION
|
||||
- All required build tools installed? [YES/NO]
|
||||
- Project directory permissions sufficient? [YES/NO]
|
||||
- Required ports available? [YES/NO]
|
||||
|
||||
→ If all YES: Continue to Minimal Build Test.
|
||||
→ If any NO: Fix environment issues before continuing.
|
||||
```
|
||||
|
||||
**Next Step (on PASS):** Load `van-qa-checks/build-test.mdc`.
|
||||
**Next Step (on FAIL):** Check `van-qa-utils/common-fixes.mdc` for environment fixes.
|
||||
+1
@@ -0,0 +1 @@
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
---
|
||||
description: Visual process map for VAN QA mode (Technical Validation Entry Point)
|
||||
globs: van-qa-main.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN MODE: QA TECHNICAL VALIDATION (Main Entry)
|
||||
|
||||
> **TL;DR:** This is the entry point for the QA validation process that executes *after* CREATIVE mode and *before* BUILD mode. It ensures technical requirements are met before implementation begins.
|
||||
|
||||
## 📣 HOW TO USE THESE QA RULES
|
||||
|
||||
To access any QA validation rule or component, use the `fetch_rules` tool with exact rule names:
|
||||
|
||||
```
|
||||
// CRITICAL: Always use fetch_rules to load validation components
|
||||
// For detailed examples and guidance, load:
|
||||
// isolation_rules/visual-maps/van-qa-utils/rule-calling-guide
|
||||
```
|
||||
|
||||
## 🚀 VAN QA MODE ACTIVATION
|
||||
|
||||
After completing CREATIVE mode, when the user types "VAN QA", respond:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
UserQA["User Types: QA"] --> HighPriority["⚠️ HIGH PRIORITY COMMAND"]
|
||||
HighPriority --> CurrentTask["Pause Current Task/Process"]
|
||||
CurrentTask --> LoadQA["Load QA Main Map (This File)"]
|
||||
LoadQA --> RunQA["Execute QA Validation Process"]
|
||||
RunQA --> QAResults{"QA Results"}
|
||||
|
||||
QAResults -->|"PASS"| ResumeFlow["Resume Prior Process Flow"]
|
||||
QAResults -->|"FAIL"| FixIssues["Fix Identified Issues"]
|
||||
FixIssues --> ReRunQA["Re-run QA Validation"]
|
||||
ReRunQA --> QAResults
|
||||
|
||||
style UserQA fill:#f8d486,stroke:#e8b84d,color:black
|
||||
style HighPriority fill:#ff0000,stroke:#cc0000,color:white,stroke-width:3px
|
||||
style LoadQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style RunQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style QAResults fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### QA Interruption Rules
|
||||
|
||||
1. **Immediate Precedence:** `QA` command interrupts everything.
|
||||
2. **Load & Execute:** Load this map (`van-qa-main.mdc`) and its components (see below).
|
||||
3. **Remediation Priority:** Fixes take priority over pending mode switches.
|
||||
4. **Resume:** On PASS, resume the previous flow.
|
||||
|
||||
```
|
||||
⚠️ QA OVERRIDE ACTIVATED
|
||||
All other processes paused
|
||||
QA validation checks now running...
|
||||
Any issues found MUST be remediated before continuing with normal process flow
|
||||
```
|
||||
|
||||
## 🔍 TECHNICAL VALIDATION OVERVIEW
|
||||
|
||||
Four-point validation process with selective loading:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
VANQA["VAN QA MODE"] --> FourChecks["FOUR-POINT VALIDATION"]
|
||||
|
||||
FourChecks --> DepCheck["1️⃣ DEPENDENCY VERIFICATION
|
||||
Load: van-qa-checks/dependency-check.mdc"]
|
||||
DepCheck --> ConfigCheck["2️⃣ CONFIGURATION VALIDATION
|
||||
Load: van-qa-checks/config-check.mdc"]
|
||||
ConfigCheck --> EnvCheck["3️⃣ ENVIRONMENT VALIDATION
|
||||
Load: van-qa-checks/environment-check.mdc"]
|
||||
EnvCheck --> MinBuildCheck["4️⃣ MINIMAL BUILD TEST
|
||||
Load: van-qa-checks/build-test.mdc"]
|
||||
|
||||
MinBuildCheck --> ValidationResults{"All Checks<br>Passed?"}
|
||||
ValidationResults -->|"Yes"| SuccessReport["GENERATE SUCCESS REPORT
|
||||
Load: van-qa-utils/reports.mdc"]
|
||||
ValidationResults -->|"No"| FailureReport["GENERATE FAILURE REPORT
|
||||
Load: van-qa-utils/reports.mdc"]
|
||||
|
||||
SuccessReport --> BUILD_Transition["Trigger BUILD Mode
|
||||
Load: van-qa-utils/mode-transitions.mdc"]
|
||||
FailureReport --> FixIssues["Fix Technical Issues
|
||||
Load: van-qa-utils/common-fixes.mdc"]
|
||||
FixIssues --> ReValidate["Re-validate (Re-run VAN QA)"]
|
||||
ReValidate --> FourChecks
|
||||
|
||||
style VANQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FourChecks fill:#f6546a,stroke:#c30052,color:white
|
||||
style ValidationResults fill:#f6546a,stroke:#c30052,color:white
|
||||
style BUILD_Transition fill:#10b981,stroke:#059669,color:white
|
||||
style FixIssues fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 🔄 INTEGRATION WITH DESIGN DECISIONS
|
||||
|
||||
Reads Creative Phase outputs to inform validation:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Read Design Decisions"] --> ReadCreative["Parse Creative Phase<br>Documentation"]
|
||||
ReadCreative --> ExtractTech["Extract Technology<br>Choices"]
|
||||
ExtractTech --> ExtractDeps["Extract Required<br>Dependencies"]
|
||||
ExtractDeps --> BuildValidationPlan["Build Validation<br>Plan"]
|
||||
BuildValidationPlan --> StartValidation["Start Four-Point<br>Validation Process"]
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ExtractTech fill:#f6546a,stroke:#c30052,color:white
|
||||
style BuildValidationPlan fill:#10b981,stroke:#059669,color:white
|
||||
style StartValidation fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
## 📋 COMPONENT LOADING SEQUENCE
|
||||
|
||||
The QA validation process follows this selective loading sequence:
|
||||
|
||||
1. **Main Entry (This File)**: `van-qa-main.mdc`
|
||||
2. **Validation Checks**:
|
||||
- `van-qa-checks/dependency-check.mdc`
|
||||
- `van-qa-checks/config-check.mdc`
|
||||
- `van-qa-checks/environment-check.mdc`
|
||||
- `van-qa-checks/build-test.mdc`
|
||||
3. **Utilities (As Needed)**:
|
||||
- `van-qa-utils/reports.mdc`
|
||||
- `van-qa-utils/common-fixes.mdc`
|
||||
- `van-qa-utils/mode-transitions.mdc`
|
||||
|
||||
## 📋 FINAL QA VALIDATION CHECKPOINT
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: QA VALIDATION
|
||||
- Dependency Verification Passed? [YES/NO]
|
||||
- Configuration Validation Passed? [YES/NO]
|
||||
- Environment Validation Passed? [YES/NO]
|
||||
- Minimal Build Test Passed? [YES/NO]
|
||||
|
||||
→ If all YES: Ready for BUILD mode transition.
|
||||
→ If any NO: Fix identified issues and re-run VAN QA.
|
||||
```
|
||||
|
||||
**Next Step (on PASS):** Trigger BUILD mode (load `van-qa-utils/mode-transitions.mdc`).
|
||||
**Next Step (on FAIL):** Address issues (load `van-qa-utils/common-fixes.mdc`) and re-run `VAN QA`.
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
---
|
||||
description: Utility for VAN QA common validation fixes
|
||||
globs: van-qa-utils/common-fixes.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: COMMON VALIDATION FIXES
|
||||
|
||||
> **TL;DR:** This component provides common fixes for issues that may arise during the QA validation process.
|
||||
|
||||
## 🧪 COMMON QA VALIDATION FIXES BY CATEGORY
|
||||
|
||||
### Dependency Issues
|
||||
|
||||
| Issue | Fix |
|
||||
|-------|-----|
|
||||
| **Missing Node.js** | Download and install Node.js from https://nodejs.org/ |
|
||||
| **Outdated npm** | Run `npm install -g npm@latest` to update |
|
||||
| **Missing packages** | Run `npm install` or `npm install [package-name]` |
|
||||
| **Package version conflicts** | Adjust versions in package.json and run `npm install` |
|
||||
| **Dependency resolution issues** | Run `npm cache clean -f` and try installing again |
|
||||
|
||||
### Configuration Issues
|
||||
|
||||
| Issue | Fix |
|
||||
|-------|-----|
|
||||
| **Invalid JSON** | Use a JSON validator (e.g., jsonlint) to check syntax |
|
||||
| **Missing React plugin** | Add `import react from '@vitejs/plugin-react'` and `plugins: [react()]` to vite.config.js |
|
||||
| **Incompatible TypeScript config** | Update `tsconfig.json` with correct React settings |
|
||||
| **Mismatched version references** | Ensure consistent versions across configuration files |
|
||||
| **Missing entries in config files** | Add required fields to configuration files |
|
||||
|
||||
### Environment Issues
|
||||
|
||||
| Issue | Fix |
|
||||
|-------|-----|
|
||||
| **Permission denied** | Run terminal as administrator (Windows) or use sudo (Mac/Linux) |
|
||||
| **Port already in use** | Kill process using the port: `netstat -ano \| findstr :PORT` then `taskkill /F /PID PID` (Windows) or `lsof -i :PORT` then `kill -9 PID` (Mac/Linux) |
|
||||
| **Missing build tools** | Install required command-line tools (git, node, etc.) |
|
||||
| **Environment variable issues** | Set required environment variables: `$env:VAR_NAME = "value"` (PowerShell) or `export VAR_NAME="value"` (Bash) |
|
||||
| **Disk space issues** | Free up disk space, clean npm/package cache files |
|
||||
|
||||
### Build Test Issues
|
||||
|
||||
| Issue | Fix |
|
||||
|-------|-----|
|
||||
| **Build fails** | Check console for specific error messages |
|
||||
| **Test fails** | Verify minimal configuration is correct |
|
||||
| **Path issues** | Ensure paths use correct separators for the platform (`\` for Windows, `/` for Mac/Linux) |
|
||||
| **Missing dependencies** | Make sure all required dependencies are installed |
|
||||
| **Script permissions** | Ensure script files have execution permissions (chmod +x on Unix) |
|
||||
|
||||
## 📝 ISSUE DIAGNOSIS PROCEDURES
|
||||
|
||||
### 1. Dependency Diagnosis
|
||||
```powershell
|
||||
# Find conflicting dependencies
|
||||
npm ls [package-name]
|
||||
|
||||
# Check for outdated packages
|
||||
npm outdated
|
||||
|
||||
# Check for vulnerabilities
|
||||
npm audit
|
||||
```
|
||||
|
||||
### 2. Configuration Diagnosis
|
||||
```powershell
|
||||
# List all configuration files
|
||||
Get-ChildItem -Recurse -Include "*.json","*.config.js" | Select-Object FullName
|
||||
|
||||
# Find missing references in tsconfig.json
|
||||
if (Test-Path "tsconfig.json") {
|
||||
$tsconfig = Get-Content "tsconfig.json" -Raw | ConvertFrom-Json
|
||||
if (-not $tsconfig.compilerOptions.jsx) {
|
||||
Write-Output "Missing jsx setting in tsconfig.json"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### 3. Environment Diagnosis
|
||||
```powershell
|
||||
# Check process using a port (Windows)
|
||||
netstat -ano | findstr ":3000"
|
||||
|
||||
# List environment variables
|
||||
Get-ChildItem Env:
|
||||
|
||||
# Check disk space
|
||||
Get-PSDrive C | Select-Object Used,Free
|
||||
```
|
||||
|
||||
**Next Step:** Return to the validation process or follow the specific fix recommendations provided above.
|
||||
+101
@@ -0,0 +1,101 @@
|
||||
---
|
||||
description: Utility for VAN QA mode transitions
|
||||
globs: van-qa-utils/mode-transitions.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: MODE TRANSITIONS
|
||||
|
||||
> **TL;DR:** This component handles transitions between modes, particularly the QA validation to BUILD mode transition, and prevents BUILD mode access without successful QA validation.
|
||||
|
||||
## 🔒 BUILD MODE PREVENTION MECHANISM
|
||||
|
||||
The system prevents moving to BUILD mode without passing QA validation:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["User Types: BUILD"] --> CheckQA{"QA Validation<br>Completed?"}
|
||||
CheckQA -->|"Yes and Passed"| AllowBuild["Allow BUILD Mode"]
|
||||
CheckQA -->|"No or Failed"| BlockBuild["BLOCK BUILD MODE"]
|
||||
BlockBuild --> Message["Display:<br>⚠️ QA VALIDATION REQUIRED"]
|
||||
Message --> ReturnToVANQA["Prompt: Type VAN QA"]
|
||||
|
||||
style CheckQA fill:#f6546a,stroke:#c30052,color:white
|
||||
style BlockBuild fill:#ff0000,stroke:#990000,color:white,stroke-width:3px
|
||||
style Message fill:#ff5555,stroke:#dd3333,color:white
|
||||
style ReturnToVANQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
```
|
||||
|
||||
### Implementation Example (PowerShell):
|
||||
```powershell
|
||||
# Check QA status before allowing BUILD mode
|
||||
function Check-QAValidationStatus {
|
||||
$qaStatusFile = "memory-bank\.qa_validation_status" # Assumes status is written by reports.mdc
|
||||
|
||||
if (Test-Path $qaStatusFile) {
|
||||
$status = Get-Content $qaStatusFile -Raw
|
||||
if ($status -match "PASS") {
|
||||
return $true
|
||||
}
|
||||
}
|
||||
|
||||
# Display block message
|
||||
Write-Output "`n`n"
|
||||
Write-Output "🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫"
|
||||
Write-Output "⛔️ BUILD MODE BLOCKED: QA VALIDATION REQUIRED"
|
||||
Write-Output "⛔️ You must complete QA validation before proceeding to BUILD mode"
|
||||
Write-Output "`n"
|
||||
Write-Output "Type 'VAN QA' to perform technical validation"
|
||||
Write-Output "`n"
|
||||
Write-Output "🚫 NO IMPLEMENTATION CAN PROCEED WITHOUT VALIDATION 🚫"
|
||||
Write-Output "🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫🚫"
|
||||
|
||||
return $false
|
||||
}
|
||||
```
|
||||
|
||||
## 🚨 MODE TRANSITION TRIGGERS
|
||||
|
||||
### CREATIVE to VAN QA Transition:
|
||||
After completing the CREATIVE phase, trigger this message to prompt QA validation:
|
||||
|
||||
```
|
||||
⏭️ NEXT MODE: VAN QA
|
||||
To validate technical requirements before implementation, please type 'VAN QA'
|
||||
```
|
||||
|
||||
### VAN QA to BUILD Transition (On Success):
|
||||
After successful QA validation, trigger this message to allow BUILD mode:
|
||||
|
||||
```
|
||||
✅ TECHNICAL VALIDATION COMPLETE
|
||||
All prerequisites verified successfully
|
||||
You may now proceed to BUILD mode
|
||||
Type 'BUILD' to begin implementation
|
||||
```
|
||||
|
||||
### Manual BUILD Mode Access (When QA Already Passed):
|
||||
When the user manually types 'BUILD', check the QA status before allowing access:
|
||||
|
||||
```powershell
|
||||
# Handle BUILD mode request
|
||||
function Handle-BuildModeRequest {
|
||||
if (Check-QAValidationStatus) {
|
||||
# Allow transition to BUILD mode
|
||||
Write-Output "`n"
|
||||
Write-Output "✅ QA VALIDATION CHECK: PASSED"
|
||||
Write-Output "Loading BUILD mode..."
|
||||
Write-Output "`n"
|
||||
|
||||
# Here you would load the BUILD mode map
|
||||
# [Code to load BUILD mode map]
|
||||
|
||||
return $true
|
||||
}
|
||||
|
||||
# QA validation failed or not completed, BUILD mode blocked
|
||||
return $false
|
||||
}
|
||||
```
|
||||
|
||||
**Next Step (on QA SUCCESS):** Continue to BUILD mode.
|
||||
**Next Step (on QA FAILURE):** Return to QA validation process.
|
||||
@@ -0,0 +1,149 @@
|
||||
---
|
||||
description: Utility for VAN QA validation reports
|
||||
globs: van-qa-utils/reports.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: VALIDATION REPORTS
|
||||
|
||||
> **TL;DR:** This component contains the formats for comprehensive success and failure reports generated upon completion of the QA validation process.
|
||||
|
||||
## 📋 COMPREHENSIVE SUCCESS REPORT FORMAT
|
||||
|
||||
After all four validation points pass, generate this success report:
|
||||
|
||||
```
|
||||
╔═════════════════════ 🔍 QA VALIDATION REPORT ══════════════════════╗
|
||||
│ PROJECT: [Project Name] | TIMESTAMP: [Current Date/Time] │
|
||||
├─────────────────────────────────────────────────────────────────────┤
|
||||
│ 1️⃣ DEPENDENCIES: ✓ Compatible │
|
||||
│ 2️⃣ CONFIGURATION: ✓ Valid & Compatible │
|
||||
│ 3️⃣ ENVIRONMENT: ✓ Ready │
|
||||
│ 4️⃣ MINIMAL BUILD: ✓ Successful & Passed │
|
||||
├─────────────────────────────────────────────────────────────────────┤
|
||||
│ 🚨 FINAL VERDICT: PASS │
|
||||
│ ➡️ Clear to proceed to BUILD mode │
|
||||
╚═════════════════════════════════════════════════════════════════════╝
|
||||
```
|
||||
|
||||
### Success Report Generation Example:
|
||||
```powershell
|
||||
function Generate-SuccessReport {
|
||||
param (
|
||||
[string]$ProjectName = "Current Project"
|
||||
)
|
||||
|
||||
$timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
|
||||
|
||||
$report = @"
|
||||
╔═════════════════════ 🔍 QA VALIDATION REPORT ══════════════════════╗
|
||||
│ PROJECT: $ProjectName | TIMESTAMP: $timestamp │
|
||||
├─────────────────────────────────────────────────────────────────────┤
|
||||
│ 1️⃣ DEPENDENCIES: ✓ Compatible │
|
||||
│ 2️⃣ CONFIGURATION: ✓ Valid & Compatible │
|
||||
│ 3️⃣ ENVIRONMENT: ✓ Ready │
|
||||
│ 4️⃣ MINIMAL BUILD: ✓ Successful & Passed │
|
||||
├─────────────────────────────────────────────────────────────────────┤
|
||||
│ 🚨 FINAL VERDICT: PASS │
|
||||
│ ➡️ Clear to proceed to BUILD mode │
|
||||
╚═════════════════════════════════════════════════════════════════════╝
|
||||
"@
|
||||
|
||||
# Save validation status (used by BUILD mode prevention mechanism)
|
||||
"PASS" | Set-Content -Path "memory-bank\.qa_validation_status"
|
||||
|
||||
return $report
|
||||
}
|
||||
```
|
||||
|
||||
## ❌ FAILURE REPORT FORMAT
|
||||
|
||||
If any validation step fails, generate this detailed failure report:
|
||||
|
||||
```
|
||||
⚠️⚠️⚠️ QA VALIDATION FAILED ⚠️⚠️⚠️
|
||||
|
||||
The following issues must be resolved before proceeding to BUILD mode:
|
||||
|
||||
1️⃣ DEPENDENCY ISSUES:
|
||||
- [Detailed description of dependency issues]
|
||||
- [Recommended fix]
|
||||
|
||||
2️⃣ CONFIGURATION ISSUES:
|
||||
- [Detailed description of configuration issues]
|
||||
- [Recommended fix]
|
||||
|
||||
3️⃣ ENVIRONMENT ISSUES:
|
||||
- [Detailed description of environment issues]
|
||||
- [Recommended fix]
|
||||
|
||||
4️⃣ BUILD TEST ISSUES:
|
||||
- [Detailed description of build test issues]
|
||||
- [Recommended fix]
|
||||
|
||||
⚠️ BUILD MODE IS BLOCKED until these issues are resolved.
|
||||
Type 'VAN QA' after fixing the issues to re-validate.
|
||||
```
|
||||
|
||||
### Failure Report Generation Example:
|
||||
```powershell
|
||||
function Generate-FailureReport {
|
||||
param (
|
||||
[string[]]$DependencyIssues = @(),
|
||||
[string[]]$ConfigIssues = @(),
|
||||
[string[]]$EnvironmentIssues = @(),
|
||||
[string[]]$BuildIssues = @()
|
||||
)
|
||||
|
||||
$report = @"
|
||||
⚠️⚠️⚠️ QA VALIDATION FAILED ⚠️⚠️⚠️
|
||||
|
||||
The following issues must be resolved before proceeding to BUILD mode:
|
||||
|
||||
"@
|
||||
|
||||
if ($DependencyIssues.Count -gt 0) {
|
||||
$report += @"
|
||||
1️⃣ DEPENDENCY ISSUES:
|
||||
$(($DependencyIssues | ForEach-Object { "- $_" }) -join "`n")
|
||||
|
||||
"@
|
||||
}
|
||||
|
||||
if ($ConfigIssues.Count -gt 0) {
|
||||
$report += @"
|
||||
2️⃣ CONFIGURATION ISSUES:
|
||||
$(($ConfigIssues | ForEach-Object { "- $_" }) -join "`n")
|
||||
|
||||
"@
|
||||
}
|
||||
|
||||
if ($EnvironmentIssues.Count -gt 0) {
|
||||
$report += @"
|
||||
3️⃣ ENVIRONMENT ISSUES:
|
||||
$(($EnvironmentIssues | ForEach-Object { "- $_" }) -join "`n")
|
||||
|
||||
"@
|
||||
}
|
||||
|
||||
if ($BuildIssues.Count -gt 0) {
|
||||
$report += @"
|
||||
4️⃣ BUILD TEST ISSUES:
|
||||
$(($BuildIssues | ForEach-Object { "- $_" }) -join "`n")
|
||||
|
||||
"@
|
||||
}
|
||||
|
||||
$report += @"
|
||||
⚠️ BUILD MODE IS BLOCKED until these issues are resolved.
|
||||
Type 'VAN QA' after fixing the issues to re-validate.
|
||||
"@
|
||||
|
||||
# Save validation status (used by BUILD mode prevention mechanism)
|
||||
"FAIL" | Set-Content -Path "memory-bank\.qa_validation_status"
|
||||
|
||||
return $report
|
||||
}
|
||||
```
|
||||
|
||||
**Next Step (on SUCCESS):** Load `van-qa-utils/mode-transitions.mdc` to handle BUILD mode transition.
|
||||
**Next Step (on FAILURE):** Load `van-qa-utils/common-fixes.mdc` for issue remediation guidance.
|
||||
+66
@@ -0,0 +1,66 @@
|
||||
---
|
||||
description: Comprehensive guide for calling VAN QA rules
|
||||
globs: van-qa-utils/rule-calling-guide.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: COMPREHENSIVE RULE CALLING GUIDE
|
||||
|
||||
> **TL;DR:** This reference guide shows how to properly call all VAN QA rules at the right time during the validation process.
|
||||
|
||||
## 🔍 RULE CALLING BASICS
|
||||
|
||||
Remember these key principles:
|
||||
1. Always use the `fetch_rules` tool to load rules
|
||||
2. Use exact rule paths
|
||||
3. Load components only when needed
|
||||
|
||||
## 📋 MAIN QA ENTRY POINT
|
||||
|
||||
When user types "VAN QA", load the main entry point:
|
||||
|
||||
```
|
||||
fetch_rules with "isolation_rules/visual-maps/van-qa-main"
|
||||
```
|
||||
|
||||
## 📋 VALIDATION CHECKS
|
||||
|
||||
Load these components sequentially during validation:
|
||||
|
||||
```
|
||||
1. fetch_rules with "isolation_rules/visual-maps/van-qa-checks/dependency-check"
|
||||
2. fetch_rules with "isolation_rules/visual-maps/van-qa-checks/config-check"
|
||||
3. fetch_rules with "isolation_rules/visual-maps/van-qa-checks/environment-check"
|
||||
4. fetch_rules with "isolation_rules/visual-maps/van-qa-checks/build-test"
|
||||
```
|
||||
|
||||
## 📋 UTILITY COMPONENTS
|
||||
|
||||
Load these when needed based on validation results:
|
||||
|
||||
```
|
||||
- For reports: fetch_rules with "isolation_rules/visual-maps/van-qa-utils/reports"
|
||||
- For fixes: fetch_rules with "isolation_rules/visual-maps/van-qa-utils/common-fixes"
|
||||
- For transitions: fetch_rules with "isolation_rules/visual-maps/van-qa-utils/mode-transitions"
|
||||
```
|
||||
|
||||
## ⚠️ CRITICAL REMINDERS
|
||||
|
||||
Remember to call these rules at these specific points:
|
||||
- ALWAYS load the main QA entry point when "VAN QA" is typed
|
||||
- ALWAYS load dependency-check before starting validation
|
||||
- ALWAYS load reports after completing validation
|
||||
- ALWAYS load mode-transitions after successful validation
|
||||
- ALWAYS load common-fixes after failed validation
|
||||
|
||||
## 🔄 FULL VALIDATION SEQUENCE
|
||||
|
||||
Complete sequence for a QA validation process:
|
||||
|
||||
1. Load main entry: `isolation_rules/visual-maps/van-qa-main`
|
||||
2. Load first check: `isolation_rules/visual-maps/van-qa-checks/dependency-check`
|
||||
3. Load second check: `isolation_rules/visual-maps/van-qa-checks/config-check`
|
||||
4. Load third check: `isolation_rules/visual-maps/van-qa-checks/environment-check`
|
||||
5. Load fourth check: `isolation_rules/visual-maps/van-qa-checks/build-test`
|
||||
6. If pass, load: `isolation_rules/visual-maps/van-qa-utils/reports`
|
||||
7. If pass, load: `isolation_rules/visual-maps/van-qa-utils/mode-transitions`
|
||||
8. If fail, load: `isolation_rules/visual-maps/van-qa-utils/common-fixes`
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
---
|
||||
description: Utility for remembering how to call VAN QA rules
|
||||
globs: van-qa-utils/rule-calling-help.mdc
|
||||
alwaysApply: false
|
||||
---
|
||||
# VAN QA: HOW TO CALL RULES
|
||||
|
||||
> **TL;DR:** This file provides examples and reminders on how to properly call VAN QA rules using the fetch_rules tool.
|
||||
|
||||
## 🚨 RULE CALLING SYNTAX
|
||||
|
||||
Always use the `fetch_rules` tool with the correct syntax:
|
||||
|
||||
```
|
||||
<function_calls>
|
||||
<invoke name="fetch_rules">
|
||||
<parameter name="rule_names">["isolation_rules/visual-maps/rule-name"]
|
||||
</invoke>
|
||||
</function_calls>
|
||||
@@ -0,0 +1,363 @@
|
||||
# VAN MODE: QA TECHNICAL VALIDATION (Pre-BUILD)
|
||||
|
||||
> **TL;DR:** This map details the technical validation process executed *after* CREATIVE mode and *before* BUILD mode, triggered by the `VAN QA` command. It ensures dependencies, configuration, environment, and basic build functionality are sound.
|
||||
|
||||
## 🚀 VAN QA MODE ACTIVATION
|
||||
|
||||
After completing CREATIVE mode, when the user types "VAN QA", respond:
|
||||
|
||||
```
|
||||
User: VAN QA
|
||||
|
||||
Response: OK VAN QA - Beginning Technical Validation
|
||||
Loading QA Validation map...
|
||||
```
|
||||
|
||||
## 🔄 QA COMMAND PRECEDENCE (QA Override)
|
||||
|
||||
QA validation can be called at any point (`QA` command) and takes immediate precedence:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
UserQA["User Types: QA"] --> HighPriority["⚠️ HIGH PRIORITY COMMAND"]
|
||||
HighPriority --> CurrentTask["Pause Current Task/Process"]
|
||||
CurrentTask --> LoadQA["Load QA Validation Map (This File)"]
|
||||
LoadQA --> RunQA["Execute QA Validation Process"]
|
||||
RunQA --> QAResults{"QA Results"}
|
||||
|
||||
QAResults -->|"PASS"| ResumeFlow["Resume Prior Process Flow"]
|
||||
QAResults -->|"FAIL"| FixIssues["Fix Identified Issues"]
|
||||
FixIssues --> ReRunQA["Re-run QA Validation"]
|
||||
ReRunQA --> QAResults
|
||||
|
||||
style UserQA fill:#f8d486,stroke:#e8b84d,color:black
|
||||
style HighPriority fill:#ff0000,stroke:#cc0000,color:white,stroke-width:3px
|
||||
style LoadQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style RunQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style QAResults fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### QA Interruption Rules
|
||||
|
||||
1. **Immediate Precedence:** `QA` command interrupts everything.
|
||||
2. **Load & Execute:** Load this map (`van-qa-validation.mdc`) and run the full process.
|
||||
3. **Remediation Priority:** Fixes take priority over pending mode switches.
|
||||
4. **Resume:** On PASS, resume the previous flow.
|
||||
|
||||
```
|
||||
⚠️ QA OVERRIDE ACTIVATED
|
||||
All other processes paused
|
||||
QA validation checks now running...
|
||||
Any issues found MUST be remediated before continuing with normal process flow
|
||||
```
|
||||
|
||||
## 🔍 TECHNICAL VALIDATION OVERVIEW
|
||||
|
||||
Four-point validation process:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
VANQA["VAN QA MODE"] --> FourChecks["FOUR-POINT VALIDATION"]
|
||||
|
||||
FourChecks --> DepCheck["1️⃣ DEPENDENCY VERIFICATION"]
|
||||
DepCheck --> ConfigCheck["2️⃣ CONFIGURATION VALIDATION"]
|
||||
ConfigCheck --> EnvCheck["3️⃣ ENVIRONMENT VALIDATION"]
|
||||
EnvCheck --> MinBuildCheck["4️⃣ MINIMAL BUILD TEST"]
|
||||
|
||||
MinBuildCheck --> ValidationResults{"All Checks<br>Passed?"}
|
||||
ValidationResults -->|"Yes"| SuccessReport["GENERATE SUCCESS REPORT"]
|
||||
ValidationResults -->|"No"| FailureReport["GENERATE FAILURE REPORT"]
|
||||
|
||||
SuccessReport --> BUILD_Transition["Trigger BUILD Mode"]
|
||||
FailureReport --> FixIssues["Fix Technical Issues"]
|
||||
FixIssues --> ReValidate["Re-validate (Re-run VAN QA)"]
|
||||
ReValidate --> FourChecks
|
||||
|
||||
style VANQA fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style FourChecks fill:#f6546a,stroke:#c30052,color:white
|
||||
style ValidationResults fill:#f6546a,stroke:#c30052,color:white
|
||||
style BUILD_Transition fill:#10b981,stroke:#059669,color:white
|
||||
style FixIssues fill:#ff5555,stroke:#dd3333,color:white
|
||||
```
|
||||
|
||||
## 🔄 INTEGRATION WITH DESIGN DECISIONS
|
||||
|
||||
Reads Creative Phase outputs (e.g., `memory-bank/systemPatterns.md`) to inform validation:
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["Read Design Decisions"] --> ReadCreative["Parse Creative Phase<br>Documentation"]
|
||||
ReadCreative --> ExtractTech["Extract Technology<br>Choices"]
|
||||
ExtractTech --> ExtractDeps["Extract Required<br>Dependencies"]
|
||||
ExtractDeps --> BuildValidationPlan["Build Validation<br>Plan"]
|
||||
BuildValidationPlan --> StartValidation["Start Four-Point<br>Validation Process"]
|
||||
|
||||
style Start fill:#4da6ff,stroke:#0066cc,color:white
|
||||
style ExtractTech fill:#f6546a,stroke:#c30052,color:white
|
||||
style BuildValidationPlan fill:#10b981,stroke:#059669,color:white
|
||||
style StartValidation fill:#f6546a,stroke:#c30052,color:white
|
||||
```
|
||||
|
||||
### Example Technology Extraction (PowerShell):
|
||||
```powershell
|
||||
# Example: Extract technology choices from creative phase documentation
|
||||
function Extract-TechnologyChoices {
|
||||
$techChoices = @{}
|
||||
# Read from systemPatterns.md
|
||||
if (Test-Path "memory-bank\systemPatterns.md") {
|
||||
$content = Get-Content "memory-bank\systemPatterns.md" -Raw
|
||||
if ($content -match "Framework:\s*(\w+)") { $techChoices["framework"] = $Matches[1] }
|
||||
if ($content -match "UI Library:\s*(\w+)") { $techChoices["ui_library"] = $Matches[1] }
|
||||
if ($content -match "State Management:\s*([^\n]+)") { $techChoices["state_management"] = $Matches[1].Trim() }
|
||||
}
|
||||
return $techChoices
|
||||
}
|
||||
```
|
||||
|
||||
## 🔍 DETAILED QA VALIDATION STEPS & SCRIPTS
|
||||
|
||||
### 1️⃣ DEPENDENCY VERIFICATION
|
||||
|
||||
```mermaid
|
||||
# Mermaid graph for Dependency Verification (as in original file)
|
||||
graph TD
|
||||
Start["Dependency Verification"] --> ReadDeps["Read Required Dependencies<br>from Creative Phase"]
|
||||
ReadDeps --> CheckInstalled["Check if Dependencies<br>are Installed"]
|
||||
CheckInstalled --> DepStatus{"All Dependencies<br>Installed?"}
|
||||
DepStatus -->|"Yes"| VerifyVersions["Verify Versions<br>and Compatibility"]
|
||||
DepStatus -->|"No"| InstallMissing["Install Missing<br>Dependencies"]
|
||||
InstallMissing --> VerifyVersions
|
||||
VerifyVersions --> VersionStatus{"Versions<br>Compatible?"}
|
||||
VersionStatus -->|"Yes"| DepSuccess["Dependencies Verified<br>✅ PASS"]
|
||||
VersionStatus -->|"No"| UpgradeVersions["Upgrade/Downgrade<br>as Needed"]
|
||||
UpgradeVersions --> RetryVerify["Retry Verification"]
|
||||
RetryVerify --> VersionStatus
|
||||
style Start fill:#4da6ff; style DepSuccess fill:#10b981; style DepStatus fill:#f6546a; style VersionStatus fill:#f6546a;
|
||||
```
|
||||
|
||||
#### Example Implementation (PowerShell):
|
||||
```powershell
|
||||
# Verify-Dependencies function (as in original file)
|
||||
function Verify-Dependencies {
|
||||
$requiredDeps = @{ "node" = ">=14.0.0"; "npm" = ">=6.0.0" }
|
||||
$missingDeps = @(); $incompatibleDeps = @()
|
||||
try { $nodeVersion = node -v; if ($nodeVersion -match "v(\d+).*") { if ([int]$Matches[1] -lt 14) { $incompatibleDeps += "node" } } } catch { $missingDeps += "node" }
|
||||
try { $npmVersion = npm -v; if ($npmVersion -match "(\d+).*") { if ([int]$Matches[1] -lt 6) { $incompatibleDeps += "npm" } } } catch { $missingDeps += "npm" }
|
||||
if ($missingDeps.Count -eq 0 -and $incompatibleDeps.Count -eq 0) { Write-Output "✅ Deps OK"; return $true } else { Write-Output "❌ Deps FAIL"; return $false }
|
||||
}
|
||||
```
|
||||
|
||||
#### Example Implementation (Bash):
|
||||
```bash
|
||||
# verify_dependencies function (as in original file)
|
||||
verify_dependencies() {
|
||||
local missing_deps=(); local incompatible_deps=()
|
||||
if command -v node &> /dev/null; then node_version=$(node -v); if [[ $node_version =~ v([0-9]+) ]]; then if (( ${BASH_REMATCH[1]} < 14 )); then incompatible_deps+=("node"); fi; fi; else missing_deps+=("node"); fi
|
||||
if command -v npm &> /dev/null; then npm_version=$(npm -v); if [[ $npm_version =~ ([0-9]+) ]]; then if (( ${BASH_REMATCH[1]} < 6 )); then incompatible_deps+=("npm"); fi; fi; else missing_deps+=("npm"); fi
|
||||
if [ ${#missing_deps[@]} -eq 0 ] && [ ${#incompatible_deps[@]} -eq 0 ]; then echo "✅ Deps OK"; return 0; else echo "❌ Deps FAIL"; return 1; fi
|
||||
}
|
||||
```
|
||||
|
||||
### 2️⃣ CONFIGURATION VALIDATION
|
||||
|
||||
```mermaid
|
||||
# Mermaid graph for Configuration Validation (as in original file)
|
||||
graph TD
|
||||
Start["Configuration Validation"] --> IdentifyConfigs["Identify Files"]
|
||||
IdentifyConfigs --> ReadConfigs["Read Files"]
|
||||
ReadConfigs --> ValidateSyntax["Validate Syntax"]
|
||||
ValidateSyntax --> SyntaxStatus{"Valid?"}
|
||||
SyntaxStatus -->|"Yes"| CheckCompatibility["Check Compatibility"]
|
||||
SyntaxStatus -->|"No"| FixSyntax["Fix Syntax"]
|
||||
FixSyntax --> RetryValidate["Retry"]
|
||||
RetryValidate --> SyntaxStatus
|
||||
CheckCompatibility --> CompatStatus{"Compatible?"}
|
||||
CompatStatus -->|"Yes"| ConfigSuccess["Configs Validated ✅ PASS"]
|
||||
CompatStatus -->|"No"| AdaptConfigs["Adapt Configs"]
|
||||
AdaptConfigs --> RetryCompat["Retry Check"]
|
||||
RetryCompat --> CompatStatus
|
||||
style Start fill:#4da6ff; style ConfigSuccess fill:#10b981; style SyntaxStatus fill:#f6546a; style CompatStatus fill:#f6546a;
|
||||
```
|
||||
|
||||
#### Example Implementation (PowerShell):
|
||||
```powershell
|
||||
# Validate-Configurations function (as in original file)
|
||||
function Validate-Configurations {
|
||||
$configFiles = @("package.json", "tsconfig.json", "vite.config.js")
|
||||
$invalidConfigs = @(); $incompatibleConfigs = @()
|
||||
foreach ($configFile in $configFiles) {
|
||||
if (Test-Path $configFile) {
|
||||
if ($configFile -match "\.json$") { try { Get-Content $configFile -Raw | ConvertFrom-Json | Out-Null } catch { $invalidConfigs += "$configFile (JSON)"; continue } }
|
||||
if ($configFile -eq "vite.config.js") { $content = Get-Content $configFile -Raw; if ($content -notmatch "react\(\)") { $incompatibleConfigs += "$configFile (React)" } }
|
||||
} else { $invalidConfigs += "$configFile (missing)" }
|
||||
}
|
||||
if ($invalidConfigs.Count -eq 0 -and $incompatibleConfigs.Count -eq 0) { Write-Output "✅ Configs OK"; return $true } else { Write-Output "❌ Configs FAIL"; return $false }
|
||||
}
|
||||
```
|
||||
|
||||
### 3️⃣ ENVIRONMENT VALIDATION
|
||||
|
||||
```mermaid
|
||||
# Mermaid graph for Environment Validation (as in original file)
|
||||
graph TD
|
||||
Start["Environment Validation"] --> CheckEnv["Check Env"]
|
||||
CheckEnv --> VerifyBuildTools["Verify Tools"]
|
||||
VerifyBuildTools --> ToolsStatus{"Available?"}
|
||||
ToolsStatus -->|"Yes"| CheckPerms["Check Permissions"]
|
||||
ToolsStatus -->|"No"| InstallTools["Install Tools"]
|
||||
InstallTools --> RetryTools["Retry"]
|
||||
RetryTools --> ToolsStatus
|
||||
CheckPerms --> PermsStatus{"Sufficient?"}
|
||||
PermsStatus -->|"Yes"| EnvSuccess["Environment Validated ✅ PASS"]
|
||||
PermsStatus -->|"No"| FixPerms["Fix Permissions"]
|
||||
FixPerms --> RetryPerms["Retry Check"]
|
||||
RetryPerms --> PermsStatus
|
||||
style Start fill:#4da6ff; style EnvSuccess fill:#10b981; style ToolsStatus fill:#f6546a; style PermsStatus fill:#f6546a;
|
||||
```
|
||||
|
||||
#### Example Implementation (PowerShell):
|
||||
```powershell
|
||||
# Validate-Environment function (as in original file)
|
||||
function Validate-Environment {
|
||||
$requiredTools = @(@{Name='git';Cmd='git --version'},@{Name='node';Cmd='node --version'},@{Name='npm';Cmd='npm --version'})
|
||||
$missingTools = @(); $permissionIssues = @()
|
||||
foreach ($tool in $requiredTools) { try { Invoke-Expression $tool.Cmd | Out-Null } catch { $missingTools += $tool.Name } }
|
||||
try { $testFile = ".__perm_test"; New-Item $testFile -ItemType File -Force | Out-Null; Remove-Item $testFile -Force } catch { $permissionIssues += "CWD Write" }
|
||||
try { $L = New-Object Net.Sockets.TcpListener([Net.IPAddress]::Loopback, 3000); $L.Start(); $L.Stop() } catch { $permissionIssues += "Port 3000" }
|
||||
if ($missingTools.Count -eq 0 -and $permissionIssues.Count -eq 0) { Write-Output "✅ Env OK"; return $true } else { Write-Output "❌ Env FAIL"; return $false }
|
||||
}
|
||||
```
|
||||
|
||||
### 4️⃣ MINIMAL BUILD TEST
|
||||
|
||||
```mermaid
|
||||
# Mermaid graph for Minimal Build Test (as in original file)
|
||||
graph TD
|
||||
Start["Minimal Build Test"] --> CreateTest["Create Test Proj"]
|
||||
CreateTest --> BuildTest["Attempt Build"]
|
||||
BuildTest --> BuildStatus{"Success?"}
|
||||
BuildStatus -->|"Yes"| RunTest["Run Basic Test"]
|
||||
BuildStatus -->|"No"| FixBuild["Fix Build Issues"]
|
||||
FixBuild --> RetryBuild["Retry Build"]
|
||||
RetryBuild --> BuildStatus
|
||||
RunTest --> TestStatus{"Passed?"}
|
||||
TestStatus -->|"Yes"| TestSuccess["Build Test ✅ PASS"]
|
||||
TestStatus -->|"No"| FixTest["Fix Test Issues"]
|
||||
FixTest --> RetryTest["Retry Test"]
|
||||
RetryTest --> TestStatus
|
||||
style Start fill:#4da6ff; style TestSuccess fill:#10b981; style BuildStatus fill:#f6546a; style TestStatus fill:#f6546a;
|
||||
```
|
||||
|
||||
#### Example Implementation (PowerShell):
|
||||
```powershell
|
||||
# Perform-MinimalBuildTest function (as in original file)
|
||||
function Perform-MinimalBuildTest {
|
||||
$buildSuccess = $false; $testSuccess = $false; $testDir = ".__build_test"
|
||||
if (Test-Path $testDir) { Remove-Item $testDir -Recurse -Force }
|
||||
try {
|
||||
New-Item $testDir -ItemType Directory | Out-Null; Push-Location $testDir
|
||||
'{"name": "build-test","scripts": {"build": "echo Build test successful"}}' | Set-Content package.json
|
||||
npm run build | Out-Null; $buildSuccess = $true
|
||||
'console.log("Test successful");' | Set-Content index.js
|
||||
node index.js | Out-Null; $testSuccess = $true
|
||||
} catch { Write-Output "❌ Build test exception" } finally { Pop-Location; if (Test-Path $testDir) { Remove-Item $testDir -Recurse -Force } }
|
||||
if ($buildSuccess -and $testSuccess) { Write-Output "✅ Build Test OK"; return $true } else { Write-Output "❌ Build Test FAIL"; return $false }
|
||||
}
|
||||
```
|
||||
|
||||
## 📝 VALIDATION REPORT FORMATS
|
||||
|
||||
### Comprehensive Success Report:
|
||||
```
|
||||
╔═════════════════════ 🔍 QA VALIDATION REPORT ══════════════════════╗
|
||||
│ PROJECT: [Project Name] | TIMESTAMP: [Current Date/Time] │
|
||||
├─────────────────────────────────────────────────────────────────────┤
|
||||
│ 1️⃣ DEPENDENCIES: ✓ Compatible │
|
||||
│ 2️⃣ CONFIGURATION: ✓ Valid & Compatible │
|
||||
│ 3️⃣ ENVIRONMENT: ✓ Ready │
|
||||
│ 4️⃣ MINIMAL BUILD: ✓ Successful & Passed │
|
||||
├─────────────────────────────────────────────────────────────────────┤
|
||||
│ 🚨 FINAL VERDICT: PASS │
|
||||
│ ➡️ Clear to proceed to BUILD mode │
|
||||
╚═════════════════════════════════════════════════════════════════════╝
|
||||
```
|
||||
|
||||
### Detailed Failure Report:
|
||||
```
|
||||
⚠️⚠️⚠️ QA VALIDATION FAILED ⚠️⚠️⚠️
|
||||
Issues must be resolved before BUILD mode:
|
||||
|
||||
1️⃣ DEPENDENCY ISSUES: [Details/Fix]
|
||||
2️⃣ CONFIGURATION ISSUES: [Details/Fix]
|
||||
3️⃣ ENVIRONMENT ISSUES: [Details/Fix]
|
||||
4️⃣ BUILD TEST ISSUES: [Details/Fix]
|
||||
|
||||
⚠️ BUILD MODE BLOCKED. Type 'VAN QA' after fixing to re-validate.
|
||||
```
|
||||
|
||||
## 🧪 COMMON QA VALIDATION FIXES
|
||||
|
||||
- **Dependencies:** Install Node/npm, run `npm install`, check versions.
|
||||
- **Configuration:** Validate JSON, check required plugins (e.g., React for Vite), ensure TSConfig compatibility.
|
||||
- **Environment:** Check permissions (Admin/sudo), ensure ports are free, install missing CLI tools (git, etc.).
|
||||
- **Build Test:** Check logs for errors, verify minimal config, check path separators.
|
||||
|
||||
## 🔒 BUILD MODE PREVENTION MECHANISM
|
||||
|
||||
Logic to check QA status before allowing BUILD mode transition.
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
Start["User Types: BUILD"] --> CheckQA{"QA Validation<br>Passed?"}
|
||||
CheckQA -->|"Yes"| AllowBuild["Allow BUILD Mode"]
|
||||
CheckQA -->|"No"| BlockBuild["BLOCK BUILD MODE"]
|
||||
BlockBuild --> Message["Display:<br>⚠️ QA VALIDATION REQUIRED"]
|
||||
Message --> ReturnToVANQA["Prompt: Type VAN QA"]
|
||||
|
||||
style CheckQA fill:#f6546a; style BlockBuild fill:#ff0000,stroke:#990000; style Message fill:#ff5555; style ReturnToVANQA fill:#4da6ff;
|
||||
```
|
||||
|
||||
### Example Implementation (PowerShell):
|
||||
```powershell
|
||||
# Example: Check QA status before allowing BUILD
|
||||
function Check-QAValidationStatus {
|
||||
$qaStatusFile = "memory-bank\.qa_validation_status" # Assumes status is written here
|
||||
if (Test-Path $qaStatusFile) {
|
||||
if ((Get-Content $qaStatusFile -Raw) -match "PASS") { return $true }
|
||||
}
|
||||
Write-Output "🚫 BUILD MODE BLOCKED: QA VALIDATION REQUIRED. Type 'VAN QA'. 🚫"
|
||||
return $false
|
||||
}
|
||||
```
|
||||
|
||||
## 🚨 MODE TRANSITION TRIGGERS (Relevant to QA)
|
||||
|
||||
### CREATIVE to VAN QA Transition:
|
||||
```
|
||||
⏭️ NEXT MODE: VAN QA
|
||||
To validate technical requirements before implementation, please type 'VAN QA'
|
||||
```
|
||||
|
||||
### VAN QA to BUILD Transition (On Success):
|
||||
```
|
||||
✅ TECHNICAL VALIDATION COMPLETE
|
||||
All prerequisites verified successfully
|
||||
You may now proceed to BUILD mode
|
||||
Type 'BUILD' to begin implementation
|
||||
```
|
||||
|
||||
## 📋 FINAL QA VALIDATION CHECKPOINT
|
||||
|
||||
```
|
||||
✓ SECTION CHECKPOINT: QA VALIDATION
|
||||
- Dependency Verification Passed? [YES/NO]
|
||||
- Configuration Validation Passed? [YES/NO]
|
||||
- Environment Validation Passed? [YES/NO]
|
||||
- Minimal Build Test Passed? [YES/NO]
|
||||
|
||||
→ If all YES: Ready for BUILD mode transition.
|
||||
→ If any NO: Fix identified issues and re-run VAN QA.
|
||||
```
|
||||
|
||||
**Next Step (on PASS):** Trigger BUILD mode.
|
||||
**Next Step (on FAIL):** Address issues and re-run `VAN QA`.
|
||||
Reference in New Issue
Block a user