aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/core/service_resolver.py

@@ -0,0 +1,261 @@
+"""
+Service dependency resolution for Aegis Stack.
+
+This module handles service dependency resolution, converting service selections
+to their required components and validating service-to-component compatibility.
+"""
+
+from .dependency_resolver import DependencyResolver
+from .services import SERVICES, get_service_dependencies
+
+
+class ServiceResolver:
+    """Handles service dependency resolution and validation."""
+
+    @staticmethod
+    def resolve_service_dependencies(
+        selected_services: list[str],
+    ) -> tuple[list[str], list[str]]:
+        """
+        Resolve services to their required components.
+
+        Args:
+            selected_services: List of service names selected by user
+
+        Returns:
+            Tuple of (resolved_components, service_added_components)
+            - resolved_components: All components needed (including auto-added)
+            - service_added_components: Components that were added due to services
+
+        Raises:
+            ValueError: If any selected services are invalid
+        """
+        # Validate services first
+        errors = ServiceResolver.validate_services(selected_services)
+        if errors:
+            raise ValueError(f"Invalid services: {'; '.join(errors)}")
+
+        # Collect all components required by services
+        service_required_components = set()
+        for service_name in selected_services:
+            service_deps = get_service_dependencies(service_name)
+            service_required_components.update(service_deps)
+
+        # Convert to list and resolve component-to-component dependencies
+        component_list = list(service_required_components)
+        resolved_components = DependencyResolver.resolve_dependencies(component_list)
+
+        # The service_added_components are what services directly require
+        # (This represents what gets auto-added when services are selected)
+        service_added_components = sorted(service_required_components)
+
+        return resolved_components, service_added_components
+
+    @staticmethod
+    def validate_services(services: list[str]) -> list[str]:
+        """
+        Validate service selection and return errors.
+
+        Args:
+            services: List of service names to validate
+
+        Returns:
+            List of error messages (empty if valid)
+        """
+        errors = []
+
+        for service in services:
+            if service not in SERVICES:
+                errors.append(f"Unknown service: {service}")
+                continue
+
+            spec = SERVICES[service]
+
+            # Check service conflicts
+            if spec.conflicts:
+                for conflict in spec.conflicts:
+                    if conflict in services:
+                        errors.append(
+                            f"Service '{service}' conflicts with service '{conflict}'"
+                        )
+
+        # Check for service-to-service dependencies
+        for service in services:
+            if service not in SERVICES:
+                continue  # Already reported above
+
+            spec = SERVICES[service]
+            if spec.required_services:
+                for required_service in spec.required_services:
+                    if required_service not in services:
+                        errors.append(
+                            f"Service '{service}' requires service '{required_service}'"
+                        )
+
+        return errors
+
+    @staticmethod
+    def get_missing_components_for_services(
+        selected_services: list[str], available_components: list[str]
+    ) -> list[str]:
+        """
+        Get components that need to be added for the selected services.
+
+        Args:
+            selected_services: List of service names
+            available_components: List of already available components
+
+        Returns:
+            List of component names that need to be added
+        """
+        if not selected_services:
+            return []
+
+        try:
+            resolved_components, _ = ServiceResolver.resolve_service_dependencies(
+                selected_services
+            )
+            missing = set(resolved_components) - set(available_components)
+            return sorted(missing)
+        except ValueError:
+            # If services are invalid, return empty list
+            return []
+
+    @staticmethod
+    def validate_service_component_compatibility(
+        selected_services: list[str], available_components: list[str]
+    ) -> list[str]:
+        """
+        Validate that all required components are available for selected services.
+
+        Args:
+            selected_services: List of service names
+            available_components: List of available component names
+
+        Returns:
+            List of error messages (empty if compatible)
+        """
+        errors = []
+
+        # First validate the services themselves
+        service_errors = ServiceResolver.validate_services(selected_services)
+        errors.extend(service_errors)
+
+        # Then check component dependencies
+        for service_name in selected_services:
+            if service_name not in SERVICES:
+                continue  # Already reported in service validation
+
+            service_deps = get_service_dependencies(service_name)
+            for required_comp in service_deps:
+                if required_comp not in available_components:
+                    errors.append(
+                        f"Service '{service_name}' requires component '{required_comp}'"
+                    )
+
+        return errors
+
+    @staticmethod
+    def get_service_component_summary(
+        selected_services: list[str],
+    ) -> dict[str, list[str]]:
+        """
+        Get a summary of what components each service requires.
+
+        Args:
+            selected_services: List of service names
+
+        Returns:
+            Dictionary mapping service names to their required components
+        """
+        summary = {}
+
+        for service_name in selected_services:
+            if service_name in SERVICES:
+                summary[service_name] = get_service_dependencies(service_name)
+            else:
+                summary[service_name] = []  # Unknown service
+
+        return summary
+
+    @staticmethod
+    def recommend_components_for_services(selected_services: list[str]) -> list[str]:
+        """
+        Get recommended (but not required) components for selected services.
+
+        Args:
+            selected_services: List of service names
+
+        Returns:
+            List of recommended component names
+        """
+        recommendations = set()
+
+        for service_name in selected_services:
+            if service_name not in SERVICES:
+                continue
+
+            spec = SERVICES[service_name]
+            if spec.recommended_components:
+                recommendations.update(spec.recommended_components)
+
+        return sorted(recommendations)
+
+    @staticmethod
+    def get_services_requiring_component(component_name: str) -> list[str]:
+        """
+        Get list of services that require a specific component.
+
+        Args:
+            component_name: Name of the component
+
+        Returns:
+            List of service names that require this component
+        """
+        requiring_services = []
+
+        for service_name, spec in SERVICES.items():
+            if component_name in spec.required_components:
+                requiring_services.append(service_name)
+
+        return requiring_services
+
+    @staticmethod
+    def merge_service_and_component_selections(
+        selected_services: list[str], selected_components: list[str]
+    ) -> tuple[list[str], list[str], list[str]]:
+        """
+        Merge service and component selections, resolving all dependencies.
+
+        Args:
+            selected_services: List of service names
+            selected_components: List of component names
+
+        Returns:
+            Tuple of (final_components, auto_added_from_services, auto_added_from_components)
+            - final_components: Final list of all components
+            - auto_added_from_services: Components added due to service requirements
+            - auto_added_from_components: Components added due to component dependencies
+
+        Raises:
+            ValueError: If services or components are invalid
+        """
+        # Resolve service dependencies first
+        service_components, service_auto_added = (
+            ServiceResolver.resolve_service_dependencies(selected_services)
+        )
+
+        # Combine with explicitly selected components
+        all_components = list(set(selected_components + service_components))
+
+        # Resolve final component dependencies
+        final_components = DependencyResolver.resolve_dependencies(all_components)
+
+        # Calculate what was auto-added from component dependencies
+        component_auto_added = set(final_components) - set(all_components)
+
+        return (
+            final_components,
+            sorted(service_auto_added),
+            sorted(component_auto_added),
+        )

aegis/core/services.py

@@ -0,0 +1,157 @@
+"""
+Service registry and specifications for Aegis Stack.
+
+This module defines all available services (auth, payment, AI, etc.), their dependencies,
+and metadata used for project generation and validation.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ServiceType(Enum):
+    """Service type classifications."""
+
+    AUTH = "auth"  # Authentication and authorization
+    PAYMENT = "payment"  # Payment processing
+    AI = "ai"  # AI and ML integrations
+    NOTIFICATION = "notification"  # Email, SMS, push notifications
+    ANALYTICS = "analytics"  # Usage analytics and metrics
+    STORAGE = "storage"  # File storage and CDN
+
+
+@dataclass
+class ServiceSpec:
+    """Specification for a single service."""
+
+    name: str
+    type: ServiceType
+    description: str
+    required_components: list[str] = field(
+        default_factory=list
+    )  # Components this service needs
+    recommended_components: list[str] = field(
+        default_factory=list
+    )  # Soft component dependencies
+    required_services: list[str] = field(
+        default_factory=list
+    )  # Other services this service needs
+    conflicts: list[str] = field(default_factory=list)  # Mutual exclusions
+    pyproject_deps: list[str] = field(
+        default_factory=list
+    )  # Python packages for this service
+    template_files: list[str] = field(default_factory=list)  # Template files to include
+
+
+# Service registry - single source of truth for all available services
+SERVICES: dict[str, ServiceSpec] = {
+    "auth": ServiceSpec(
+        name="auth",
+        type=ServiceType.AUTH,
+        description="User authentication and authorization with JWT tokens",
+        required_components=["backend", "database"],
+        pyproject_deps=[
+            "python-jose[cryptography]==3.3.0",
+            "passlib[bcrypt]==1.7.4",
+            "python-multipart==0.0.9",  # For form data parsing
+        ],
+        template_files=[
+            "app/components/backend/api/auth/",
+            "app/models/user.py",
+            "app/services/auth/",
+            "app/core/security.py",
+        ],
+    ),
+    "ai": ServiceSpec(
+        name="ai",
+        type=ServiceType.AI,
+        description="AI chatbot service with PydanticAI engine",
+        required_components=["backend"],
+        pyproject_deps=[
+            "pydantic-ai-slim[{AI_PROVIDERS}]==1.0.10",  # Dynamic providers
+            "httpx>=0.27.0",  # For API providers
+        ],
+        template_files=[
+            "app/services/ai/",
+            "app/cli/ai.py",
+            "app/components/backend/api/ai/",
+        ],
+    ),
+    # Future services will be added here:
+    # "payment_stripe": ServiceSpec(...),
+    # "notification_email": ServiceSpec(...),
+}
+
+
+def get_service(name: str) -> ServiceSpec:
+    """Get service specification by name."""
+    if name not in SERVICES:
+        raise ValueError(f"Unknown service: {name}")
+    return SERVICES[name]
+
+
+def get_services_by_type(service_type: ServiceType) -> dict[str, ServiceSpec]:
+    """Get all services of a specific type."""
+    return {name: spec for name, spec in SERVICES.items() if spec.type == service_type}
+
+
+def list_available_services() -> list[str]:
+    """Get list of all available service names."""
+    return list(SERVICES.keys())
+
+
+def get_service_dependencies(service_name: str) -> list[str]:
+    """
+    Get all required components for a service.
+
+    Args:
+        service_name: Name of the service
+
+    Returns:
+        List of component names required by this service
+    """
+    if service_name not in SERVICES:
+        return []
+
+    service = SERVICES[service_name]
+    return service.required_components.copy()
+
+
+def validate_service_dependencies(
+    selected_services: list[str], available_components: list[str]
+) -> list[str]:
+    """
+    Validate that all required components are available for selected services.
+
+    Args:
+        selected_services: List of service names to validate
+        available_components: List of available component names
+
+    Returns:
+        List of error messages (empty if valid)
+    """
+    errors = []
+
+    for service_name in selected_services:
+        if service_name not in SERVICES:
+            errors.append(f"Unknown service: {service_name}")
+            continue
+
+        service = SERVICES[service_name]
+
+        # Check required components
+        for required_comp in service.required_components:
+            if required_comp not in available_components:
+                errors.append(
+                    f"Service '{service_name}' requires component '{required_comp}'"
+                )
+
+        # Check service conflicts
+        if service.conflicts:
+            for conflict in service.conflicts:
+                if conflict in selected_services:
+                    errors.append(
+                        f"Service '{service_name}' conflicts with service '{conflict}'"
+                    )
+
+    return errors

aegis/core/template_generator.py

@@ -0,0 +1,266 @@
+"""
+Template generation and context building for Aegis Stack projects.
+
+This module handles the generation of cookiecutter context and manages
+the template rendering process based on selected components.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from .component_utils import extract_base_component_name, extract_engine_info
+from .components import COMPONENTS, CORE_COMPONENTS, SchedulerBackend
+from .services import SERVICES
+
+
+class TemplateGenerator:
+    """Handles template context generation for cookiecutter."""
+
+    def __init__(
+        self,
+        project_name: str,
+        selected_components: list[str],
+        scheduler_backend: str = SchedulerBackend.MEMORY.value,
+        selected_services: list[str] | None = None,
+    ):
+        """
+        Initialize template generator.
+
+        Args:
+            project_name: Name of the project being generated
+            selected_components: List of component names to include
+            scheduler_backend: Scheduler backend: memory, sqlite, or postgres
+            selected_services: List of service names to include
+        """
+        self.project_name = project_name
+        self.project_slug = project_name.lower().replace(" ", "-").replace("_", "-")
+        self.scheduler_backend = scheduler_backend
+        self.selected_services = selected_services or []
+
+        # Always include core components
+        all_components = CORE_COMPONENTS + selected_components
+
+        # Add required components from selected services
+        for service_name in self.selected_services:
+            if service_name in SERVICES:
+                service_spec = SERVICES[service_name]
+                all_components.extend(service_spec.required_components)
+
+        # Remove duplicates, preserve order
+        self.components = list(dict.fromkeys(all_components))
+
+        # Extract database engine from database[engine] format for template context
+        self.database_engine = None
+        for component in self.components:
+            if extract_base_component_name(component) == "database":
+                self.database_engine = extract_engine_info(component)
+                if self.database_engine:
+                    break
+
+        # Extract scheduler backend from scheduler[backend] format or use passed param
+        # If scheduler[backend] syntax is used, it overrides the passed parameter
+        for component in self.components:
+            if extract_base_component_name(component) == "scheduler":
+                backend = extract_engine_info(component)
+                if backend:
+                    self.scheduler_backend = backend
+                    break
+
+        # Build component specs using base names
+        self.component_specs = {}
+        for name in self.components:
+            base_name = extract_base_component_name(name)
+            if base_name in COMPONENTS:
+                self.component_specs[base_name] = COMPONENTS[base_name]
+
+    def get_template_context(self) -> dict[str, Any]:
+        """
+        Generate cookiecutter context from components.
+
+        Returns:
+            Dictionary containing all template variables
+        """
+        # Store the originally selected components (without core)
+        selected_only = [c for c in self.components if c not in CORE_COMPONENTS]
+
+        # Check for components using base names
+        has_database = any(c.startswith("database") for c in self.components)
+
+        return {
+            "project_name": self.project_name,
+            "project_slug": self.project_slug,
+            # Component flags for template conditionals - cookiecutter needs yes/no
+            "include_redis": "yes" if "redis" in self.components else "no",
+            "include_worker": "yes" if "worker" in self.components else "no",
+            "include_scheduler": "yes"
+            if any(c.startswith("scheduler") for c in self.components)
+            else "no",
+            "include_database": "yes" if has_database else "no",
+            # Database engine selection
+            "database_engine": self.database_engine or "sqlite",
+            # Scheduler backend selection
+            "scheduler_backend": self.scheduler_backend,
+            # Legacy scheduler persistence flag for backwards compatibility
+            "scheduler_with_persistence": (
+                "yes"
+                if self.scheduler_backend != SchedulerBackend.MEMORY.value
+                else "no"
+            ),
+            # Derived flags for template logic
+            "has_background_infrastructure": any(
+                name in self.components for name in ["worker", "scheduler"]
+            ),
+            "needs_redis": "redis" in self.components,
+            # Service flags for template conditionals
+            "include_auth": "yes" if "auth" in self.selected_services else "no",
+            "include_ai": "yes" if "ai" in self.selected_services else "no",
+            # AI provider selection for dynamic dependency generation
+            "ai_providers": self._get_ai_providers_string(),
+            # Dependency lists for templates
+            "selected_components": selected_only,  # Original selection for context
+            "docker_services": self._get_docker_services(),
+            "pyproject_dependencies": self._get_pyproject_deps(),
+        }
+
+    def _get_docker_services(self) -> list[str]:
+        """
+        Collect all docker services needed.
+
+        Returns:
+            List of docker service names
+        """
+        services = []
+        for component_name in self.components:
+            if component_name in self.component_specs:
+                spec = self.component_specs[component_name]
+                if spec.docker_services:
+                    services.extend(spec.docker_services)
+        return list(dict.fromkeys(services))  # Preserve order, remove duplicates
+
+    def _get_pyproject_deps(self) -> list[str]:
+        """
+        Collect all Python dependencies.
+
+        Returns:
+            Sorted list of Python package dependencies
+        """
+        deps = []
+        # Collect component dependencies
+        for component_name in self.components:
+            if component_name in self.component_specs:
+                spec = self.component_specs[component_name]
+                if spec.pyproject_deps:
+                    deps.extend(spec.pyproject_deps)
+
+        # Collect service dependencies
+        for service_name in self.selected_services:
+            if service_name in SERVICES:
+                service_spec = SERVICES[service_name]
+                if service_spec.pyproject_deps:
+                    # Process service dependencies with dynamic substitution
+                    for dep in service_spec.pyproject_deps:
+                        if service_name == "ai" and "{AI_PROVIDERS}" in dep:
+                            # Substitute AI providers dynamically
+                            providers = self._get_ai_providers_string()
+                            dep = dep.replace("{AI_PROVIDERS}", providers)
+                        deps.append(dep)
+
+        return sorted(set(deps))  # Sort and deduplicate
+
+    def get_template_files(self) -> list[str]:
+        """
+        Get list of template files that should be included.
+
+        Returns:
+            List of template file paths
+        """
+        files = []
+        # Collect component template files
+        for component_name in self.components:
+            base_name = extract_base_component_name(component_name)
+            if base_name in self.component_specs:
+                spec = self.component_specs[base_name]
+                if spec.template_files:
+                    files.extend(spec.template_files)
+
+        # Collect service template files
+        for service_name in self.selected_services:
+            if service_name in SERVICES:
+                service_spec = SERVICES[service_name]
+                if service_spec.template_files:
+                    files.extend(service_spec.template_files)
+
+        return list(dict.fromkeys(files))  # Preserve order, remove duplicates
+
+    def _get_ai_providers_string(self) -> str:
+        """
+        Get AI providers as comma-separated string for pydantic-ai-slim dependency.
+
+        Returns:
+            Comma-separated string of provider names (e.g., "openai,anthropic,google")
+        """
+        if "ai" not in self.selected_services:
+            return "openai"  # Default for PUBLIC provider
+
+        # Import here to avoid circular imports
+        from ..cli.interactive import get_ai_provider_selection
+
+        providers = get_ai_provider_selection("ai")
+        return ",".join(providers)
+
+    def get_entrypoints(self) -> list[str]:
+        """
+        Get list of entrypoints that will be created.
+
+        Returns:
+            List of entrypoint file paths
+        """
+        entrypoints = ["app/entrypoints/webserver.py"]  # Always included
+
+        # Check component specs for actual entrypoint files
+        for component_name in self.components:
+            base_name = extract_base_component_name(component_name)
+            if base_name in self.component_specs:
+                spec = self.component_specs[base_name]
+                if spec.template_files:
+                    for template_file in spec.template_files:
+                        if (
+                            template_file.startswith("app/entrypoints/")
+                            and template_file not in entrypoints
+                        ):
+                            entrypoints.append(template_file)
+
+        return entrypoints
+
+    def get_worker_queues(self) -> list[str]:
+        """
+        Get list of worker queue files that will be created.
+
+        Returns:
+            List of worker queue file paths
+        """
+        queues: list[str] = []
+
+        # Only check if worker component is included
+        if not any(c.startswith("worker") for c in self.components):
+            return queues
+
+        # Discover queue files from the template directory
+        template_root = (
+            Path(__file__).parent.parent / "templates" / "cookiecutter-aegis-project"
+        )
+        worker_queues_dir = (
+            template_root
+            / "{{cookiecutter.project_slug}}"
+            / "app"
+            / "components"
+            / "worker"
+            / "queues"
+        )
+
+        if worker_queues_dir.exists():
+            for queue_file in worker_queues_dir.glob("*.py"):
+                if queue_file.stem != "__init__":
+                    queues.append(f"app/components/worker/queues/{queue_file.name}")
+
+        return sorted(queues)