@onion-architect-ai/cli 4.1.0-beta.1 → 4.1.0-beta.3

package/templates/.cursor/docs/c4/c4-mermaid-patterns.md

@@ -0,0 +1,331 @@
+# 🎭 C4 Mermaid Patterns - Sistema Onion
+
+## 📋 **Mermaid C4 Syntax Reference**
+
+Padrões específicos para geração de diagramas C4 em Mermaid, focados em compatibilidade GitHub.
+
+---
+
+## 🎨 **Context Diagram Patterns**
+
+### **Basic Context Pattern**
+```mermaid
+C4Context
+    title System Context diagram for [System Name]
+    
+    Person(user, "User", "Primary system user")
+    System(main_system, "Main System", "Core application system")
+    System_Ext(external, "External System", "Third-party service")
+    
+    Rel(user, main_system, "Uses", "HTTPS")
+    Rel(main_system, external, "Integrates with", "API/HTTPS")
+```
+
+### **Multi-User Context Pattern**
+```mermaid
+C4Context
+    title System Context - Multi-User Application
+    
+    Person(end_user, "End User", "Application end user")
+    Person(admin, "Administrator", "System administrator")
+    Person(dev, "Developer", "Development team member")
+    
+    System(app_system, "Application System", "Main application")
+    System_Ext(auth_service, "Auth Service", "Authentication provider")
+    SystemDb_Ext(analytics, "Analytics", "Usage analytics service")
+    
+    Rel(end_user, app_system, "Uses application", "HTTPS")
+    Rel(admin, app_system, "Administers", "HTTPS/Admin Panel")
+    Rel(dev, app_system, "Develops & deploys", "CI/CD")
+    Rel(app_system, auth_service, "Authenticates users", "OAuth/JWT")
+    Rel(app_system, analytics, "Sends events", "HTTPS/Events API")
+```
+
+### **Microservices Context Pattern**
+```mermaid
+C4Context
+    title System Context - Microservices Architecture
+    
+    Person(user, "User", "System user")
+    
+    System_Boundary(microservices, "Microservices Ecosystem") {
+        System(api_gateway, "API Gateway", "Request routing & authentication")
+        System(service_a, "Service A", "Domain-specific service")
+        System(service_b, "Service B", "Domain-specific service")
+    }
+    
+    System_Ext(database, "Database Cluster", "Distributed data storage")
+    System_Ext(message_broker, "Message Broker", "Event streaming")
+    
+    Rel(user, api_gateway, "API requests", "HTTPS/REST")
+    Rel(api_gateway, service_a, "Routes requests", "HTTP")
+    Rel(api_gateway, service_b, "Routes requests", "HTTP")
+    Rel(service_a, database, "Persists data", "SQL")
+    Rel(service_b, database, "Persists data", "SQL")
+    Rel(service_a, message_broker, "Publishes events", "Message Queue")
+    Rel(service_b, message_broker, "Consumes events", "Message Queue")
+```
+
+---
+
+## 🏗️ **Container Diagram Patterns**
+
+### **Web Application Container Pattern**
+```mermaid
+C4Container
+    title Container diagram for Web Application
+    
+    Person(user, "User")
+    
+    Container_Boundary(web_app, "Web Application") {
+        Container(spa, "Single Page App", "React/TypeScript", "User interface")
+        Container(api, "API Server", "Node.js/Express", "Business logic & API")
+        Container(bg_jobs, "Background Jobs", "Node.js/Queue", "Async processing")
+    }
+    
+    ContainerDb(database, "Database", "PostgreSQL", "Application data")
+    ContainerDb(cache, "Cache", "Redis", "Session & temporary data")
+    Container_Ext(cdn, "CDN", "CloudFront", "Static assets")
+    
+    Rel(user, spa, "Uses", "HTTPS")
+    Rel(spa, cdn, "Loads assets", "HTTPS")
+    Rel(spa, api, "API calls", "JSON/HTTPS")
+    Rel(api, database, "Reads/Writes", "SQL")
+    Rel(api, cache, "Caches data", "Redis Protocol")
+    Rel(api, bg_jobs, "Enqueues tasks", "Message Queue")
+    Rel(bg_jobs, database, "Updates data", "SQL")
+```
+
+### **Monorepo Container Pattern**
+```mermaid
+C4Container
+    title Container diagram for NX Monorepo
+    
+    Person(developer, "Developer")
+    Person(user, "End User")
+    
+    Container_Boundary(nx_workspace, "NX Monorepo Workspace") {
+        Container(web_app, "Web App", "React", "Main user application")
+        Container(admin_app, "Admin App", "React", "Administrative interface")
+        Container(mobile_app, "Mobile App", "React Native", "Mobile application")
+        Container(api_service, "API Service", "NestJS", "Backend API")
+        Container(shared_libs, "Shared Libraries", "TypeScript", "Common utilities")
+    }
+    
+    ContainerDb(database, "Database", "PostgreSQL", "Application data")
+    Container_Ext(registry, "Package Registry", "npm/private", "Package distribution")
+    
+    Rel(developer, nx_workspace, "Develops", "NX CLI")
+    Rel(user, web_app, "Uses", "HTTPS")
+    Rel(user, mobile_app, "Uses", "Mobile App")
+    Rel(web_app, shared_libs, "Imports", "ES Modules")
+    Rel(admin_app, shared_libs, "Imports", "ES Modules")
+    Rel(mobile_app, shared_libs, "Imports", "ES Modules")
+    Rel(api_service, shared_libs, "Imports", "ES Modules")
+    Rel(web_app, api_service, "API calls", "HTTPS/REST")
+    Rel(admin_app, api_service, "API calls", "HTTPS/REST")
+    Rel(mobile_app, api_service, "API calls", "HTTPS/REST")
+    Rel(api_service, database, "Persists data", "SQL")
+    Rel(shared_libs, registry, "Published to", "npm publish")
+```
+
+### **Full-stack Container Pattern**
+```mermaid
+C4Container
+    title Container diagram for Next.js Full-stack Application
+    
+    Person(user, "User")
+    
+    Container_Boundary(nextjs_app, "Next.js Application") {
+        Container(frontend, "Frontend", "React/Next.js", "User interface & pages")
+        Container(api_routes, "API Routes", "Next.js API", "Backend API endpoints")
+        Container(middleware, "Middleware", "Next.js Middleware", "Auth & routing logic")
+    }
+    
+    ContainerDb(database, "Database", "PostgreSQL", "Application data")
+    Container_Ext(cdn, "CDN", "Vercel CDN", "Static assets & ISR")
+    Container_Ext(auth_provider, "Auth Provider", "NextAuth.js", "Authentication")
+    
+    Rel(user, frontend, "Visits pages", "HTTPS")
+    Rel(user, cdn, "Loads static content", "HTTPS")
+    Rel(frontend, middleware, "Auth checks", "Server-side")
+    Rel(frontend, api_routes, "API calls", "HTTP/Internal")
+    Rel(middleware, auth_provider, "Validates auth", "OAuth")
+    Rel(api_routes, database, "Data operations", "SQL")
+    Rel(cdn, frontend, "Serves ISR content", "HTTP")
+```
+
+---
+
+## 🧩 **Component Diagram Patterns**
+
+### **React Component Structure Pattern**
+```mermaid
+C4Component
+    title Component diagram for React Frontend
+    
+    Container(frontend, "Frontend Container", "React")
+    
+    Component(app, "App Component", "React", "Root application component")
+    Component(router, "Router", "React Router", "Client-side routing")
+    Component(pages, "Page Components", "React", "Route-specific pages")
+    Component(layout, "Layout Components", "React", "Common layout structures")
+    Component(ui_components, "UI Components", "React", "Reusable UI elements")
+    Component(hooks, "Custom Hooks", "React Hooks", "Business logic abstraction")
+    Component(context, "Context Providers", "React Context", "Global state management")
+    Component(services, "API Services", "TypeScript", "HTTP client abstractions")
+    Component(utils, "Utilities", "TypeScript", "Helper functions")
+    Component(constants, "Constants", "TypeScript", "Configuration & constants")
+    
+    Rel(app, router, "Configures routes")
+    Rel(app, context, "Provides global state")
+    Rel(router, pages, "Renders page")
+    Rel(pages, layout, "Uses layout")
+    Rel(pages, ui_components, "Renders components")
+    Rel(pages, hooks, "Uses business logic")
+    Rel(layout, ui_components, "Composes UI")
+    Rel(hooks, services, "Calls APIs")
+    Rel(hooks, context, "Consumes context")
+    Rel(services, utils, "Uses utilities")
+    Rel(services, constants, "Uses configuration")
+    Rel(ui_components, constants, "Uses constants")
+```
+
+### **API Service Component Pattern**
+```mermaid
+C4Component
+    title Component diagram for Node.js API Service
+    
+    Container(api_service, "API Service Container", "Node.js")
+    
+    Component(app, "App Module", "Express", "Application setup & middleware")
+    Component(routes, "Route Handlers", "Express Router", "HTTP endpoint definitions")
+    Component(controllers, "Controllers", "TypeScript Classes", "Request/response logic")
+    Component(services, "Business Services", "TypeScript Classes", "Business logic layer")
+    Component(repositories, "Repositories", "TypeScript Classes", "Data access layer")
+    Component(middleware, "Middleware", "Express Middleware", "Cross-cutting concerns")
+    Component(validators, "Validators", "Joi/Zod", "Input validation")
+    Component(auth, "Auth Module", "JWT/Passport", "Authentication & authorization")
+    Component(config, "Configuration", "TypeScript", "Environment & settings")
+    Component(utils, "Utilities", "TypeScript", "Helper functions")
+    
+    Rel(app, routes, "Registers routes")
+    Rel(app, middleware, "Applies middleware")
+    Rel(app, auth, "Configures auth")
+    Rel(routes, controllers, "Delegates to")
+    Rel(controllers, validators, "Validates input")
+    Rel(controllers, services, "Calls business logic")
+    Rel(controllers, auth, "Checks authorization")
+    Rel(services, repositories, "Accesses data")
+    Rel(repositories, config, "Uses DB config")
+    Rel(middleware, auth, "Validates tokens")
+    Rel(auth, config, "Uses auth config")
+    Rel(services, utils, "Uses utilities")
+```
+
+---
+
+## 🎯 **Pattern Selection Rules**
+
+### **Context Level Selection**
+```typescript
+const contextPatterns = {
+  'single-user-spa': 'basic-context-pattern',
+  'multi-user-app': 'multi-user-context-pattern',
+  'microservices': 'microservices-context-pattern',
+  'monolith': 'basic-context-pattern',
+  'serverless': 'serverless-context-pattern'
+}
+```
+
+### **Container Level Selection**
+```typescript
+const containerPatterns = {
+  'spa-with-api': 'web-application-container-pattern',
+  'monorepo-nx': 'monorepo-container-pattern',
+  'nextjs-fullstack': 'fullstack-container-pattern',
+  'microservices': 'microservices-container-pattern',
+  'api-only': 'api-service-container-pattern'
+}
+```
+
+### **Component Level Selection**
+```typescript
+const componentPatterns = {
+  'react-frontend': 'react-component-structure-pattern',
+  'vue-frontend': 'vue-component-structure-pattern',
+  'node-api': 'api-service-component-pattern',
+  'nestjs-api': 'nestjs-component-pattern',
+  'express-api': 'express-component-pattern'
+}
+```
+
+---
+
+## 🔧 **Mermaid Optimization Rules**
+
+### **GitHub Compatibility**
+```yaml
+github_optimizations:
+  max_diagram_size: '2MB'
+  recommended_nodes: '< 20 per diagram'
+  text_length: '< 50 chars per label'
+  
+  avoid:
+    - Complex nested boundaries
+    - Too many relationship lines
+    - Very long descriptions
+    
+  prefer:
+    - Simple, clear node names
+    - Consistent styling
+    - Logical grouping with boundaries
+```
+
+### **Performance Guidelines**
+```yaml
+performance_rules:
+  context_diagrams:
+    max_systems: 8
+    max_actors: 4
+    max_relationships: 12
+    
+  container_diagrams:
+    max_containers: 12
+    max_databases: 4
+    max_external_systems: 6
+    
+  component_diagrams:
+    max_components: 15
+    max_relationships: 20
+    recommended_depth: 1  # Avoid nested components
+```
+
+### **Styling Consistency**
+```yaml
+styling_patterns:
+  colors:
+    person: '#08427B'
+    system: '#1168BD'
+    system_ext: '#999999'
+    container: '#438DD5'
+    component: '#85BBF0'
+    database: '#F2F2F2'
+    
+  node_naming:
+    use_snake_case: true
+    max_length: 20
+    avoid_special_chars: true
+    
+  relationship_labels:
+    action_oriented: 'Uses, Calls, Sends, Reads'
+    include_protocol: 'HTTPS, REST, SQL'
+    max_length: 30
+```
+
+---
+
+**Patterns**: 🎭 **GitHub-Optimized & Performance-Tuned**  
+**Compatibility**: Testado com GitHub Mermaid rendering  
+**Performance**: Otimizado para diagramas < 2MB  
+**Quality**: Templates seguem melhores práticas C4 Model

package/templates/.cursor/docs/c4/c4-templates.md

@@ -0,0 +1,256 @@
+# 🎨 C4 Templates - Sistema Onion
+
+## 📋 **Template Strategy**
+
+Templates Mermaid C4 adaptativos para diferentes tipos de projeto. Seguindo a estratégia "Cebola" (núcleo → abstração).
+
+---
+
+## 🏢 **Single Page Application (SPA) Templates**
+
+### **React SPA Template**
+```mermaid
+C4Context
+    title System Context diagram for React SPA Application
+    
+    Person(user, "User", "End user of the application")
+    System(spa, "React SPA", "Single Page Application built with React")
+    System_Ext(api, "Backend API", "RESTful API providing data")
+    System_Ext(cdn, "CDN", "Content Delivery Network")
+    
+    Rel(user, spa, "Uses", "HTTPS")
+    Rel(spa, api, "Fetches data", "HTTPS/REST")
+    Rel(spa, cdn, "Loads assets", "HTTPS")
+```
+
+### **Vue.js SPA Template**
+```mermaid
+C4Context
+    title System Context diagram for Vue.js SPA Application
+    
+    Person(user, "User", "Application user")
+    System(vue_spa, "Vue.js SPA", "Single Page Application built with Vue.js")
+    System_Ext(api, "Backend API", "Data provider")
+    System_Ext(router, "Vue Router", "Client-side routing")
+    
+    Rel(user, vue_spa, "Interacts", "HTTPS")
+    Rel(vue_spa, api, "API calls", "HTTPS/REST")
+    Rel(vue_spa, router, "Navigation", "Client-side")
+```
+
+---
+
+## 🔌 **API Service Templates**
+
+### **Node.js Express API Template**
+```mermaid
+C4Context
+    title System Context diagram for Node.js Express API
+    
+    System_Ext(client, "Client Applications", "Web, Mobile, or SPA")
+    System(api, "Express API", "Node.js REST API built with Express")
+    SystemDb(database, "Database", "PostgreSQL/MongoDB")
+    System_Ext(cache, "Redis Cache", "Caching layer")
+    
+    Rel(client, api, "API Requests", "HTTPS/REST")
+    Rel(api, database, "Stores/Retrieves data", "SQL/NoSQL")
+    Rel(api, cache, "Caches data", "Redis Protocol")
+```
+
+### **NestJS API Template**
+```mermaid
+C4Context
+    title System Context diagram for NestJS API
+    
+    System_Ext(client, "Client Applications", "Various client types")
+    System(nestjs_api, "NestJS API", "Enterprise Node.js API with NestJS")
+    SystemDb(database, "Database", "TypeORM supported database")
+    System_Ext(auth, "Authentication Service", "JWT/OAuth provider")
+    
+    Rel(client, nestjs_api, "API calls", "HTTPS/REST")
+    Rel(nestjs_api, database, "Data operations", "TypeORM")
+    Rel(nestjs_api, auth, "Authentication", "JWT/OAuth")
+```
+
+---
+
+## 🌐 **Full-stack Application Templates**
+
+### **Next.js Full-stack Template**
+```mermaid
+C4Context
+    title System Context diagram for Next.js Application
+    
+    Person(user, "User", "Application user")
+    System(nextjs_app, "Next.js Application", "Full-stack React framework")
+    SystemDb(database, "Database", "Database system")
+    System_Ext(cdn, "Vercel CDN", "Static assets and ISR")
+    
+    Rel(user, nextjs_app, "Uses application", "HTTPS")
+    Rel(nextjs_app, database, "Data operations", "Database connection")
+    Rel(nextjs_app, cdn, "Serves static content", "CDN")
+```
+
+---
+
+## 📦 **Monorepo Templates**
+
+### **NX Monorepo Template**
+```mermaid
+C4Context
+    title System Context diagram for NX Monorepo Workspace
+    
+    Person(dev, "Developer", "Development team member")
+    System(nx_workspace, "NX Workspace", "Monorepo with multiple applications")
+    System_Ext(registry, "Package Registry", "npm/private registry")
+    System_Ext(ci_cd, "CI/CD Pipeline", "Build and deployment automation")
+    
+    Rel(dev, nx_workspace, "Develops", "CLI/IDE")
+    Rel(nx_workspace, registry, "Publishes packages", "npm publish")
+    Rel(nx_workspace, ci_cd, "Triggers builds", "Git hooks")
+```
+
+### **Lerna Monorepo Template**
+```mermaid
+C4Context
+    title System Context diagram for Lerna Monorepo
+    
+    Person(dev, "Developer", "Team member")
+    System(lerna_mono, "Lerna Monorepo", "Multi-package repository")
+    System_Ext(npm, "NPM Registry", "Package registry")
+    System_Ext(git, "Git Repository", "Version control")
+    
+    Rel(dev, lerna_mono, "Manages packages", "Lerna CLI")
+    Rel(lerna_mono, npm, "Publishes", "npm")
+    Rel(lerna_mono, git, "Version control", "Git")
+```
+
+---
+
+## ☁️ **Serverless Templates**
+
+### **AWS Lambda Template**
+```mermaid
+C4Context
+    title System Context diagram for AWS Lambda Functions
+    
+    System_Ext(client, "Client", "Application or API Gateway")
+    System(lambda, "Lambda Functions", "Serverless compute functions")
+    SystemDb(dynamo, "DynamoDB", "NoSQL database")
+    System_Ext(s3, "S3 Bucket", "File storage")
+    
+    Rel(client, lambda, "Invokes functions", "API Gateway/Direct")
+    Rel(lambda, dynamo, "Data operations", "AWS SDK")
+    Rel(lambda, s3, "File operations", "AWS SDK")
+```
+
+---
+
+## 🎯 **Container Level Templates**
+
+### **React SPA Container Diagram**
+```mermaid
+C4Container
+    title Container diagram for React SPA
+    
+    Person(user, "User")
+    
+    Container(web_app, "Web Application", "React, TypeScript", "Single-page application")
+    Container(api_app, "API Application", "Node.js, Express", "Provides functionality via API")
+    ContainerDb(database, "Database", "PostgreSQL", "Stores data")
+    
+    Rel(user, web_app, "Uses", "HTTPS")
+    Rel(web_app, api_app, "Makes API calls to", "JSON/HTTPS")
+    Rel(api_app, database, "Reads from and writes to", "SQL/JDBC")
+```
+
+### **Monorepo Container Diagram**
+```mermaid
+C4Container
+    title Container diagram for NX Monorepo
+    
+    Person(dev, "Developer")
+    
+    Container(web_app, "Web Application", "React", "Main user-facing app")
+    Container(admin_app, "Admin Application", "React", "Administrative interface") 
+    Container(api, "API Service", "Node.js/NestJS", "Backend API service")
+    Container(shared_lib, "Shared Libraries", "TypeScript", "Common utilities and types")
+    ContainerDb(database, "Database", "PostgreSQL", "Shared database")
+    
+    Rel(dev, web_app, "Develops")
+    Rel(dev, admin_app, "Develops")
+    Rel(dev, api, "Develops")
+    Rel(web_app, shared_lib, "Uses")
+    Rel(admin_app, shared_lib, "Uses")
+    Rel(api, shared_lib, "Uses")
+    Rel(web_app, api, "API calls", "HTTPS")
+    Rel(admin_app, api, "API calls", "HTTPS")
+    Rel(api, database, "Persists data")
+```
+
+---
+
+## 🧩 **Component Level Templates**
+
+### **React Component Structure**
+```mermaid
+C4Component
+    title Component diagram for React Application
+    
+    Container(web_app, "Web Application", "React")
+    
+    Component(app_comp, "App Component", "React Component", "Main application component")
+    Component(router, "Router", "React Router", "Handles client-side routing")
+    Component(pages, "Page Components", "React Components", "Individual page components")
+    Component(components, "UI Components", "React Components", "Reusable UI components")
+    Component(hooks, "Custom Hooks", "React Hooks", "Business logic hooks")
+    Component(services, "API Services", "TypeScript", "API communication layer")
+    Component(utils, "Utilities", "TypeScript", "Helper functions and utilities")
+    
+    Rel(app_comp, router, "Uses")
+    Rel(router, pages, "Routes to")
+    Rel(pages, components, "Renders")
+    Rel(pages, hooks, "Uses")
+    Rel(hooks, services, "Calls")
+    Rel(services, utils, "Uses")
+```
+
+---
+
+## 🔧 **Template Selection Logic**
+
+### **Detection Patterns**
+```typescript
+// Template selection based on project detection
+const templateMappingRules = {
+  // SPA Projects
+  'spa-react': {
+    contextTemplate: 'react-spa-context',
+    containerTemplate: 'spa-container-diagram',
+    componentTemplate: 'react-component-structure'
+  },
+  
+  // API Projects
+  'node-api': {
+    contextTemplate: 'nodejs-api-context', 
+    containerTemplate: 'api-service-containers',
+    componentTemplate: 'api-layered-components'
+  },
+  
+  // Monorepo Projects
+  'nx-monorepo': {
+    contextTemplate: 'nx-workspace-context',
+    containerTemplate: 'monorepo-container-diagram', 
+    componentTemplate: 'nx-lib-components'
+  }
+  
+  // ... more mappings
+}
+```
+
+---
+
+**Templates**: 🎨 **Adaptive & Project-Aware**  
+**Strategy**: Seleção automática baseada em detecção de projeto  
+**Fallback**: Template genérico quando tipo não identificado  
+**Extensibilidade**: Novos templates facilmente adicionáveis