odoo-forge-bundle 0.1.0 → 0.1.1

package/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "odoo-forge-bundle",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "status": "scaffold",
   "payload": {
     "root": "./payload",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "odoo-forge-bundle",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Generated bundle payload for Odoo Forge internal 1.0.",
   "type": "module",
   "exports": "./index.js",

package/payload/config/product.json

@@ -1,7 +1,7 @@
 {
   "name": "Odoo Forge",
   "slug": "odoo-forge",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Unified Odoo agent toolkit for Codex and Claude Code.",
   "localInstallRoot": "~/.odoo-forge",
   "packages": {

package/payload/platforms/claude/plugin.template.json

@@ -1,6 +1,6 @@
 {
   "name": "odoo-forge",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Internal Odoo Forge plugin for Claude Code.",
   "author": {
     "name": "Internal Team"

package/payload/platforms/codex/plugin.template.json

@@ -1,6 +1,6 @@
 {
   "name": "odoo-forge",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Odoo skill suite for Codex and Claude Code.",
   "skills": "./skills",
   "mcpServers": "./.mcp.json",

package/payload/skills/mermaid-diagrams/README.md

@@ -0,0 +1,244 @@
+# Mermaid Diagrams Skill
+
+A comprehensive guide for creating professional software diagrams using Mermaid's text-based syntax. This skill enables you to visualize system architecture, document code structure, model databases, and communicate technical concepts through diagrams.
+
+## Purpose
+
+Transform complex technical concepts into clear, maintainable diagrams that can be version-controlled alongside your code. Mermaid diagrams are rendered from simple text definitions, making them easy to update, review in pull requests, and maintain over time.
+
+## When to Use This Skill
+
+Use this skill when you need to:
+
+- **Document architecture** - Visualize system context, containers, components, and deployment
+- **Model domains** - Create domain models with entities, relationships, and behaviors
+- **Explain flows** - Show API interactions, user journeys, authentication sequences
+- **Design databases** - Document table relationships, keys, and schema structure
+- **Plan processes** - Map workflows, decision trees, algorithms, and pipelines
+- **Communicate designs** - Align stakeholders on technical decisions before coding
+
+### Trigger Phrases
+
+The skill activates when you mention:
+- "diagram", "visualize", "model", "map out", "show the flow"
+- "architecture diagram", "class diagram", "sequence diagram", "flowchart"
+- "database schema", "ERD", "entity relationship"
+- "system design", "data model", "domain model"
+
+## How It Works
+
+1. **Choose the right diagram type** based on what you want to communicate
+2. **Start with core elements** - entities, actors, or components
+3. **Add relationships** - connections, flows, interactions
+4. **Refine incrementally** - add details, styling, notes
+5. **Export or embed** - use in documentation, PRs, wikis
+
+Mermaid syntax is intuitive and follows a consistent pattern across all diagram types:
+
+```mermaid
+diagramType
+  definition content
+```
+
+## Key Features
+
+### 9 Diagram Types Supported
+
+1. **Class Diagrams** - Domain models, OOP design, entity relationships
+2. **Sequence Diagrams** - API flows, user interactions, temporal sequences
+3. **Flowcharts** - User journeys, processes, decision logic, pipelines
+4. **Entity Relationship Diagrams** - Database schemas, table relationships
+5. **C4 Architecture Diagrams** - System context, containers, components
+6. **State Diagrams** - State machines, lifecycle states
+7. **Git Graphs** - Branching strategies, version control flows
+8. **Gantt Charts** - Project timelines, scheduling
+9. **Pie/Bar Charts** - Data visualization, metrics
+
+### Advanced Capabilities
+
+- **Themes and styling** - Default, forest, dark, neutral, base themes
+- **Custom theming** - Configure colors, fonts, and layout
+- **Layout options** - Dagre (balanced) or ELK (advanced)
+- **Look options** - Classic or hand-drawn sketch style
+- **Subgraphs** - Group related elements for clarity
+- **Notes and comments** - Add context and explanations
+- **Alt/loop/opt blocks** - Complex flow control in sequences
+
+### Integration Support
+
+- **GitHub/GitLab** - Automatic rendering in Markdown files
+- **VS Code** - Preview with Markdown Mermaid extension
+- **Notion, Obsidian, Confluence** - Built-in support
+- **Export** - PNG, SVG, PDF via Mermaid Live or CLI
+
+## Usage Examples
+
+### Example 1: Document a Domain Model
+
+**When:** You're designing a video streaming platform and need to model core entities.
+
+```mermaid
+classDiagram
+    Title -- Genre
+    Title *-- Season
+    Title *-- Review
+    User --> Review : creates
+
+    class Title {
+        +string name
+        +int releaseYear
+        +play()
+    }
+
+    class Genre {
+        +string name
+        +getTopTitles()
+    }
+```
+
+### Example 2: Explain an API Authentication Flow
+
+**When:** You need to document how login works for frontend developers.
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant API
+    participant Database
+
+    User->>API: POST /login
+    API->>Database: Query credentials
+    Database-->>API: Return user data
+    alt Valid credentials
+        API-->>User: 200 OK + JWT token
+    else Invalid credentials
+        API-->>User: 401 Unauthorized
+    end
+```
+
+### Example 3: Map a User Journey
+
+**When:** You're planning a feature and need to visualize the user flow.
+
+```mermaid
+flowchart TD
+    Start([User visits site]) --> Auth{Authenticated?}
+    Auth -->|No| Login[Show login page]
+    Auth -->|Yes| Dashboard[Show dashboard]
+    Login --> Creds[Enter credentials]
+    Creds --> Validate{Valid?}
+    Validate -->|Yes| Dashboard
+    Validate -->|No| Error[Show error]
+    Error --> Login
+```
+
+### Example 4: Design a Database Schema
+
+**When:** You're planning table relationships for a new feature.
+
+```mermaid
+erDiagram
+    USER ||--o{ ORDER : places
+    ORDER ||--|{ LINE_ITEM : contains
+    PRODUCT ||--o{ LINE_ITEM : includes
+
+    USER {
+        int id PK
+        string email UK
+        string name
+        datetime created_at
+    }
+
+    ORDER {
+        int id PK
+        int user_id FK
+        decimal total
+        datetime created_at
+    }
+```
+
+### Example 5: Visualize System Architecture (C4)
+
+**When:** You need to show how systems and external services interact.
+
+```mermaid
+C4Context
+    title System Context Diagram for E-commerce Platform
+
+    Person(customer, "Customer", "A user browsing and purchasing products")
+    System(webApp, "Web Application", "Provides product catalog and checkout")
+    System_Ext(payment, "Payment Gateway", "Processes payments")
+    System_Ext(email, "Email Service", "Sends order confirmations")
+
+    Rel(customer, webApp, "Browses products, places orders")
+    Rel(webApp, payment, "Processes payments", "HTTPS")
+    Rel(webApp, email, "Sends notifications", "SMTP")
+```
+
+## Getting Started
+
+1. **Identify what you need to communicate** - Architecture? Flow? Data model?
+2. **Choose the appropriate diagram type** - See "Diagram Type Selection Guide" in SKILL.md
+3. **Start simple** - Add core entities/components first
+4. **Add relationships** - Connect elements with appropriate connectors
+5. **Refine and style** - Add details, notes, and custom theming
+6. **Validate** - Test in [Mermaid Live Editor](https://mermaid.live)
+7. **Embed or export** - Use in Markdown, export as image, or integrate
+
+## Detailed References
+
+For comprehensive syntax and advanced features, see:
+
+- **[SKILL.md](SKILL.md)** - Quick start guide and diagram selection
+- **[references/class-diagrams.md](references/class-diagrams.md)** - Relationships, multiplicity, methods
+- **[references/sequence-diagrams.md](references/sequence-diagrams.md)** - Messages, activations, loops, alt blocks
+- **[references/flowcharts.md](references/flowcharts.md)** - Node shapes, decision logic, subgraphs
+- **[references/erd-diagrams.md](references/erd-diagrams.md)** - Cardinality, keys, attributes
+- **[references/c4-diagrams.md](references/c4-diagrams.md)** - Context, container, component levels
+- **[references/architecture-diagrams.md](references/architecture-diagrams.md)** - Cloud services, infrastructure, CI/CD deployments
+- **[references/advanced-features.md](references/advanced-features.md)** - Themes, styling, configuration
+
+## Best Practices
+
+1. **Start simple, iterate** - Begin with core elements, add complexity gradually
+2. **One diagram, one concept** - Keep diagrams focused and split large views
+3. **Use meaningful names** - Clear labels make diagrams self-documenting
+4. **Comment liberally** - Use `%%` to explain non-obvious relationships
+5. **Version control** - Store `.mmd` files with code, update as system evolves
+6. **Add context** - Include titles and notes explaining diagram purpose
+7. **Validate syntax** - Test in Mermaid Live before committing
+8. **Keep it readable** - Don't overcrowd; split into multiple diagrams if needed
+
+## Common Use Cases
+
+- **Onboarding** - Help new team members understand system structure
+- **Design reviews** - Visualize proposals before implementation
+- **Documentation** - Create living docs that evolve with code
+- **Architecture decisions** - Align stakeholders on technical choices
+- **Refactoring** - Plan restructuring with before/after diagrams
+- **API handoffs** - Document flows for frontend/backend coordination
+- **Database migrations** - Visualize schema changes
+
+## Tips for Success
+
+- **Test incrementally** - Validate syntax as you build to catch errors early
+- **Use consistent naming** - Match diagram names to code/database names
+- **Leverage GitHub rendering** - Diagrams appear automatically in `.md` files
+- **Export for presentations** - Use Mermaid Live or CLI for high-res exports
+- **Collaborate** - Diagrams are great for PR discussions and design docs
+- **Keep updated** - Update diagrams when code changes to prevent drift
+
+## Tools and Resources
+
+- **[Mermaid Live Editor](https://mermaid.live)** - Interactive editor with instant preview and export
+- **[Official Documentation](https://mermaid.js.org)** - Comprehensive syntax reference
+- **Mermaid CLI** - `npm install -g @mermaid-js/mermaid-cli` for batch exports
+- **VS Code Extension** - "Markdown Preview Mermaid Support" for live preview
+- **GitHub** - Native rendering in all `.md` files
+
+## Support
+
+For questions, syntax help, or advanced features, refer to:
+- SKILL.md for quick reference
+- Reference files in `references/` for detailed syntax
+- [Mermaid official docs](https://mermaid.js.org) for latest features

package/payload/skills/mermaid-diagrams/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: mermaid-diagrams
+description: Use when users need to create, visualize, or document software with Mermaid diagrams such as class diagrams, sequence diagrams, flowcharts, ERDs, C4 architecture diagrams, state diagrams, git graphs, gantt charts, pie charts, or similar technical visuals, especially when discussing architecture, database design, code structure, or user and system flows.
+---
+
+# Mermaid Diagramming
+
+Create professional software diagrams using Mermaid's text-based syntax. Mermaid renders diagrams from simple text definitions, making diagrams version-controllable, easy to update, and maintainable alongside code.
+
+## Core Syntax Structure
+
+All Mermaid diagrams follow this pattern:
+
+```mermaid
+diagramType
+  definition content
+```
+
+**Key principles:**
+- First line declares diagram type (e.g., `classDiagram`, `sequenceDiagram`, `flowchart`)
+- Use `%%` for comments
+- Line breaks and indentation improve readability but aren't required
+- Unknown words break diagrams; parameters fail silently
+
+## Diagram Type Selection Guide
+
+**Choose the right diagram type:**
+
+1. **Class Diagrams** - Domain modeling, OOP design, entity relationships
+   - Domain-driven design documentation
+   - Object-oriented class structures
+   - Entity relationships and dependencies
+
+2. **Sequence Diagrams** - Temporal interactions, message flows
+   - API request/response flows
+   - User authentication flows
+   - System component interactions
+   - Method call sequences
+
+3. **Flowcharts** - Processes, algorithms, decision trees
+   - User journeys and workflows
+   - Business processes
+   - Algorithm logic
+   - Deployment pipelines
+
+4. **Entity Relationship Diagrams (ERD)** - Database schemas
+   - Table relationships
+   - Data modeling
+   - Schema design
+
+5. **C4 Diagrams** - Software architecture at multiple levels
+   - System Context (systems and users)
+   - Container (applications, databases, services)
+   - Component (internal structure)
+   - Code (class/interface level)
+
+6. **State Diagrams** - State machines, lifecycle states
+7. **Git Graphs** - Version control branching strategies
+8. **Gantt Charts** - Project timelines, scheduling
+9. **Pie/Bar Charts** - Data visualization
+
+## Quick Start Examples
+
+### Class Diagram (Domain Model)
+```mermaid
+classDiagram
+    Title -- Genre
+    Title *-- Season
+    Title *-- Review
+    User --> Review : creates
+
+    class Title {
+        +string name
+        +int releaseYear
+        +play()
+    }
+
+    class Genre {
+        +string name
+        +getTopTitles()
+    }
+```
+
+### Sequence Diagram (API Flow)
+```mermaid
+sequenceDiagram
+    participant User
+    participant API
+    participant Database
+
+    User->>API: POST /login
+    API->>Database: Query credentials
+    Database-->>API: Return user data
+    alt Valid credentials
+        API-->>User: 200 OK + JWT token
+    else Invalid credentials
+        API-->>User: 401 Unauthorized
+    end
+```
+
+### Flowchart (User Journey)
+```mermaid
+flowchart TD
+    Start([User visits site]) --> Auth{Authenticated?}
+    Auth -->|No| Login[Show login page]
+    Auth -->|Yes| Dashboard[Show dashboard]
+    Login --> Creds[Enter credentials]
+    Creds --> Validate{Valid?}
+    Validate -->|Yes| Dashboard
+    Validate -->|No| Error[Show error]
+    Error --> Login
+```
+
+### ERD (Database Schema)
+```mermaid
+erDiagram
+    USER ||--o{ ORDER : places
+    ORDER ||--|{ LINE_ITEM : contains
+    PRODUCT ||--o{ LINE_ITEM : includes
+
+    USER {
+        int id PK
+        string email UK
+        string name
+        datetime created_at
+    }
+
+    ORDER {
+        int id PK
+        int user_id FK
+        decimal total
+        datetime created_at
+    }
+```
+
+## Detailed References
+
+For in-depth guidance on specific diagram types, see:
+
+- **[references/class-diagrams.md](references/class-diagrams.md)** - Domain modeling, relationships (association, composition, aggregation, inheritance), multiplicity, methods/properties
+- **[references/sequence-diagrams.md](references/sequence-diagrams.md)** - Actors, participants, messages (sync/async), activations, loops, alt/opt/par blocks, notes
+- **[references/flowcharts.md](references/flowcharts.md)** - Node shapes, connections, decision logic, subgraphs, styling
+- **[references/erd-diagrams.md](references/erd-diagrams.md)** - Entities, relationships, cardinality, keys, attributes
+- **[references/c4-diagrams.md](references/c4-diagrams.md)** - System context, container, component diagrams, boundaries
+- **[references/architecture-diagrams.md](references/architecture-diagrams.md)** - Cloud services, infrastructure, CI/CD deployments
+- **[references/advanced-features.md](references/advanced-features.md)** - Themes, styling, configuration, layout options
+
+## Best Practices
+
+1. **Start Simple** - Begin with core entities/components, add details incrementally
+2. **Use Meaningful Names** - Clear labels make diagrams self-documenting
+3. **Comment Extensively** - Use `%%` comments to explain complex relationships
+4. **Keep Focused** - One diagram per concept; split large diagrams into multiple focused views
+5. **Version Control** - Store `.mmd` files alongside code for easy updates
+6. **Add Context** - Include titles and notes to explain diagram purpose
+7. **Iterate** - Refine diagrams as understanding evolves
+
+## Configuration and Theming
+
+Configure diagrams using frontmatter:
+
+```mermaid
+---
+config:
+  theme: base
+  themeVariables:
+    primaryColor: "#ff6b6b"
+---
+flowchart LR
+    A --> B
+```
+
+**Available themes:** default, forest, dark, neutral, base
+
+**Layout options:**
+- `layout: dagre` (default) - Classic balanced layout
+- `layout: elk` - Advanced layout for complex diagrams (requires integration)
+
+**Look options:**
+- `look: classic` - Traditional Mermaid style
+- `look: handDrawn` - Sketch-like appearance
+
+## Exporting and Rendering
+
+**Native support in:**
+- GitHub/GitLab - Automatically renders in Markdown
+- VS Code - With Markdown Mermaid extension
+- Notion, Obsidian, Confluence - Built-in support
+
+**Export options:**
+- [Mermaid Live Editor](https://mermaid.live) - Online editor with PNG/SVG export
+- Mermaid CLI - `npm install -g @mermaid-js/mermaid-cli` then `mmdc -i input.mmd -o output.png`
+- Docker - `docker run --rm -v $(pwd):/data minlag/mermaid-cli -i /data/input.mmd -o /data/output.png`
+
+## Common Pitfalls
+
+- **Breaking characters** - Avoid `{}` in comments, use proper escape sequences for special characters
+- **Syntax errors** - Misspellings break diagrams; validate syntax in Mermaid Live
+- **Overcomplexity** - Split complex diagrams into multiple focused views
+- **Missing relationships** - Document all important connections between entities
+
+## When to Create Diagrams
+
+**Always diagram when:**
+- Starting new projects or features
+- Documenting complex systems
+- Explaining architecture decisions
+- Designing database schemas
+- Planning refactoring efforts
+- Onboarding new team members
+
+**Use diagrams to:**
+- Align stakeholders on technical decisions
+- Document domain models collaboratively
+- Visualize data flows and system interactions
+- Plan before coding
+- Create living documentation that evolves with code