geminize 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c08ca1105b496592ec06cd7b7aab2b1b9a1dde2cb0f1c31be6feda85281683a2
-  data.tar.gz: ae7352a06b607dbd1e98cf30cd069551765156d088513a4cf780f94033d8ab89
+  metadata.gz: 1b3672d83fd6ff1d0a803808ee2c6d71681053229a84b3f33e0ea8b64b78dc74
+  data.tar.gz: 79eca877306a66edcf9dd6bfa3afc3dd1b1222c6127d4391cdc077944557a3bf
 SHA512:
-  metadata.gz: 9041ba768b03996f4b2a6fdd9d45dd9a1430298d6d555e54951a9736e24ac713397b1010ffb640bd3a3bcb5b647eb37d15193852e0df31cdfb9bafe6da6a6779
-  data.tar.gz: 3a99e5d5a7e2a7b1d3b8ac7d6ca3450a8a54dd4636b614fa53b4e6175e0ead68981ecb7390b00f9d6c7f5f4fd3bcb9bb44e46b84d9e97702cdca7803227fc022
+  metadata.gz: 81c4a2324a026449c00e983a2ad0f7e4e89e5d77564a62b6e7d430303eeeb129f32002f0c9a41055b4001044ec6272386ebba920e3e0565b8ac8c61f7bbc2d5d
+  data.tar.gz: 7aeb4afe504891c0849f83b04d3afc7b50fa45c1b60d6ae5ebcaea681b403e13c1bc86613694713162fff8ab220b0f447fedf808f0611fb0dbfb7476a2243148

data/.cursor/mcp.json

@@ -0,0 +1,3 @@
+{
+  "mcpServers": {}
+}

data/.cursor/rules/isolation_rules/Core/command-execution.mdc

@@ -0,0 +1,235 @@
+---
+description: Command execution guidelines for isolation-focused Memory Bank
+globs: command-execution.mdc
+alwaysApply: false
+---
+
+# COMMAND EXECUTION SYSTEM
+
+> **TL;DR:** This system provides guidelines for efficient command execution, balancing clarity and token optimization through appropriate command chaining, with proper documentation of commands and results.
+
+## 🔍 COMMAND EFFICIENCY WORKFLOW
+
+```mermaid
+graph TD
+    Start["Command<br>Planning"] --> Analyze["Analyze Command<br>Requirements"]
+    Analyze --> Balance["Balance Clarity<br>vs. Efficiency"]
+    Balance --> Complexity{"Command<br>Complexity?"}
+    
+    Complexity -->|"Simple"| Single["Execute<br>Single Command"]
+    Complexity -->|"Moderate"| Chain["Use Efficient<br>Command Chaining"]
+    Complexity -->|"Complex"| Group["Group Into<br>Logical Steps"]
+    
+    Single & Chain & Group --> Verify["Verify<br>Results"]
+    Verify --> Document["Document<br>Command & Result"]
+    Document --> Next["Next<br>Command"]
+```
+
+## 📋 COMMAND CHAINING GUIDELINES
+
+```mermaid
+graph TD
+    Command["Command<br>Execution"] --> ChainApprop{"Is Chaining<br>Appropriate?"}
+    
+    ChainApprop -->|"Yes"| ChainTypes["Chain<br>Types"]
+    ChainApprop -->|"No"| SingleCmd["Use Single<br>Commands"]
+    
+    ChainTypes --> Sequential["Sequential Operations<br>cmd1 && cmd2"]
+    ChainTypes --> Conditional["Conditional Operations<br>cmd1 || cmd2"]
+    ChainTypes --> Piping["Piping<br>cmd1 | cmd2"]
+    ChainTypes --> Grouping["Command Grouping<br>(cmd1; cmd2)"]
+    
+    Sequential & Conditional & Piping & Grouping --> Doc["Document<br>Commands & Results"]
+```
+
+## 🚦 DIRECTORY VERIFICATION WORKFLOW
+
+```mermaid
+graph TD
+    Command["Command<br>Execution"] --> DirCheck["Check Current<br>Directory"]
+    DirCheck --> ProjectRoot{"In Project<br>Root?"}
+    
+    ProjectRoot -->|"Yes"| Execute["Execute<br>Command"]
+    ProjectRoot -->|"No"| Locate["Locate<br>Project Root"]
+    
+    Locate --> Found{"Project Root<br>Found?"}
+    Found -->|"Yes"| Navigate["Navigate to<br>Project Root"]
+    Found -->|"No"| Error["Error: Cannot<br>Find Project Root"]
+    
+    Navigate --> Execute
+    Execute --> Verify["Verify<br>Results"]
+```
+
+## 📋 DIRECTORY VERIFICATION CHECKLIST
+
+Before executing any npm or build command:
+
+| Step | Windows (PowerShell) | Unix/Linux/Mac | Purpose |
+|------|----------------------|----------------|---------|
+| **Check package.json** | `Test-Path package.json` | `ls package.json` | Verify current directory is project root |
+| **Check for parent directory** | `Test-Path "*/package.json"` | `find . -maxdepth 2 -name package.json` | Find potential project directories |
+| **Navigate to project root** | `cd [project-dir]` | `cd [project-dir]` | Move to correct directory before executing commands |
+
+## 📋 REACT-SPECIFIC COMMAND GUIDELINES
+
+For React applications, follow these strict guidelines:
+
+| Command | Correct Usage | Incorrect Usage | Notes |
+|---------|---------------|----------------|-------|
+| **npm start** | `cd [project-root] && npm start` | `npm start` (from parent dir) | Must execute from directory with package.json |
+| **npm run build** | `cd [project-root] && npm run build` | `cd [parent-dir] && npm run build` | Must execute from directory with package.json |
+| **npm install** | `cd [project-root] && npm install [pkg]` | `npm install [pkg]` (wrong dir) | Dependencies installed to nearest package.json |
+| **npm create** | `npm create vite@latest my-app -- --template react` | Manually configuring webpack | Use standard tools for project creation |
+
+## 🔄 COMMAND CHAINING PATTERNS
+
+Effective command chaining patterns include:
+
+| Pattern | Format | Examples | Use Case |
+|---------|--------|----------|----------|
+| **Sequential** | `cmd1 && cmd2` | `mkdir dir && cd dir` | Commands that should run in sequence, second only if first succeeds |
+| **Conditional** | `cmd1 || cmd2` | `test -f file.txt || touch file.txt` | Fallback commands, second only if first fails |
+| **Piping** | `cmd1 \| cmd2` | `grep "pattern" file.txt \| wc -l` | Pass output of first command as input to second |
+| **Background** | `cmd &` | `npm start &` | Run command in background |
+| **Grouping** | `(cmd1; cmd2)` | `(echo "Start"; npm test; echo "End")` | Group commands to run as a unit |
+
+## 📋 COMMAND DOCUMENTATION TEMPLATE
+
+```
+## Command Execution: [Purpose]
+
+### Command
+```
+[actual command or chain]
+```
+
+### Result
+```
+[command output]
+```
+
+### Effect
+[Brief description of what changed in the system]
+
+### Next Steps
+[What needs to be done next]
+```
+
+## 🔍 PLATFORM-SPECIFIC CONSIDERATIONS
+
+```mermaid
+graph TD
+    Platform["Platform<br>Detection"] --> Windows["Windows<br>Commands"]
+    Platform --> Unix["Unix/Linux/Mac<br>Commands"]
+    
+    Windows --> WinAdapt["Windows Command<br>Adaptations"]
+    Unix --> UnixAdapt["Unix Command<br>Adaptations"]
+    
+    WinAdapt --> WinChain["Windows Chaining:<br>Commands separated by &"]
+    UnixAdapt --> UnixChain["Unix Chaining:<br>Commands separated by ;"]
+    
+    WinChain & UnixChain --> Execute["Execute<br>Platform-Specific<br>Commands"]
+```
+
+## 📋 COMMAND EFFICIENCY EXAMPLES
+
+Examples of efficient command usage:
+
+| Inefficient | Efficient | Explanation |
+|-------------|-----------|-------------|
+| `mkdir dir`<br>`cd dir`<br>`npm init -y` | `mkdir dir && cd dir && npm init -y` | Combines related sequential operations |
+| `ls`<br>`grep "\.js$"` | `ls \| grep "\.js$"` | Pipes output of first command to second |
+| `test -f file.txt`<br>`if not exists, touch file.txt` | `test -f file.txt \|\| touch file.txt` | Creates file only if it doesn't exist |
+| `mkdir dir1`<br>`mkdir dir2`<br>`mkdir dir3` | `mkdir dir1 dir2 dir3` | Uses command's built-in multiple argument capability |
+| `npm install pkg1`<br>`npm install pkg2` | `npm install pkg1 pkg2` | Installs multiple packages in one command |
+
+## 📋 REACT PROJECT INITIALIZATION STANDARDS
+
+Always use these standard approaches for React project creation:
+
+| Approach | Command | Benefits | Avoids |
+|----------|---------|----------|--------|
+| **Create React App** | `npx create-react-app my-app` | Preconfigured webpack & babel | Manual configuration errors |
+| **Create React App w/TypeScript** | `npx create-react-app my-app --template typescript` | Type safety + preconfigured | Inconsistent module systems |
+| **Vite** | `npm create vite@latest my-app -- --template react` | Faster build times | Complex webpack setups |
+| **Next.js** | `npx create-next-app@latest my-app` | SSR support | Module system conflicts |
+
+## ⚠️ ERROR HANDLING WORKFLOW
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant AI
+    participant System
+    
+    AI->>System: Execute Command
+    System->>AI: Return Result
+    
+    alt Success
+        AI->>AI: Verify Expected Result
+        AI->>User: Report Success
+    else Error
+        AI->>AI: Analyze Error Message
+        AI->>AI: Identify Likely Cause
+        AI->>User: Explain Error & Cause
+        AI->>User: Suggest Corrective Action
+        User->>AI: Approve Correction
+        AI->>System: Execute Corrected Command
+    end
+```
+
+## 📋 COMMAND RESULT VERIFICATION
+
+After command execution, verify:
+
+```mermaid
+graph TD
+    Execute["Execute<br>Command"] --> Check{"Check<br>Result"}
+    
+    Check -->|"Success"| Verify["Verify Expected<br>Outcome"]
+    Check -->|"Error"| Analyze["Analyze<br>Error"]
+    
+    Verify -->|"Expected"| Document["Document<br>Success"]
+    Verify -->|"Unexpected"| Investigate["Investigate<br>Unexpected Result"]
+    
+    Analyze --> Diagnose["Diagnose<br>Error Cause"]
+    Diagnose --> Correct["Propose<br>Correction"]
+    
+    Document & Investigate & Correct --> Next["Next Step<br>in Process"]
+```
+
+## 📝 COMMAND EXECUTION CHECKLIST
+
+```
+✓ COMMAND EXECUTION CHECKLIST
+- Command purpose clearly identified? [YES/NO]
+- Appropriate balance of clarity vs. efficiency? [YES/NO]
+- Platform-specific considerations addressed? [YES/NO]
+- Command documented with results? [YES/NO]
+- Outcome verified against expectations? [YES/NO]
+- Errors properly handled (if any)? [YES/NO/NA]
+- For npm/build commands: Executed from project root? [YES/NO/NA]
+- For React projects: Using standard tooling? [YES/NO/NA]
+
+→ If all YES: Command execution complete
+→ If any NO: Address missing elements
+```
+
+## 🚨 COMMAND EXECUTION WARNINGS
+
+Avoid these common command issues:
+
+```mermaid
+graph TD
+    Warning["Command<br>Warnings"] --> W1["Excessive<br>Verbosity"]
+    Warning --> W2["Insufficient<br>Error Handling"]
+    Warning --> W3["Unnecessary<br>Complexity"]
+    Warning --> W4["Destructive<br>Operations Without<br>Confirmation"]
+    Warning --> W5["Wrong Directory<br>Execution"]
+    
+    W1 --> S1["Use flags to reduce<br>unnecessary output"]
+    W2 --> S2["Include error handling<br>in command chains"]
+    W3 --> S3["Prefer built-in<br>command capabilities"]
+    W4 --> S4["Show confirmation<br>before destructive actions"]
+    W5 --> S5["Verify directory before<br>npm/build commands"]
+``` 

data/.cursor/rules/isolation_rules/Core/complexity-decision-tree.mdc

@@ -0,0 +1,187 @@
+---
+description: complexity decision tree
+globs: complexity-decision-tree.mdc
+alwaysApply: false
+---
+# TASK COMPLEXITY DETERMINATION
+
+> **TL;DR:** This document helps determine the appropriate complexity level (1-4) for any task. Use the decision tree and indicators to select the right process level, then load the corresponding process map.
+
+## 🌳 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
+    
+    L1 --> LoadL1["Load Level 1 Map"]
+    L2 --> LoadL2["Load Level 2 Map"]
+    L3 --> LoadL3["Load Level 3 Map"]
+    L4 --> LoadL4["Load Level 4 Map"]
+```
+
+## 📊 COMPLEXITY LEVEL INDICATORS
+
+Use these indicators to help determine task complexity:
+
+### Level 1: Quick Bug Fix
+- **Keywords**: "fix", "broken", "not working", "issue", "bug", "error", "crash"
+- **Scope**: Single component or UI element
+- **Duration**: Can be completed quickly (minutes to hours)
+- **Risk**: Low, isolated changes
+- **Examples**:
+  - Fix button not working
+  - Correct styling issue
+  - Fix validation error
+  - Resolve broken link
+  - Fix typo or text issue
+
+### Level 2: Simple Enhancement
+- **Keywords**: "add", "improve", "update", "change", "enhance", "modify"
+- **Scope**: Single component or subsystem
+- **Duration**: Hours to 1-2 days
+- **Risk**: Moderate, contained to specific area
+- **Examples**:
+  - Add form field
+  - Improve validation
+  - Update styling
+  - Add simple feature
+  - Change text content
+  - Enhance existing component
+
+### Level 3: Intermediate Feature
+- **Keywords**: "implement", "create", "develop", "build", "feature"
+- **Scope**: Multiple components, complete feature
+- **Duration**: Days to 1-2 weeks
+- **Risk**: Significant, affects multiple areas
+- **Examples**:
+  - Implement user authentication
+  - Create dashboard
+  - Develop search functionality
+  - Build user profile system
+  - Implement data visualization
+  - Create complex form system
+
+### Level 4: Complex System
+- **Keywords**: "system", "architecture", "redesign", "integration", "framework"
+- **Scope**: Multiple subsystems or entire application
+- **Duration**: Weeks to months
+- **Risk**: High, architectural implications
+- **Examples**:
+  - Implement authentication system
+  - Build payment processing framework
+  - Create microservice architecture
+  - Implement database migration system
+  - Develop real-time communication system
+  - Create multi-tenant architecture
+
+## 🔍 COMPLEXITY ASSESSMENT QUESTIONS
+
+Answer these questions to determine complexity:
+
+1. **Scope Impact**
+   - Does it affect a single component or multiple?
+   - Are there system-wide implications?
+   - How many files will need to be modified?
+
+2. **Design Decisions**
+   - Are complex design decisions required?
+   - Will it require creative phases for design?
+   - Are there architectural considerations?
+
+3. **Risk Assessment**
+   - What happens if it fails?
+   - Are there security implications?
+   - Will it affect critical functionality?
+
+4. **Implementation Effort**
+   - How long will it take to implement?
+   - Does it require specialized knowledge?
+   - Is extensive testing needed?
+
+## 📊 KEYWORD ANALYSIS TABLE
+
+| Keyword | Likely Level | Notes |
+|---------|--------------|-------|
+| "Fix" | Level 1 | Unless system-wide |
+| "Bug" | Level 1 | Unless multiple components |
+| "Error" | Level 1 | Unless architectural |
+| "Add" | Level 2 | Unless complex feature |
+| "Update" | Level 2 | Unless architectural |
+| "Improve" | Level 2 | Unless system-wide |
+| "Implement" | Level 3 | Complex components |
+| "Create" | Level 3 | New functionality |
+| "Develop" | Level 3 | Significant scope |
+| "System" | Level 4 | Architectural implications |
+| "Architecture" | Level 4 | Major structural changes |
+| "Framework" | Level 4 | Core infrastructure |
+
+## 🔄 COMPLEXITY ESCALATION
+
+If during a task you discover it's more complex than initially determined:
+
+```
+⚠️ TASK ESCALATION NEEDED
+Current Level: Level [X]
+Recommended Level: Level [Y]
+Reason: [Brief explanation]
+
+Would you like me to escalate this task to Level [Y]?
+```
+
+If approved, switch to the appropriate higher-level process map.
+
+## 🎯 PROCESS SELECTION
+
+After determining complexity, load the appropriate process map:
+
+| Level | Description | Process Map |
+|-------|-------------|-------------|
+| 1 | Quick Bug Fix | [Level 1 Map](mdc:.cursor/rules/visual-maps/level1-map.mdc) |
+| 2 | Simple Enhancement | [Level 2 Map](mdc:.cursor/rules/visual-maps/level2-map.mdc) |
+| 3 | Intermediate Feature | [Level 3 Map](mdc:.cursor/rules/visual-maps/level3-map.mdc) |
+| 4 | Complex System | [Level 4 Map](mdc:.cursor/rules/visual-maps/level4-map.mdc) |
+
+## 📝 COMPLEXITY DETERMINATION TEMPLATE
+
+Use this template to document complexity determination:
+
+```
+## COMPLEXITY DETERMINATION
+
+Task: [Task description]
+
+Assessment:
+- Scope: [Single component/Multiple components/System-wide]
+- Design decisions: [Simple/Moderate/Complex]
+- Risk: [Low/Moderate/High]
+- Implementation effort: [Low/Moderate/High]
+
+Keywords identified: [List relevant keywords]
+
+Determination: Level [1/2/3/4] - [Quick Bug Fix/Simple Enhancement/Intermediate Feature/Complex System]
+
+Loading process map: [Level X Map]
+```

data/.cursor/rules/isolation_rules/Core/creative-phase-enforcement.mdc

@@ -0,0 +1,145 @@
+---
+description: creative phase enforcement 
+globs: creative-phase-enforcement.md
+alwaysApply: false
+---
+
+# CREATIVE PHASE ENFORCEMENT
+
+> **TL;DR:** This document implements strict enforcement of creative phase requirements for Level 3-4 tasks, ensuring all design decisions are properly documented and verified before implementation can proceed.
+
+## 🔍 ENFORCEMENT WORKFLOW
+
+```mermaid
+graph TD
+    Start["Task Start"] --> Check{"Level 3-4<br>Task?"}
+    Check -->|Yes| Analyze["Analyze Design<br>Decision Points"]
+    Check -->|No| Optional["Creative Phase<br>Optional"]
+    
+    Analyze --> Decision{"Design Decisions<br>Required?"}
+    Decision -->|Yes| Gate["🚨 IMPLEMENTATION<br>BLOCKED"]
+    Decision -->|No| Allow["Allow<br>Implementation"]
+    
+    Gate --> Creative["Enter Creative<br>Phase"]
+    Creative --> Verify{"All Decisions<br>Documented?"}
+    Verify -->|No| Return["Return to<br>Creative Phase"]
+    Verify -->|Yes| Proceed["Allow<br>Implementation"]
+    
+    style Start fill:#4da6ff,stroke:#0066cc,color:white
+    style Check fill:#ffa64d,stroke:#cc7a30,color:white
+    style Analyze fill:#4dbb5f,stroke:#36873f,color:white
+    style Gate fill:#d94dbb,stroke:#a3378a,color:white
+    style Creative fill:#4dbbbb,stroke:#368787,color:white
+    style Verify fill:#d971ff,stroke:#a33bc2,color:white
+```
+
+## 🚨 ENFORCEMENT GATES
+
+```mermaid
+graph TD
+    subgraph "CREATIVE PHASE GATES"
+    G1["Entry Gate<br>Verify Requirements"]
+    G2["Process Gate<br>Verify Progress"]
+    G3["Exit Gate<br>Verify Completion"]
+    end
+    
+    G1 --> G2 --> G3
+    
+    style G1 fill:#4dbb5f,stroke:#36873f,color:white
+    style G2 fill:#ffa64d,stroke:#cc7a30,color:white
+    style G3 fill:#d94dbb,stroke:#a3378a,color:white
+```
+
+## 📋 ENFORCEMENT CHECKLIST
+
+```markdown
+## Entry Gate Verification
+- [ ] Task complexity is Level 3-4
+- [ ] Design decisions identified
+- [ ] Creative phase requirements documented
+- [ ] Required participants notified
+
+## Process Gate Verification
+- [ ] All options being considered
+- [ ] Pros/cons documented
+- [ ] Technical constraints identified
+- [ ] Implementation impacts assessed
+
+## Exit Gate Verification
+- [ ] All decisions documented
+- [ ] Rationale provided for choices
+- [ ] Implementation plan outlined
+- [ ] Verification against requirements
+```
+
+## 🚨 IMPLEMENTATION BLOCK NOTICE
+
+When a creative phase is required but not completed:
+
+```
+🚨 IMPLEMENTATION BLOCKED
+Creative phases MUST be completed before implementation.
+
+Required Creative Phases:
+- [ ] [Creative Phase 1]
+- [ ] [Creative Phase 2]
+- [ ] [Creative Phase 3]
+
+⛔ This is a HARD BLOCK
+Implementation CANNOT proceed until all creative phases are completed.
+Type "PHASE.REVIEW" to begin creative phase review.
+```
+
+## ✅ VERIFICATION PROTOCOL
+
+```mermaid
+graph TD
+    subgraph "VERIFICATION STEPS"
+    V1["1. Requirements<br>Check"]
+    V2["2. Documentation<br>Review"]
+    V3["3. Decision<br>Validation"]
+    V4["4. Implementation<br>Readiness"]
+    end
+    
+    V1 --> V2 --> V3 --> V4
+    
+    style V1 fill:#4dbb5f,stroke:#36873f,color:white
+    style V2 fill:#ffa64d,stroke:#cc7a30,color:white
+    style V3 fill:#d94dbb,stroke:#a3378a,color:white
+    style V4 fill:#4dbbbb,stroke:#368787,color:white
+```
+
+## 🔄 CREATIVE PHASE MARKERS
+
+Use these markers to clearly indicate creative phase boundaries:
+
+```markdown
+🎨🎨🎨 ENTERING CREATIVE PHASE: [TYPE] 🎨🎨🎨
+Focus: [Specific component/feature]
+Objective: [Clear goal of this creative phase]
+Requirements: [List of requirements]
+
+[Creative phase content]
+
+🎨 CREATIVE CHECKPOINT: [Milestone]
+- Progress: [Status]
+- Decisions: [List]
+- Next steps: [Plan]
+
+🎨🎨🎨 EXITING CREATIVE PHASE 🎨🎨🎨
+Summary: [Brief description]
+Key Decisions: [List]
+Next Steps: [Implementation plan]
+```
+
+## 🔄 DOCUMENT MANAGEMENT
+
+```mermaid
+graph TD
+    Current["Current Document"] --> Active["Active:<br>- creative-phase-enforcement.md"]
+    Current --> Related["Related:<br>- creative-phase-architecture.md<br>- task-tracking-intermediate.md"]
+    
+    style Current fill:#4da6ff,stroke:#0066cc,color:white
+    style Active fill:#4dbb5f,stroke:#36873f,color:white
+    style Related fill:#ffa64d,stroke:#cc7a30,color:white
+```