@etus/bhono-app 0.1.1

package/templates/base/.claude/skills/architecture-analyzer/scripts/extract_apis.py

@@ -0,0 +1,338 @@
+#!/usr/bin/env python3
+"""
+API Extractor
+Extracts API endpoints from microservices code
+"""
+
+import os
+import re
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+class APIExtractor:
+    """Extract API endpoints from various frameworks"""
+    
+    # Regex patterns for different frameworks
+    PATTERNS = {
+        'express': [
+            r"app\.(get|post|put|delete|patch|options|head)\s*\(\s*['\"`]([^'\"]+)['\"`]",
+            r"router\.(get|post|put|delete|patch|options|head)\s*\(\s*['\"`]([^'\"]+)['\"`]",
+        ],
+        'fastapi': [
+            r"@app\.(get|post|put|delete|patch|options|head)\s*\(\s*['\"`]([^'\"]+)['\"`]",
+            r"@router\.(get|post|put|delete|patch|options|head)\s*\(\s*['\"`]([^'\"]+)['\"`]",
+        ],
+        'flask': [
+            r"@app\.route\s*\(\s*['\"`]([^'\"]+)['\"`].*methods=\[(.*?)\]",
+            r"@app\.route\s*\(\s*['\"`]([^'\"]+)['\"`]",
+        ],
+        'spring': [
+            r"@(Get|Post|Put|Delete|Patch|Request)Mapping\s*\(\s*.*?['\"`]([^'\"]+)['\"`]",
+            r"@(Get|Post|Put|Delete|Patch|Request)Mapping\s*\(\s*value\s*=\s*['\"`]([^'\"]+)['\"`]",
+        ],
+        'gin': [
+            r"router\.(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)\s*\(\s*['\"`]([^'\"]+)['\"`]",
+            r"r\.(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)\s*\(\s*['\"`]([^'\"]+)['\"`]",
+        ],
+        'django': [
+            r"path\s*\(\s*['\"`]([^'\"]+)['\"`]",
+            r"url\s*\(\s*r?['\"`]\^?([^'\"]+)\$?['\"`]",
+        ],
+    }
+    
+    # GraphQL patterns
+    GRAPHQL_PATTERNS = [
+        r"type\s+Query\s*{([^}]+)}",
+        r"type\s+Mutation\s*{([^}]+)}",
+        r"type\s+Subscription\s*{([^}]+)}",
+    ]
+    
+    # gRPC patterns
+    GRPC_PATTERNS = [
+        r"service\s+(\w+)\s*{([^}]+)}",
+        r"rpc\s+(\w+)\s*\(([^)]+)\)\s*returns\s*\(([^)]+)\)",
+    ]
+    
+    def __init__(self, service_path: str):
+        self.service_path = Path(service_path)
+        self.apis = []
+    
+    def detect_framework(self) -> Optional[str]:
+        """Detect the framework used by the service"""
+        # Check package.json for Node.js frameworks
+        pkg_file = self.service_path / 'package.json'
+        if pkg_file.exists():
+            try:
+                with open(pkg_file) as f:
+                    data = json.load(f)
+                    deps = {**data.get('dependencies', {}), 
+                            **data.get('devDependencies', {})}
+                    
+                    if 'express' in deps:
+                        return 'express'
+                    if 'fastify' in deps:
+                        return 'express'  # Similar patterns
+                    if '@nestjs/core' in deps:
+                        return 'express'  # Similar patterns
+                    if 'koa' in deps:
+                        return 'express'  # Similar patterns
+            except:
+                pass
+        
+        # Check for Python frameworks
+        for file in self.service_path.glob('**/*.py'):
+            try:
+                content = file.read_text()
+                if 'from flask' in content or 'import flask' in content:
+                    return 'flask'
+                if 'from fastapi' in content or 'import fastapi' in content:
+                    return 'fastapi'
+                if 'from django' in content or 'import django' in content:
+                    return 'django'
+            except:
+                continue
+        
+        # Check for Java/Spring
+        for file in self.service_path.glob('**/*.java'):
+            try:
+                content = file.read_text()
+                if '@RestController' in content or '@RequestMapping' in content:
+                    return 'spring'
+            except:
+                continue
+        
+        # Check for Go/Gin
+        for file in self.service_path.glob('**/*.go'):
+            try:
+                content = file.read_text()
+                if 'github.com/gin-gonic/gin' in content:
+                    return 'gin'
+            except:
+                continue
+        
+        return None
+    
+    def extract_rest_endpoints(self, file_path: Path, framework: str) -> List[Dict]:
+        """Extract REST endpoints from a file"""
+        endpoints = []
+        
+        try:
+            content = file_path.read_text()
+            patterns = self.PATTERNS.get(framework, [])
+            
+            for pattern in patterns:
+                matches = re.finditer(pattern, content, re.MULTILINE | re.IGNORECASE)
+                for match in matches:
+                    if framework in ['express', 'fastapi', 'gin']:
+                        method = match.group(1).upper()
+                        path = match.group(2)
+                    elif framework == 'spring':
+                        method = match.group(1).replace('Mapping', '').upper()
+                        if method == 'REQUEST':
+                            method = 'GET'  # Default
+                        path = match.group(2) if len(match.groups()) > 1 else '/'
+                    elif framework == 'flask':
+                        if len(match.groups()) > 1:
+                            path = match.group(1)
+                            methods = match.group(2) if match.group(2) else 'GET'
+                            method = methods.split(',')[0].strip().strip("'\"").upper()
+                        else:
+                            path = match.group(1)
+                            method = 'GET'
+                    elif framework == 'django':
+                        path = match.group(1)
+                        method = 'GET'  # Django doesn't specify in URL
+                    else:
+                        continue
+                    
+                    endpoints.append({
+                        'method': method,
+                        'path': path,
+                        'file': str(file_path.relative_to(self.service_path)),
+                        'type': 'REST',
+                        'confidence': 'HIGH'
+                    })
+        except Exception as e:
+            print(f"Error reading {file_path}: {e}")
+        
+        return endpoints
+    
+    def extract_graphql_endpoints(self) -> List[Dict]:
+        """Extract GraphQL operations"""
+        endpoints = []
+        
+        for file in self.service_path.glob('**/*.graphql'):
+            try:
+                content = file.read_text()
+                
+                for pattern in self.GRAPHQL_PATTERNS:
+                    matches = re.finditer(pattern, content, re.MULTILINE | re.DOTALL)
+                    for match in matches:
+                        operation_type = pattern.split()[1].lower()
+                        operations = match.group(1)
+                        
+                        # Extract individual operations
+                        op_pattern = r'(\w+)\s*(?:\([^)]*\))?\s*:'
+                        op_matches = re.finditer(op_pattern, operations)
+                        
+                        for op_match in op_matches:
+                            endpoints.append({
+                                'operation': op_match.group(1),
+                                'type': 'GraphQL',
+                                'operation_type': operation_type,
+                                'file': str(file.relative_to(self.service_path)),
+                                'confidence': 'HIGH'
+                            })
+            except:
+                continue
+        
+        return endpoints
+    
+    def extract_grpc_endpoints(self) -> List[Dict]:
+        """Extract gRPC service definitions"""
+        endpoints = []
+        
+        for file in self.service_path.glob('**/*.proto'):
+            try:
+                content = file.read_text()
+                
+                # Find services
+                service_pattern = r"service\s+(\w+)\s*{([^}]+)}"
+                service_matches = re.finditer(service_pattern, content, re.MULTILINE | re.DOTALL)
+                
+                for service_match in service_matches:
+                    service_name = service_match.group(1)
+                    service_content = service_match.group(2)
+                    
+                    # Find RPCs in service
+                    rpc_pattern = r"rpc\s+(\w+)\s*\(([^)]+)\)\s*returns\s*\(([^)]+)\)"
+                    rpc_matches = re.finditer(rpc_pattern, service_content)
+                    
+                    for rpc_match in rpc_matches:
+                        endpoints.append({
+                            'service': service_name,
+                            'method': rpc_match.group(1),
+                            'request': rpc_match.group(2).strip(),
+                            'response': rpc_match.group(3).strip(),
+                            'type': 'gRPC',
+                            'file': str(file.relative_to(self.service_path)),
+                            'confidence': 'HIGH'
+                        })
+            except:
+                continue
+        
+        return endpoints
+    
+    def extract_all_apis(self) -> Dict:
+        """Extract all APIs from the service"""
+        framework = self.detect_framework()
+        
+        apis = {
+            'service_path': str(self.service_path),
+            'framework': framework or 'Unknown',
+            'rest_endpoints': [],
+            'graphql_operations': [],
+            'grpc_services': [],
+            'total_endpoints': 0
+        }
+        
+        # Extract REST endpoints
+        if framework:
+            file_patterns = {
+                'express': ['**/*.js', '**/*.ts'],
+                'flask': ['**/*.py'],
+                'fastapi': ['**/*.py'],
+                'django': ['**/urls.py', '**/views.py'],
+                'spring': ['**/*.java'],
+                'gin': ['**/*.go'],
+            }
+            
+            patterns = file_patterns.get(framework, ['**/*'])
+            for pattern in patterns:
+                for file in self.service_path.glob(pattern):
+                    if 'node_modules' not in str(file) and 'test' not in str(file).lower():
+                        apis['rest_endpoints'].extend(
+                            self.extract_rest_endpoints(file, framework)
+                        )
+        
+        # Extract GraphQL
+        apis['graphql_operations'] = self.extract_graphql_endpoints()
+        
+        # Extract gRPC
+        apis['grpc_services'] = self.extract_grpc_endpoints()
+        
+        # Total count
+        apis['total_endpoints'] = (
+            len(apis['rest_endpoints']) + 
+            len(apis['graphql_operations']) + 
+            len(apis['grpc_services'])
+        )
+        
+        return apis
+
+def format_markdown(apis: Dict) -> str:
+    """Format APIs as markdown"""
+    output = f"""# API Documentation
+
+## Service: {apis['service_path']}
+- **Framework**: {apis['framework']}
+- **Total Endpoints**: {apis['total_endpoints']}
+
+"""
+    
+    if apis['rest_endpoints']:
+        output += "## REST Endpoints\n\n"
+        output += "| Method | Path | File | Confidence |\n"
+        output += "|--------|------|------|------------|\n"
+        
+        for endpoint in apis['rest_endpoints']:
+            output += f"| {endpoint['method']} | `{endpoint['path']}` | {endpoint['file']} | {endpoint['confidence']} |\n"
+        output += "\n"
+    
+    if apis['graphql_operations']:
+        output += "## GraphQL Operations\n\n"
+        output += "| Operation | Type | File | Confidence |\n"
+        output += "|-----------|------|------|------------|\n"
+        
+        for op in apis['graphql_operations']:
+            output += f"| {op['operation']} | {op['operation_type']} | {op['file']} | {op['confidence']} |\n"
+        output += "\n"
+    
+    if apis['grpc_services']:
+        output += "## gRPC Services\n\n"
+        output += "| Service | Method | Request | Response | File |\n"
+        output += "|---------|--------|---------|----------|------|\n"
+        
+        for rpc in apis['grpc_services']:
+            output += f"| {rpc['service']} | {rpc['method']} | {rpc['request']} | {rpc['response']} | {rpc['file']} |\n"
+        output += "\n"
+    
+    return output
+
+def main():
+    parser = argparse.ArgumentParser(description='Extract API endpoints from microservices')
+    parser.add_argument('path', nargs='?', default='.', help='Service path to analyze')
+    parser.add_argument('--output', '-o', help='Output file')
+    parser.add_argument('--format', '-f', choices=['json', 'markdown'], default='markdown')
+    
+    args = parser.parse_args()
+    
+    extractor = APIExtractor(args.path)
+    apis = extractor.extract_all_apis()
+    
+    if args.format == 'json':
+        output = json.dumps(apis, indent=2)
+    else:
+        output = format_markdown(apis)
+    
+    if args.output:
+        with open(args.output, 'w') as f:
+            f.write(output)
+        print(f"API documentation written to {args.output}")
+    else:
+        print(output)
+
+if __name__ == '__main__':
+    main()

package/templates/base/.claude/skills/architecture-analyzer/scripts/generate_c4.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""
+C4 Diagram Generator
+Generates C4 architecture diagrams from service analysis
+"""
+
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List, Set
+
+class C4Generator:
+    """Generate C4 diagrams in Mermaid format"""
+    
+    def __init__(self, services_data: Dict):
+        self.services = services_data.get('services', [])
+        self.dependencies = {}
+        self.external_systems = set()
+        
+    def analyze_dependencies(self):
+        """Analyze service dependencies from code patterns"""
+        # This would be populated from actual code analysis
+        # For now, showing the structure
+        pass
+    
+    def generate_context_diagram(self) -> str:
+        """Generate C4 Level 1 - System Context diagram"""
+        diagram = """graph TB
+    %% C4 Context Diagram
+    %% Level 1: System Context
+    
+    %% Actors
+    User[User<br/>System User]
+    Admin[Administrator<br/>System Admin]
+    
+    %% System Boundary
+    System[Your System<br/>Microservices Platform]
+    
+    %% External Systems
+    Auth[External Auth<br/>OAuth Provider]
+    Payment[Payment Gateway<br/>External Service]
+    Email[Email Service<br/>SendGrid/SES]
+    
+    %% Relationships
+    User -->|Uses| System
+    Admin -->|Manages| System
+    System -->|Authenticates with| Auth
+    System -->|Processes payments| Payment
+    System -->|Sends emails| Email
+    
+    %% Styling
+    style System fill:#1168bd,stroke:#333,stroke-width:4px
+    style User fill:#08427b,stroke:#333,stroke-width:2px,color:#fff
+    style Admin fill:#08427b,stroke:#333,stroke-width:2px,color:#fff
+    
+    classDef external fill:#999,stroke:#333,stroke-width:2px
+    class Auth,Payment,Email external"""
+        
+        return diagram
+    
+    def generate_container_diagram(self) -> str:
+        """Generate C4 Level 2 - Container diagram"""
+        if not self.services:
+            return "graph TB\n    NoServices[No services found]"
+        
+        diagram = """graph TB
+    %% C4 Container Diagram  
+    %% Level 2: Containers (Services)
+    
+    subgraph "System Boundary"
+"""
+        
+        # Add services
+        for service in self.services:
+            name = service.get('name', 'unknown')
+            lang = service.get('language', 'unknown')
+            framework = service.get('framework', '')
+            
+            # Create service node
+            service_id = name.replace('-', '_').replace(' ', '_')
+            label = f"{name}<br/>{lang}"
+            if framework and framework != 'Unknown':
+                label += f"<br/>{framework}"
+            
+            diagram += f"        {service_id}[{label}]\n"
+        
+        diagram += """    end
+    
+    %% External Storage
+    DB[(Database<br/>PostgreSQL)]
+    Cache[(Cache<br/>Redis)]
+    Queue[Message Queue<br/>RabbitMQ]
+    
+    %% Basic relationships (would be enhanced with actual dependency data)"""
+        
+        # Add basic relationships for services that likely need DB
+        for service in self.services:
+            service_id = service.get('name', '').replace('-', '_').replace(' ', '_')
+            if service_id:
+                if 'user' in service_id.lower() or 'auth' in service_id.lower():
+                    diagram += f"\n    {service_id} -->|Reads/Writes| DB"
+                if 'api' in service_id.lower() or 'gateway' in service_id.lower():
+                    diagram += f"\n    {service_id} -->|Caches| Cache"
+        
+        diagram += """
+    
+    %% Styling
+    classDef service fill:#1168bd,stroke:#333,stroke-width:2px,color:#fff
+    classDef storage fill:#999,stroke:#333,stroke-width:2px"""
+        
+        return diagram
+    
+    def generate_component_diagram(self, service_name: str) -> str:
+        """Generate C4 Level 3 - Component diagram for a specific service"""
+        diagram = f"""graph TB
+    %% C4 Component Diagram
+    %% Level 3: Components of {service_name}
+    
+    subgraph "{service_name}"
+        Controller[REST Controller<br/>Handles HTTP requests]
+        Service[Business Service<br/>Core business logic]
+        Repository[Repository<br/>Data access layer]
+        Validator[Validator<br/>Input validation]
+        EventBus[Event Publisher<br/>Publishes domain events]
+    end
+    
+    %% External containers
+    DB[(Database)]
+    Queue[Message Queue]
+    
+    %% Relationships
+    Controller --> Validator
+    Validator --> Service
+    Service --> Repository
+    Service --> EventBus
+    Repository -->|SQL| DB
+    EventBus -->|Publishes| Queue
+    
+    %% Styling
+    style Controller fill:#85bbf0,stroke:#333,stroke-width:2px
+    style Service fill:#85bbf0,stroke:#333,stroke-width:2px
+    style Repository fill:#85bbf0,stroke:#333,stroke-width:2px"""
+        
+        return diagram
+    
+    def generate_deployment_diagram(self) -> str:
+        """Generate deployment diagram"""
+        diagram = """graph TB
+    %% Deployment Diagram
+    
+    subgraph "Production Environment"
+        subgraph "Kubernetes Cluster"
+            subgraph "Node 1"
+                Pod1[Pod: Service A<br/>Replicas: 3]
+                Pod2[Pod: Service B<br/>Replicas: 2]
+            end
+            subgraph "Node 2"
+                Pod3[Pod: Service C<br/>Replicas: 2]
+                Pod4[Pod: Service D<br/>Replicas: 1]
+            end
+        end
+        
+        LB[Load Balancer<br/>Ingress]
+        
+        subgraph "Data Tier"
+            DB[(PostgreSQL<br/>Primary)]
+            DBR[(PostgreSQL<br/>Read Replica)]
+            Cache[(Redis Cluster)]
+        end
+    end
+    
+    Internet[Internet] -->|HTTPS| LB
+    LB --> Pod1
+    LB --> Pod2
+    Pod1 --> DB
+    Pod2 --> Cache
+    Pod3 --> DB
+    Pod4 --> DBR"""
+        
+        return diagram
+    
+    def generate_all_diagrams(self) -> Dict[str, str]:
+        """Generate all C4 diagrams"""
+        diagrams = {
+            'context': self.generate_context_diagram(),
+            'container': self.generate_container_diagram(),
+            'deployment': self.generate_deployment_diagram()
+        }
+        
+        # Generate component diagrams for key services
+        key_services = [s for s in self.services 
+                       if any(key in s.get('name', '').lower() 
+                             for key in ['api', 'gateway', 'auth', 'user'])]
+        
+        for service in key_services[:3]:  # Limit to 3 component diagrams
+            service_name = service.get('name', 'unknown')
+            diagrams[f'component_{service_name}'] = self.generate_component_diagram(service_name)
+        
+        return diagrams
+
+def main():
+    parser = argparse.ArgumentParser(description='Generate C4 diagrams from service analysis')
+    parser.add_argument('--input', '-i', default='services.json', 
+                       help='Input services JSON file')
+    parser.add_argument('--output-dir', '-o', default='diagrams',
+                       help='Output directory for diagrams')
+    parser.add_argument('--format', '-f', choices=['mermaid', 'plantuml'], 
+                       default='mermaid', help='Output format')
+    
+    args = parser.parse_args()
+    
+    # Load services data
+    services_data = {'services': []}
+    if Path(args.input).exists():
+        with open(args.input) as f:
+            services_data = json.load(f)
+    else:
+        # Try to discover services if input doesn't exist
+        print(f"Input file {args.input} not found, using sample data")
+        services_data = {
+            'services': [
+                {'name': 'api-gateway', 'language': 'Node.js', 'framework': 'Express'},
+                {'name': 'user-service', 'language': 'Java', 'framework': 'Spring Boot'},
+                {'name': 'order-service', 'language': 'Python', 'framework': 'FastAPI'},
+            ]
+        }
+    
+    # Generate diagrams
+    generator = C4Generator(services_data)
+    diagrams = generator.generate_all_diagrams()
+    
+    # Create output directory
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(exist_ok=True)
+    
+    # Save diagrams
+    for name, content in diagrams.items():
+        output_file = output_dir / f"c4_{name}.md"
+        
+        # Wrap in markdown with title
+        markdown_content = f"""# C4 {name.replace('_', ' ').title()} Diagram
+
+```mermaid
+{content}
+```
+
+## Diagram Notes
+
+- **Confidence**: Relationships marked with solid lines are HIGH confidence
+- **External Systems**: Shown in gray boxes
+- **System Boundary**: Blue boxes indicate internal services
+- **Data Stores**: Cylinder shapes indicate databases and caches
+
+## How to Render
+
+1. Copy the mermaid code into any Mermaid-compatible viewer
+2. Or use in any Markdown file that supports Mermaid rendering
+3. Can be converted to SVG/PNG using Mermaid CLI tools
+"""
+        
+        with open(output_file, 'w') as f:
+            f.write(markdown_content)
+        
+        print(f"Generated {output_file}")
+    
+    # Also create an index file
+    index_content = """# C4 Architecture Diagrams
+
+## Generated Diagrams
+
+"""
+    for name in diagrams.keys():
+        title = name.replace('_', ' ').title()
+        index_content += f"- [{title}](c4_{name}.md)\n"
+    
+    with open(output_dir / "README.md", 'w') as f:
+        f.write(index_content)
+    
+    print(f"\nAll diagrams generated in {output_dir}/")
+    print(f"View index at {output_dir}/README.md")
+
+if __name__ == '__main__':
+    main()