@etus/bhono-app 0.1.1

package/templates/base/.claude/skills/architecture-analyzer/assets/report-template.md

@@ -0,0 +1,215 @@
+# Microservices Architecture Analysis Report
+
+**Generated**: [DATE]  
+**Repository**: [REPOSITORY_NAME]  
+**Analysis Type**: Code-based (no stakeholder interviews)  
+**Confidence Distribution**: HIGH: _%, MEDIUM: _%, LOW: _%, UNKNOWN: _%
+
+---
+
+## Executive Summary
+
+### Key Findings
+- **Architecture Style**: [Microservices/Monolith/Hybrid] [Confidence: _]
+- **Total Services**: _ microservices identified
+- **Primary Technologies**: [List main stack]
+- **Communication Pattern**: [Sync/Async/Mixed]
+- **Deployment Model**: [Containers/Serverless/VMs]
+
+### Critical Observations
+🔴 **High Priority (HIGH confidence)**
+- [Issue 1]
+- [Issue 2]
+
+🟡 **Medium Priority (MEDIUM confidence)**
+- [Issue 1]
+- [Issue 2]
+
+🔵 **Needs Investigation (LOW confidence)**
+- [Issue 1]
+- [Issue 2]
+
+---
+
+## System Architecture
+
+### High-Level Overview
+[Narrative description of the system]
+
+### Architecture Style
+- **Pattern**: [Microservices/SOA/Modular Monolith]
+- **Evidence**: [List evidence]
+- **Confidence**: [HIGH/MEDIUM/LOW]
+
+### Technology Stack
+| Layer | Technology | Services Using | Confidence |
+|-------|------------|----------------|------------|
+| Frontend | | | |
+| Backend | | | |
+| Database | | | |
+| Messaging | | | |
+| Caching | | | |
+
+---
+
+## Service Catalog
+
+| Service | Path | Domain | Purpose | Tech Stack | APIs | Dependencies | Confidence |
+|---------|------|--------|---------|------------|------|--------------|------------|
+| | | | | | | | |
+
+---
+
+## System Diagrams
+
+### C4 System Context
+```mermaid
+[Insert C4 Context Diagram]
+```
+
+### C4 Container Diagram
+```mermaid
+[Insert C4 Container Diagram]
+```
+
+---
+
+## Domain Model
+
+### Bounded Contexts
+| Context | Services | Core Entities | Confidence |
+|---------|----------|---------------|------------|
+| | | | |
+
+### Key Entities
+| Entity | Owner Service | Related Services | Confidence |
+|--------|--------------|------------------|------------|
+| | | | |
+
+---
+
+## API Documentation
+
+### REST APIs
+| Service | Endpoint Count | Authentication | Documentation | Confidence |
+|---------|----------------|----------------|---------------|------------|
+| | | | | |
+
+### Event/Message APIs
+| Event | Producer | Consumers | Format | Confidence |
+|-------|----------|-----------|--------|------------|
+| | | | | |
+
+---
+
+## Service Dependencies
+
+### Dependency Matrix
+| Service | Depends On | Type | Confidence |
+|---------|------------|------|------------|
+| | | | |
+
+### Critical Paths
+1. **[Flow Name]**
+   - Path: Service A → Service B → Service C
+   - Type: [Synchronous/Asynchronous]
+   - Confidence: [_]
+
+---
+
+## Technical Assessment
+
+### Security
+| Aspect | Implementation | Coverage | Confidence |
+|--------|---------------|----------|------------|
+| Authentication | | | |
+| Authorization | | | |
+| Secrets Management | | | |
+| Encryption | | | |
+
+### Observability
+| Aspect | Implementation | Coverage | Confidence |
+|--------|---------------|----------|------------|
+| Logging | | | |
+| Metrics | | | |
+| Tracing | | | |
+| Health Checks | | | |
+
+### Quality Metrics
+| Service | Test Coverage | Code Quality | Tech Debt | Confidence |
+|---------|--------------|--------------|-----------|------------|
+| | | | | |
+
+---
+
+## Technical Debt Register
+
+| ID | Service | Issue | Type | Impact | Evidence | Confidence | Recommendation |
+|----|---------|-------|------|--------|----------|------------|----------------|
+| TD-001 | | | | | | | |
+
+---
+
+## Risks and Gaps
+
+### Architecture Risks
+| Risk | Description | Impact | Evidence | Confidence |
+|------|-------------|--------|----------|------------|
+| | | | | |
+
+### Knowledge Gaps
+- [Area 1]: Unknown (not derivable from code)
+- [Area 2]: Unknown (requires stakeholder input)
+
+---
+
+## Recommendations
+
+### Immediate Actions (HIGH confidence)
+1. **[Action]**
+   - Rationale: [Why]
+   - Evidence: [What we found]
+   - Impact: [Expected outcome]
+
+### Short-term Improvements (MEDIUM confidence)
+1. **[Improvement]**
+   - Rationale: [Why]
+   - Evidence: [What suggests this]
+   - Validation Needed: [What to confirm]
+
+### Investigation Areas (LOW confidence)
+1. **[Area]**
+   - Current Understanding: [What we think]
+   - Evidence Gap: [What's missing]
+   - Questions for Stakeholders: [What to ask]
+
+---
+
+## Appendix
+
+### Analysis Limitations
+- No runtime information available
+- No performance metrics accessible
+- No production configurations reviewed
+- No stakeholder interviews conducted
+
+### Assumptions Made
+| Assumption | Rationale | Impact if Incorrect |
+|------------|-----------|-------------------|
+| | | |
+
+### Files Analyzed
+- Total files scanned: _
+- Total lines of code: _
+- Configuration files: _
+- Test files: _
+
+### Confidence Summary
+- HIGH confidence findings: _% (_/_ items)
+- MEDIUM confidence findings: _% (_/_ items)  
+- LOW confidence findings: _% (_/_ items)
+- UNKNOWN: _ areas requiring stakeholder input
+
+---
+
+*End of Report*

package/templates/base/.claude/skills/architecture-analyzer/references/c4-templates.md

@@ -0,0 +1,234 @@
+# C4 Model Templates
+
+## Overview
+The C4 model provides a hierarchical way to describe software architecture using Context, Container, Component, and Code diagrams.
+
+## System Context Diagram (Level 1)
+
+### Mermaid Template
+```mermaid
+graph TB
+    User[User]
+    System[Your System]
+    ExtSystem1[External System 1]
+    ExtSystem2[External System 2]
+    
+    User -->|Uses| System
+    System -->|Sends data to| ExtSystem1
+    System -->|Gets data from| ExtSystem2
+    
+    style System fill:#1168bd,stroke:#333,stroke-width:4px
+    style User fill:#08427b,stroke:#333,stroke-width:2px,color:#fff
+```
+
+### PlantUML Template
+```plantuml
+@startuml
+!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Context.puml
+
+Person(user, "User", "A user of the system")
+System(system, "Your System", "Description of your system")
+System_Ext(ext1, "External System 1", "Description")
+System_Ext(ext2, "External System 2", "Description")
+
+Rel(user, system, "Uses")
+Rel(system, ext1, "Sends data to")
+Rel(system, ext2, "Gets data from")
+@enduml
+```
+
+## Container Diagram (Level 2)
+
+### Mermaid Template
+```mermaid
+graph TB
+    subgraph "Your System"
+        WebApp[Web Application<br/>React]
+        API[API Gateway<br/>Node.js]
+        AuthService[Auth Service<br/>Node.js]
+        UserService[User Service<br/>Java Spring]
+        OrderService[Order Service<br/>Python FastAPI]
+        DB1[(User DB<br/>PostgreSQL)]
+        DB2[(Order DB<br/>MongoDB)]
+        Queue[Message Queue<br/>RabbitMQ]
+    end
+    
+    User[User]
+    
+    User -->|HTTPS| WebApp
+    WebApp -->|REST/JSON| API
+    API -->|REST| AuthService
+    API -->|REST| UserService
+    API -->|REST| OrderService
+    UserService -->|SQL| DB1
+    OrderService -->|NoSQL| DB2
+    OrderService -->|Publish| Queue
+    UserService -->|Subscribe| Queue
+```
+
+### PlantUML Template
+```plantuml
+@startuml
+!include https://raw.githubusercontent.com/plantuml-stdlib/C4-PlantUML/master/C4_Container.puml
+
+Person(user, "User")
+System_Boundary(system, "Your System") {
+    Container(webapp, "Web Application", "React", "Provides UI")
+    Container(api, "API Gateway", "Node.js", "Routes requests")
+    Container(auth, "Auth Service", "Node.js", "Authentication")
+    Container(userservice, "User Service", "Java Spring", "User management")
+    Container(orderservice, "Order Service", "Python", "Order processing")
+    ContainerDb(userdb, "User Database", "PostgreSQL", "User data")
+    ContainerDb(orderdb, "Order Database", "MongoDB", "Order data")
+    ContainerQueue(queue, "Message Queue", "RabbitMQ", "Async messaging")
+}
+
+Rel(user, webapp, "Uses", "HTTPS")
+Rel(webapp, api, "Makes API calls", "REST/JSON")
+Rel(api, auth, "Authenticates", "REST")
+Rel(api, userservice, "User operations", "REST")
+Rel(api, orderservice, "Order operations", "REST")
+Rel(userservice, userdb, "Reads/Writes", "SQL")
+Rel(orderservice, orderdb, "Reads/Writes", "NoSQL")
+Rel(orderservice, queue, "Publishes events")
+Rel(userservice, queue, "Subscribes to events")
+@enduml
+```
+
+## Component Diagram (Level 3)
+
+### Mermaid Template
+```mermaid
+graph TB
+    subgraph "User Service"
+        Controller[REST Controller]
+        Service[User Service]
+        Repository[User Repository]
+        EventPublisher[Event Publisher]
+        SecurityFilter[Security Filter]
+    end
+    
+    API[API Gateway]
+    DB[(PostgreSQL)]
+    Queue[RabbitMQ]
+    
+    API -->|REST| Controller
+    Controller --> SecurityFilter
+    SecurityFilter --> Service
+    Service --> Repository
+    Service --> EventPublisher
+    Repository -->|SQL| DB
+    EventPublisher -->|AMQP| Queue
+```
+
+## Sequence Diagram Template
+
+### Mermaid Template
+```mermaid
+sequenceDiagram
+    participant User
+    participant WebApp
+    participant API Gateway
+    participant Auth Service
+    participant User Service
+    participant Database
+    
+    User->>WebApp: Login Request
+    WebApp->>API Gateway: POST /auth/login
+    API Gateway->>Auth Service: Validate Credentials
+    Auth Service->>Database: Query User
+    Database-->>Auth Service: User Data
+    Auth Service-->>API Gateway: JWT Token
+    API Gateway-->>WebApp: Login Response
+    WebApp-->>User: Show Dashboard
+```
+
+## Data Flow Diagram Template
+
+### Mermaid Template
+```mermaid
+graph LR
+    Source[Data Source]
+    Ingestion[Ingestion Service]
+    Processing[Processing Service]
+    Storage[(Data Lake)]
+    Analytics[Analytics Service]
+    Dashboard[Dashboard]
+    
+    Source -->|Raw Data| Ingestion
+    Ingestion -->|Validated Data| Processing
+    Processing -->|Transformed Data| Storage
+    Storage -->|Query| Analytics
+    Analytics -->|Aggregated Data| Dashboard
+```
+
+## Event Flow Diagram Template
+
+### Mermaid Template
+```mermaid
+graph TB
+    OrderService[Order Service]
+    UserService[User Service]
+    InventoryService[Inventory Service]
+    NotificationService[Notification Service]
+    
+    OrderCreated{Order Created Event}
+    PaymentProcessed{Payment Processed Event}
+    
+    OrderService -->|Publishes| OrderCreated
+    OrderCreated -->|Subscribes| UserService
+    OrderCreated -->|Subscribes| InventoryService
+    OrderCreated -->|Subscribes| NotificationService
+    
+    OrderService -->|Publishes| PaymentProcessed
+    PaymentProcessed -->|Subscribes| NotificationService
+    
+    style OrderCreated fill:#f9f,stroke:#333,stroke-width:2px
+    style PaymentProcessed fill:#f9f,stroke:#333,stroke-width:2px
+```
+
+## Dependency Matrix Template
+
+### Markdown Table
+```markdown
+| Service | User Service | Order Service | Auth Service | Notification | Database |
+|---------|-------------|---------------|--------------|--------------|----------|
+| **User Service** | - | HTTP | HTTP | Event | PostgreSQL |
+| **Order Service** | HTTP | - | HTTP | Event | MongoDB |
+| **Auth Service** | - | - | - | - | PostgreSQL |
+| **Notification** | Event | Event | - | - | - |
+```
+
+### Mermaid Heatmap Style
+```mermaid
+graph LR
+    subgraph "Service Dependencies"
+        US[User Service]
+        OS[Order Service]
+        AS[Auth Service]
+        NS[Notification Service]
+    end
+    
+    US -.->|Weak| OS
+    US ==>|Strong| AS
+    OS ==>|Strong| AS
+    OS -->|Medium| NS
+    US -->|Medium| NS
+```
+
+## Best Practices
+
+1. **Consistency**: Use the same notation and style across all diagrams
+2. **Clarity**: Label all connections with protocols/formats
+3. **Confidence**: Mark uncertain connections with dashed lines
+4. **Versioning**: Include API versions where relevant
+5. **Legend**: Add a legend for symbols and confidence levels
+
+## Confidence Notation
+
+- **Solid lines**: HIGH confidence (verified in code)
+- **Dashed lines**: MEDIUM confidence (inferred)
+- **Dotted lines**: LOW confidence (assumed)
+- **Red elements**: Critical/High priority
+- **Yellow elements**: Warning/Medium priority
+- **Green elements**: Healthy/Low priority

package/templates/base/.claude/skills/architecture-analyzer/references/confidence-levels.md

@@ -0,0 +1,203 @@
+# Confidence Levels Guide
+
+## Overview
+Every finding in the architecture analysis must be marked with a confidence level to indicate how certain we are about the information based on what can be verified in the code.
+
+## Confidence Levels
+
+### HIGH Confidence
+**Definition**: Information directly observable in code, configuration files, or explicit documentation within the repository.
+
+**Examples**:
+- Dependencies listed in package.json, pom.xml, requirements.txt
+- Database connections with explicit connection strings
+- API endpoints defined with decorators or route definitions
+- Environment variables referenced in code
+- Dockerfiles and deployment configurations
+- Test files and coverage reports
+- Explicit error messages or log statements
+
+**How to mark**:
+```markdown
+**Authentication**: JWT-based [HIGH - jsonwebtoken in package.json:15]
+**Database**: PostgreSQL 14 [HIGH - docker-compose.yml:23]
+**API Endpoints**: 23 REST endpoints [HIGH - counted from routes/]
+```
+
+### MEDIUM Confidence
+**Definition**: Information strongly inferred from patterns, naming conventions, or multiple corroborating pieces of evidence.
+
+**Examples**:
+- Service dependencies inferred from import statements
+- Framework usage inferred from file structure
+- Communication patterns inferred from client libraries
+- Business logic inferred from method/class names
+- Architectural patterns inferred from directory structure
+- Security practices inferred from middleware usage
+
+**How to mark**:
+```markdown
+**Service Communication**: REST over HTTP [MEDIUM - axios client found]
+**Pattern**: Repository pattern [MEDIUM - repo/ directory structure]
+**Caching**: Redis likely used [MEDIUM - redis client imported but no config]
+```
+
+### LOW Confidence
+**Definition**: Educated guesses based on common patterns, incomplete evidence, or industry standards.
+
+**Examples**:
+- Performance capabilities without explicit configs
+- Scaling assumptions based on technology stack
+- Business rules inferred from minimal code
+- Integration assumptions from partial evidence
+- Team structure guessed from code ownership
+- Deployment frequency from commit patterns
+
+**How to mark**:
+```markdown
+**Scale**: ~1000 concurrent users [LOW - based on single instance config]
+**Team Size**: 3-5 developers [LOW - based on commit authors]
+**Deploy Frequency**: Weekly [LOW - based on version tags]
+```
+
+### UNKNOWN
+**Definition**: Information that cannot be determined from the code alone and requires human input.
+
+**Examples**:
+- Business KPIs and metrics
+- SLAs and SLOs not in code
+- Organizational structure
+- Cost constraints
+- Compliance requirements
+- Production infrastructure details
+- User demographics
+- Business strategy
+
+**How to mark**:
+```markdown
+**Multi-tenancy Strategy**: Unknown (not derivable from code)
+**Production Scale**: Unknown (no production configs found)
+**Compliance**: Unknown (no explicit compliance markers)
+```
+
+## Decision Tree for Confidence Assignment
+
+```
+Is the information explicitly written in code/config?
+├─ YES → HIGH confidence
+└─ NO → Can it be strongly inferred from multiple sources?
+    ├─ YES → MEDIUM confidence
+    └─ NO → Is there partial evidence?
+        ├─ YES → LOW confidence
+        └─ NO → UNKNOWN
+```
+
+## Evidence Requirements by Confidence Level
+
+### HIGH Confidence Evidence
+Must provide:
+- Exact file path
+- Line number (when applicable)
+- Exact text or configuration value
+
+Example:
+```markdown
+Evidence: `/services/user/package.json:12` - "express": "^4.18.0"
+```
+
+### MEDIUM Confidence Evidence
+Must provide:
+- Multiple corroborating sources
+- Pattern explanation
+- File/directory references
+
+Example:
+```markdown
+Evidence: Multiple HTTP client calls in `/services/order/api/`
+Pattern: All external calls use axios with similar structure
+```
+
+### LOW Confidence Evidence
+Must provide:
+- Reasoning for the guess
+- What evidence is missing
+- Industry standard reference
+
+Example:
+```markdown
+Evidence: No explicit scaling config found
+Reasoning: Node.js single instance, no clustering setup
+Missing: Production deployment configs
+```
+
+## Compound Confidence
+
+When combining multiple pieces of information:
+
+```markdown
+**Service Architecture** [Confidence: Mixed]
+- Microservices: HIGH (separate deployables found)
+- Count: HIGH (12 services identified)
+- Communication: MEDIUM (REST patterns inferred)
+- Orchestration: LOW (possible K8s from yaml files)
+- Production Setup: Unknown
+```
+
+## Confidence in Diagrams
+
+### Visual Representations
+- **Solid lines**: HIGH confidence relationships
+- **Dashed lines**: MEDIUM confidence relationships
+- **Dotted lines**: LOW confidence relationships
+- **Question marks**: UNKNOWN elements
+
+### Diagram Annotations
+```mermaid
+graph LR
+    A[Service A] ==>|HIGH| B[Service B]
+    B -.->|MEDIUM| C[Service C]
+    C ...|LOW| D[Service D]
+    D ---|UNKNOWN| E[External?]
+```
+
+## Confidence Aggregation
+
+For summary sections:
+```markdown
+## Analysis Confidence Summary
+- HIGH confidence findings: 67% (45/67 items)
+- MEDIUM confidence findings: 24% (16/67 items)
+- LOW confidence findings: 9% (6/67 items)
+- UNKNOWN: 12 areas requiring stakeholder input
+
+## Recommended Validation Priority
+1. Validate LOW confidence items first
+2. Confirm MEDIUM confidence patterns
+3. Verify HIGH confidence critical items
+4. Gather information for UNKNOWN areas
+```
+
+## Best Practices
+
+1. **Be Conservative**: When in doubt, use lower confidence
+2. **Show Your Work**: Always explain reasoning
+3. **Accumulate Evidence**: Multiple weak signals can increase confidence
+4. **Update Continuously**: Adjust confidence as more code is analyzed
+5. **Highlight Uncertainty**: Make unknowns prominent
+6. **Version Confidence**: Track how confidence changes over analysis
+
+## Anti-Patterns to Avoid
+
+❌ **Don't**:
+- State something as fact without evidence
+- Hide uncertainty in footnotes
+- Average confidence across unrelated items
+- Assume industry standards apply
+- Guess at business requirements
+
+✅ **Do**:
+- Mark every technical claim
+- Lead with confidence level
+- Explain evidence gaps
+- Separate facts from inferences
+- Document what you cannot determine