198 lines
9.6 KiB
Python
198 lines
9.6 KiB
Python
from typing import Dict, Any
|
|
from loguru import logger
|
|
from datetime import datetime
|
|
|
|
class ArchitectureCombiner:
|
|
"""Combines outputs from technology specialists into unified architecture"""
|
|
|
|
def __init__(self):
|
|
logger.info("Architecture Combiner initialized")
|
|
|
|
def combine_architecture_outputs(self, frontend_result: Dict, backend_result: Dict,
|
|
database_result: Dict, tech_stack: Any) -> Dict[str, Any]:
|
|
"""Combine specialist outputs into unified architecture design"""
|
|
try:
|
|
logger.info("🔄 Combining specialist architecture outputs...")
|
|
|
|
combined = {
|
|
"architecture_overview": {
|
|
"technology_stack": {
|
|
"frontend": tech_stack.frontend_framework,
|
|
"backend": tech_stack.backend_language,
|
|
"database": tech_stack.database_system,
|
|
"ui_library": tech_stack.ui_library,
|
|
"state_management": tech_stack.state_management,
|
|
"authentication": tech_stack.authentication
|
|
},
|
|
"specialists_used": {
|
|
"frontend_specialist": frontend_result.get('specialist', 'Unknown'),
|
|
"backend_specialist": backend_result.get('specialist', 'Unknown'),
|
|
"database_specialist": database_result.get('specialist', 'Unknown')
|
|
},
|
|
"design_patterns": self._extract_design_patterns(frontend_result, backend_result, database_result)
|
|
},
|
|
|
|
"frontend_architecture": self._extract_frontend_architecture(frontend_result),
|
|
"backend_architecture": self._extract_backend_architecture(backend_result),
|
|
"database_architecture": self._extract_database_architecture(database_result),
|
|
|
|
"integrated_features": self._create_integrated_features(frontend_result, backend_result, database_result),
|
|
"deployment_configuration": self._create_deployment_config(tech_stack),
|
|
"development_workflow": self._create_development_workflow(tech_stack)
|
|
}
|
|
|
|
logger.info("✅ Architecture combination completed")
|
|
return combined
|
|
|
|
except Exception as e:
|
|
logger.error(f"❌ Architecture combination failed: {e}")
|
|
return self._create_fallback_combined_architecture(tech_stack)
|
|
|
|
def _extract_frontend_architecture(self, frontend_result: Dict) -> Dict:
|
|
"""Extract frontend architecture from specialist result"""
|
|
if not frontend_result.get('success'):
|
|
return {"error": "Frontend architecture generation failed"}
|
|
|
|
architecture = frontend_result.get('architecture', {})
|
|
|
|
return {
|
|
"framework": frontend_result.get('specialist', 'React'),
|
|
"folder_structure": architecture.get('folder_structure', {}),
|
|
"components": architecture.get('components', {}),
|
|
"routing": architecture.get('routing', {}),
|
|
"state_management": architecture.get('state_management', {}),
|
|
"styling": architecture.get('styling', {}),
|
|
"patterns": frontend_result.get('patterns_used', [])
|
|
}
|
|
|
|
def _extract_backend_architecture(self, backend_result: Dict) -> Dict:
|
|
"""Extract backend architecture from specialist result"""
|
|
if not backend_result.get('success'):
|
|
return {"error": "Backend architecture generation failed"}
|
|
|
|
architecture = backend_result.get('architecture', {})
|
|
|
|
return {
|
|
"framework": f"{backend_result.get('specialist', 'Node.js')}/{backend_result.get('framework', 'Express')}",
|
|
"folder_structure": architecture.get('folder_structure', {}),
|
|
"api_endpoints": architecture.get('api_endpoints', {}),
|
|
"middleware": architecture.get('middleware', {}),
|
|
"authentication": architecture.get('authentication', {}),
|
|
"error_handling": architecture.get('error_handling', {}),
|
|
"patterns": backend_result.get('patterns_used', [])
|
|
}
|
|
|
|
def _extract_database_architecture(self, database_result: Dict) -> Dict:
|
|
"""Extract database architecture from specialist result"""
|
|
if not database_result.get('success'):
|
|
return {"error": "Database architecture generation failed"}
|
|
|
|
architecture = database_result.get('architecture', {})
|
|
|
|
return {
|
|
"database_system": database_result.get('specialist', 'PostgreSQL'),
|
|
"schema": architecture.get('database_schema', {}),
|
|
"configuration": architecture.get('database_configuration', {}),
|
|
"features": architecture.get('postgresql_features', {}),
|
|
"backup_strategy": architecture.get('backup_strategy', {}),
|
|
"security": architecture.get('security_implementation', {})
|
|
}
|
|
|
|
def _extract_design_patterns(self, frontend_result: Dict, backend_result: Dict, database_result: Dict) -> Dict:
|
|
"""Extract design patterns used across all specialists"""
|
|
return {
|
|
"frontend_patterns": frontend_result.get('patterns_used', []),
|
|
"backend_patterns": backend_result.get('patterns_used', []),
|
|
"database_patterns": database_result.get('features_used', []),
|
|
"integration_patterns": [
|
|
"RESTful API communication",
|
|
"JWT-based authentication",
|
|
"Error boundary handling",
|
|
"Optimistic UI updates"
|
|
]
|
|
}
|
|
|
|
def _create_integrated_features(self, frontend_result: Dict, backend_result: Dict, database_result: Dict) -> Dict:
|
|
"""Create integrated features that span multiple layers"""
|
|
return {
|
|
"authentication_flow": {
|
|
"frontend": "Login form with validation and token storage",
|
|
"backend": "JWT token generation and verification middleware",
|
|
"database": "User table with secure password hashing"
|
|
},
|
|
"data_flow": {
|
|
"frontend": "React components with state management",
|
|
"backend": "Express API with validation and business logic",
|
|
"database": "PostgreSQL with optimized queries and indexes"
|
|
},
|
|
"error_handling": {
|
|
"frontend": "Error boundaries and user-friendly error messages",
|
|
"backend": "Structured error responses with proper HTTP codes",
|
|
"database": "Constraint violations and connection error handling"
|
|
}
|
|
}
|
|
|
|
def _create_deployment_config(self, tech_stack: Any) -> Dict:
|
|
"""Create deployment configuration"""
|
|
return {
|
|
"containerization": {
|
|
"frontend": f"Multi-stage Docker build for {tech_stack.frontend_framework}",
|
|
"backend": f"Node.js Docker container with production optimizations",
|
|
"database": "PostgreSQL container with persistent volumes"
|
|
},
|
|
"environment_variables": {
|
|
"frontend": ["REACT_APP_API_URL", "REACT_APP_ENVIRONMENT"],
|
|
"backend": ["NODE_ENV", "PORT", "DATABASE_URL", "JWT_SECRET"],
|
|
"database": ["POSTGRES_DB", "POSTGRES_USER", "POSTGRES_PASSWORD"]
|
|
},
|
|
"cloud_deployment": {
|
|
"provider": tech_stack.cloud_provider,
|
|
"frontend_hosting": "Static site hosting (Vercel, Netlify)",
|
|
"backend_hosting": "Container service (AWS ECS, Google Cloud Run)",
|
|
"database_hosting": "Managed PostgreSQL service"
|
|
}
|
|
}
|
|
|
|
def _create_development_workflow(self, tech_stack: Any) -> Dict:
|
|
"""Create development workflow configuration"""
|
|
return {
|
|
"development_setup": {
|
|
"frontend": f"Create {tech_stack.frontend_framework} app with {tech_stack.ui_library}",
|
|
"backend": "Node.js with Express and TypeScript",
|
|
"database": "Local PostgreSQL with Docker"
|
|
},
|
|
"testing_strategy": {
|
|
"frontend": "Jest + React Testing Library for component testing",
|
|
"backend": "Jest + Supertest for API testing",
|
|
"database": "Database migrations and seed data for testing"
|
|
},
|
|
"build_process": {
|
|
"frontend": "Vite/Webpack build with code splitting",
|
|
"backend": "TypeScript compilation and bundling",
|
|
"database": "Migration scripts and schema validation"
|
|
}
|
|
}
|
|
|
|
def _create_fallback_combined_architecture(self, tech_stack: Any) -> Dict:
|
|
"""Create fallback combined architecture"""
|
|
logger.warning("Using fallback combined architecture")
|
|
|
|
return {
|
|
"architecture_overview": {
|
|
"technology_stack": tech_stack.__dict__,
|
|
"note": "Fallback architecture due to specialist failures"
|
|
},
|
|
"frontend_architecture": {
|
|
"framework": tech_stack.frontend_framework,
|
|
"basic_setup": "Standard React application with components"
|
|
},
|
|
"backend_architecture": {
|
|
"framework": f"{tech_stack.backend_language}/Express",
|
|
"basic_setup": "Standard Express API with authentication"
|
|
},
|
|
"database_architecture": {
|
|
"database_system": tech_stack.database_system,
|
|
"basic_setup": "Standard PostgreSQL with user table"
|
|
}
|
|
}
|