geminize 1.0.0 → 1.2.0

data/.cursor/rules/isolation_rules/visual-maps/implement-mode-map.mdc

@@ -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
+``` 

data/.cursor/rules/isolation_rules/visual-maps/plan-mode-map.mdc

@@ -0,0 +1,269 @@
+# 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"| RecImplement["NEXT MODE:<br>IMPLEMENT 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/IMPLEMENT] MODE