aegis-stack 0.1.0__py3-none-any.whl

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/hooks.py

@@ -0,0 +1,133 @@
+# app/components/backend/hooks.py
+"""
+Backend-specific hook management system for drop-in extensibility.
+
+This system automatically discovers and registers:
+- Middleware from app/components/backend/middleware/
+- Startup hooks from app/components/backend/startup/
+- Shutdown hooks from app/components/backend/shutdown/
+
+Just drop files in the appropriate folders - no central registration required.
+"""
+
+from collections.abc import Callable
+import importlib
+import inspect
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+
+from app.core.log import logger
+
+
+class BackendHooks:
+    """Backend-specific hook management system."""
+
+    def __init__(self) -> None:
+        self.startup_hooks: list[Callable[[], Any]] = []
+        self.shutdown_hooks: list[Callable[[], Any]] = []
+
+    def discover_and_register_middleware(self, app: FastAPI) -> None:
+        """
+        Auto-discover and register middleware. This must be called
+        before the application starts.
+        """
+        middleware_dir = Path(__file__).parent / "middleware"
+        if not middleware_dir.exists():
+            return
+
+        for middleware_file in middleware_dir.glob("*.py"):
+            if middleware_file.name.startswith("_"):
+                continue
+
+            module_name = f"app.components.backend.middleware.{middleware_file.stem}"
+            try:
+                module = importlib.import_module(module_name)
+                if hasattr(module, "register_middleware"):
+                    logger.info(f"Registering middleware from {module_name}")
+                    # Middleware registration is synchronous
+                    module.register_middleware(app)
+            except Exception as e:
+                logger.error(f"Failed to load middleware {module_name}: {e}")
+
+    async def discover_lifespan_hooks(self) -> None:
+        """Discover startup and shutdown hooks for the lifespan event."""
+        await self._discover_startup_hooks()
+        await self._discover_shutdown_hooks()
+
+    async def _discover_startup_hooks(self) -> None:
+        """Auto-discover startup hooks from app/components/backend/startup/."""
+        startup_dir = Path(__file__).parent / "startup"
+        if not startup_dir.exists():
+            logger.info("No backend startup directory found")
+            return
+
+        for startup_file in startup_dir.glob("*.py"):
+            if startup_file.name.startswith("_"):
+                continue
+
+            module_name = f"app.components.backend.startup.{startup_file.stem}"
+            try:
+                module = importlib.import_module(module_name)
+
+                # Look for startup_hook function
+                if hasattr(module, "startup_hook"):
+                    logger.info(f"Registered startup hook from {module_name}")
+                    self.startup_hooks.append(module.startup_hook)
+
+            except Exception as e:
+                logger.error(f"Failed to load startup hook {module_name}: {e}")
+
+    async def _discover_shutdown_hooks(self) -> None:
+        """Auto-discover shutdown hooks from app/components/backend/shutdown/."""
+        shutdown_dir = Path(__file__).parent / "shutdown"
+        if not shutdown_dir.exists():
+            logger.info("No backend shutdown directory found")
+            return
+
+        for shutdown_file in shutdown_dir.glob("*.py"):
+            if shutdown_file.name.startswith("_"):
+                continue
+
+            module_name = f"app.components.backend.shutdown.{shutdown_file.stem}"
+            try:
+                module = importlib.import_module(module_name)
+
+                # Look for shutdown_hook function
+                if hasattr(module, "shutdown_hook"):
+                    logger.info(f"Registered shutdown hook from {module_name}")
+                    self.shutdown_hooks.append(module.shutdown_hook)
+
+            except Exception as e:
+                logger.error(f"Failed to load shutdown hook {module_name}: {e}")
+
+    async def execute_startup_hooks(self) -> None:
+        """Execute all discovered startup hooks."""
+        logger.info(f"Executing {len(self.startup_hooks)} backend startup hooks")
+        for hook in self.startup_hooks:
+            try:
+                if inspect.iscoroutinefunction(hook):
+                    await hook()
+                else:
+                    hook()
+            except Exception as e:
+                logger.error(f"Startup hook failed: {e}")
+                raise
+
+    async def execute_shutdown_hooks(self) -> None:
+        """Execute all discovered shutdown hooks in reverse order."""
+        logger.info(f"Executing {len(self.shutdown_hooks)} backend shutdown hooks")
+        for hook in reversed(self.shutdown_hooks):
+            try:
+                if inspect.iscoroutinefunction(hook):
+                    await hook()
+                else:
+                    hook()
+            except Exception as e:
+                logger.error(f"Shutdown hook failed: {e}")
+                # Continue with other shutdown hooks even if one fails
+
+
+# Global backend hooks instance
+backend_hooks = BackendHooks()

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/main.py

@@ -0,0 +1,16 @@
+from fastapi import FastAPI
+
+from app.components.backend.api.routing import include_routers
+from app.components.backend.hooks import backend_hooks
+
+
+def create_backend_app(app: FastAPI) -> FastAPI:
+    """Configure FastAPI app with all backend concerns"""
+
+    # Auto-discover and register middleware
+    backend_hooks.discover_and_register_middleware(app)
+
+    # Include all routes
+    include_routers(app)
+
+    return app

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/middleware/__init__.py

@@ -0,0 +1 @@
+# Backend middleware

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/middleware/cors.py

@@ -0,0 +1,20 @@
+# app/components/backend/middleware/cors.py
+"""
+Auto-discovered CORS middleware for development.
+
+This middleware is automatically registered with FastAPI when the backend starts.
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+
+def register_middleware(app: FastAPI) -> None:
+    """Auto-discovered middleware registration."""
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:3000", "http://localhost:8080"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/shutdown/__init__.py

@@ -0,0 +1 @@
+# Backend shutdown hooks

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/shutdown/cleanup.py

@@ -0,0 +1,14 @@
+# app/components/backend/shutdown/cleanup.py
+"""
+Auto-discovered cleanup shutdown hook.
+
+This hook performs cleanup when the backend shuts down.
+"""
+
+from app.core.log import logger
+
+
+async def shutdown_hook() -> None:
+    """Auto-discovered shutdown hook for cleanup."""
+    logger.info("🧹 Running backend cleanup...")
+    logger.info("✅ Backend shutdown cleanup complete")

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/startup/__init__.py

@@ -0,0 +1 @@
+# Backend startup hooks

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/startup/component_health.py.j2

@@ -0,0 +1,190 @@
+"""
+Component health registration startup hook.
+
+Automatically detects available components and registers their health checks
+with the system health service using Python's import system.
+"""
+
+from app.core.log import logger
+from app.services.system.health import register_health_check
+from app.services.system.models import ComponentStatus, ComponentStatusType
+
+
+async def _backend_component_health() -> ComponentStatus:
+    """
+    FastAPI backend health check.
+
+    In test environment, reports as healthy since the app is loaded.
+    In production, uses internal check to avoid circular dependency.
+    """
+    import os
+
+    # Check if we're in test environment
+    if os.getenv("PYTEST_CURRENT_TEST") or "pytest" in os.getenv("_", ""):
+        return ComponentStatus(
+            name="backend",
+            status=ComponentStatusType.HEALTHY,
+            message="FastAPI backend available (test mode)",
+            response_time_ms=None,
+            metadata={
+                "type": "component_check",
+                "environment": "test",
+                "note": "Backend component loaded successfully",
+            },
+        )
+
+    # In production, assume backend is healthy if we can execute this code
+    # (since this code IS the backend). Avoid self-HTTP-check circular dependency.
+    try:
+        # Simple internal health check - if we can import and run this, backend is up
+        from app.integrations.main import create_integrated_app
+        
+        return ComponentStatus(
+            name="backend",
+            status=ComponentStatusType.HEALTHY,
+            message="FastAPI backend active (internal check)",
+            response_time_ms=None,
+            metadata={
+                "type": "internal_component_check",
+                "note": "Backend is running since this health check executed",
+                "check_method": "internal_execution",
+            },
+        )
+    except Exception as e:
+        return ComponentStatus(
+            name="backend",
+            status=ComponentStatusType.UNHEALTHY,
+            message=f"Backend component check failed: {str(e)}",
+            response_time_ms=None,
+            metadata={
+                "type": "internal_component_check",
+                "error": "import_or_execution_error",
+                "error_details": str(e),
+            },
+        )
+
+
+async def _frontend_component_health() -> ComponentStatus:
+    """
+    Flet frontend health check.
+
+    Since the frontend runs in the same process as the backend,
+    we check if the frontend component is properly initialized.
+    """
+    try:
+        # Check if frontend component is available
+        from app.components.frontend.main import create_frontend_app
+
+        # Verify the frontend app factory function works
+        create_frontend_app()
+
+        return ComponentStatus(
+            name="frontend",
+            status=ComponentStatusType.HEALTHY,
+            message="Flet frontend component available",
+            response_time_ms=None,
+            metadata={
+                "type": "component_check",
+                "framework": "flet",
+                "note": "Frontend integrated with FastAPI",
+            },
+        )
+
+    except ImportError as e:
+        return ComponentStatus(
+            name="frontend",
+            status=ComponentStatusType.UNHEALTHY,
+            message="Frontend component not found",
+            response_time_ms=None,
+            metadata={
+                "type": "component_check",
+                "error": "import_error",
+                "error_details": str(e),
+            },
+        )
+    except Exception as e:
+        return ComponentStatus(
+            name="frontend",
+            status=ComponentStatusType.UNHEALTHY,
+            message=f"Frontend component error: {str(e)}",
+            response_time_ms=None,
+            metadata={
+                "type": "component_check",
+                "error": "unexpected_error",
+                "error_details": str(e),
+            },
+        )
+
+{%- if cookiecutter.include_scheduler == "yes" %}
+
+
+async def _scheduler_enabled_status() -> ComponentStatus:
+    """
+    Shows scheduler as an enabled/activated component.
+
+    This indicates the scheduler component is configured in the project
+    and running in its own container, but we can't health check it
+    without cross-container communication.
+    """
+    return ComponentStatus(
+        name="scheduler",
+        status=ComponentStatusType.HEALTHY,
+        message="Scheduler component activated",
+        response_time_ms=None,
+        metadata={
+            "type": "component_status",
+            "deployment": "separate_container",
+            "status": "activated",
+            "note": (
+                "Runs independently - health monitoring requires database "
+                "component"
+            ),
+        },
+    )
+{%- endif %}
+
+
+async def startup_hook() -> None:
+    """
+    Auto-detect available components and register their health checks.
+
+    Always registers core components (backend, frontend) and detects
+    optional components using Python's import system.
+    """
+    logger.info("Registering component health checks...")
+
+    # Always register core components
+    register_health_check("backend", _backend_component_health)
+    logger.info("Backend component health check registered")
+
+    register_health_check("frontend", _frontend_component_health)
+    logger.info("️Frontend component health check registered")
+
+    {%- if cookiecutter.include_scheduler == "yes" %}
+    # Register scheduler as enabled component (shows user it's activated)
+    register_health_check("scheduler", _scheduler_enabled_status)
+    logger.info("Scheduler component enabled (shows as activated)")
+    {%- endif %}
+
+    {%- if cookiecutter.include_worker == "yes" %}
+    # Register worker health check (shows queue status and job metrics)
+    from app.services.system.health import check_worker_health
+    register_health_check("worker", check_worker_health)
+    logger.info("Worker component health check registered")
+    {%- endif %}
+
+    {%- if cookiecutter.include_redis == "yes" %}
+    # Register cache health check (Redis connectivity and operations)
+    from app.services.system.health import check_cache_health
+    register_health_check("cache", check_cache_health)
+    logger.info("Cache component health check registered")
+    {%- endif %}
+
+    {%- if cookiecutter.include_database == "yes" %}
+    # Register database health check (SQLite connectivity and basic operations)
+    from app.services.system.health import check_database_health
+    register_health_check("database", check_database_health)
+    logger.info("Database component health check registered")
+    {%- endif %}
+
+    logger.info("✅ Component health detection complete")

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/frontend/core/__init__.py

@@ -0,0 +1 @@
+"""Frontend core utilities."""

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/frontend/core/theme.py

@@ -0,0 +1,46 @@
+"""Theme management for Flet frontend."""
+
+import flet as ft
+
+
+class ThemeManager:
+    """Manages theme configuration for the Flet application."""
+    
+    def __init__(self, page: ft.Page) -> None:
+        """Initialize theme manager with page reference."""
+        self.page = page
+        self.is_dark_mode = False
+    
+    async def initialize_themes(self) -> None:
+        """Initialize the theme system."""
+        # Set initial light theme
+        self.page.theme = self.get_theme()
+        self.page.theme_mode = ft.ThemeMode.LIGHT
+        self.is_dark_mode = False
+    
+    async def toggle_theme(self) -> None:
+        """Toggle between light and dark themes."""
+        if self.is_dark_mode:
+            self.page.theme = self.get_theme()
+            self.page.theme_mode = ft.ThemeMode.LIGHT
+            self.is_dark_mode = False
+        else:
+            self.page.theme = self.get_dark_theme()
+            self.page.theme_mode = ft.ThemeMode.DARK
+            self.is_dark_mode = True
+        
+        self.page.update()
+    
+    @staticmethod
+    def get_theme() -> ft.Theme:
+        """Get the default light theme configuration."""
+        return ft.Theme(
+            color_scheme_seed=ft.Colors.BLUE,
+        )
+    
+    @staticmethod 
+    def get_dark_theme() -> ft.Theme:
+        """Get the dark theme configuration."""
+        return ft.Theme(
+            color_scheme_seed=ft.Colors.BLUE,
+        )