aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/backend/startup/database_init.py.jinja

@@ -0,0 +1,83 @@
+"""
+Database initialization startup hook.
+
+Ensures database directory structure exists and verifies connectivity
+when the backend starts up (only when database component is included).
+"""
+{% if include_database %}
+
+from pathlib import Path
+from app.core.db import init_database
+from app.core.log import logger
+
+{% if include_auth %}
+# Import models to register them with SQLModel metadata
+from app.models.user import User  # noqa: F401
+{% endif %}
+
+
+async def startup_database_init() -> None:
+    """
+    Initialize database directory structure and verify connectivity.
+
+    This hook runs when the backend starts to ensure the database
+    directory exists and connection works. For auth service projects,
+    migrations should already be applied during project generation.
+    """
+    try:
+        # Ensure database directory exists
+        from app.core.db import DATABASE_PATH
+        db_path = Path(DATABASE_PATH)
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        {% if include_auth %}
+        # Auth service - verify database and migration status
+        try:
+            from app.core.db import db_session
+            from sqlmodel import select, func, text
+            from sqlalchemy import inspect
+
+            with db_session(autocommit=False) as session:
+                # Check 1: Basic database connectivity
+                session.exec(text("SELECT 1"))
+
+                # Check 2: Auth tables exist (User table specifically)
+                session.exec(select(func.count()).select_from(User))
+
+                # Check 3: Alembic migration system is set up
+                inspector = inspect(session.connection())
+                table_names = inspector.get_table_names()
+
+                if "alembic_version" in table_names:
+                    logger.info(
+                        "✅ Database connectivity and auth schema verified "
+                        "(migrations applied)"
+                    )
+                else:
+                    logger.warning(
+                        "⚠️  alembic_version table missing - migrations may not be "
+                        "fully applied"
+                    )
+                    logger.warning(
+                        "💡 Run 'alembic upgrade head' to ensure all migrations "
+                        "are applied"
+                    )
+
+        except Exception as e:
+            logger.warning(f"⚠️  Database check failed: {e}")
+            logger.warning("💡 Run 'alembic upgrade head' to apply migrations")
+            # Don't fail startup - let the app run and show clear errors
+        {% else %}
+        # Database component only - ensure tables exist
+        init_database()
+        logger.info("🗃️  Database initialization completed")
+        {% endif %}
+
+    except Exception as e:
+        logger.error(f"❌ Database initialization failed: {e}")
+        raise
+
+
+# Export the startup hook function
+startup_hook = startup_database_init
+{% endif %}

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

@@ -0,0 +1,5 @@
+"""Simple Flet frontend dashboard component."""
+
+from .main import create_frontend_app
+
+__all__ = ["create_frontend_app"]

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/frontend/controls/__init__.py

@@ -0,0 +1,27 @@
+"""Frontend UI controls for styled components."""
+
+from .table import (
+    TableCellText,
+    TableHeaderText,
+    TableNameText,
+)
+from .text import (
+    ConfirmationText,
+    LabelText,
+    MetricText,
+    PrimaryText,
+    SecondaryText,
+    TitleText,
+)
+
+__all__ = [
+    "PrimaryText",
+    "SecondaryText",
+    "TitleText",
+    "ConfirmationText",
+    "MetricText",
+    "LabelText",
+    "TableHeaderText",
+    "TableCellText",
+    "TableNameText",
+]

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/frontend/controls/table.py

@@ -0,0 +1,78 @@
+"""
+Table-specific text controls for consistent styling across cards.
+
+These controls provide standardized text styling for table headers, cells, and
+entity names to ensure consistency between worker, database, and other component cards.
+"""
+
+from typing import Any
+
+import flet as ft
+
+
+class TableHeaderText(ft.Text):  # type: ignore[misc]
+    """
+    Table header text control with consistent styling.
+
+    Used for column headers in component cards. Provides medium weight text
+    with reduced opacity for visual hierarchy.
+    """
+
+    def __init__(self, text: str, **kwargs: Any) -> None:
+        # Set defaults that can be overridden
+        defaults = {
+            "weight": ft.FontWeight.W_500,
+            "size": 12,
+            "color": ft.Colors.GREY_600,
+        }
+        defaults.update(kwargs)
+
+        super().__init__(
+            text,
+            **defaults,
+        )
+
+
+class TableCellText(ft.Text):  # type: ignore[misc]
+    """
+    Table cell text control for data values.
+
+    Used for displaying data values in table cells. Provides consistent
+    sizing and coloring for tabular data.
+    """
+
+    def __init__(self, text: str, **kwargs: Any) -> None:
+        # Set defaults that can be overridden
+        defaults = {
+            "size": 11,
+            "color": ft.Colors.ON_SURFACE,
+        }
+        defaults.update(kwargs)
+
+        super().__init__(
+            text,
+            **defaults,
+        )
+
+
+class TableNameText(ft.Text):  # type: ignore[misc]
+    """
+    Table entity name text control.
+
+    Used for displaying entity names (queues, tables, etc.) in table rows.
+    Provides consistent styling for entity identifiers.
+    """
+
+    def __init__(self, text: str, **kwargs: Any) -> None:
+        # Set defaults that can be overridden
+        defaults = {
+            "weight": ft.FontWeight.W_400,
+            "size": 11,
+            "color": ft.Colors.ON_SURFACE,
+        }
+        defaults.update(kwargs)
+
+        super().__init__(
+            text,
+            **defaults,
+        )

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/frontend/controls/text.py

@@ -0,0 +1,142 @@
+"""
+Custom text controls with proper theme-aware styling.
+
+These components automatically use semantic Flet colors that adapt to light/dark themes,
+following the same patterns as ee-toolset for consistent visual design.
+"""
+
+from typing import Any
+
+import flet as ft
+
+
+class PrimaryText(ft.Text):  # type: ignore[misc]
+    """
+    Primary text component using theme-aware ON_SURFACE color.
+
+    Automatically adapts to light/dark themes with proper contrast.
+    Use for main content text, labels, and primary information.
+    """
+
+    def __init__(self, value: str, opacity: float = 1.0, **kwargs: Any) -> None:
+        super().__init__(
+            value=value,
+            opacity=opacity,
+            no_wrap=False,
+            color=ft.Colors.ON_SURFACE,  # Theme-aware primary text color
+            font_family="Roboto",
+            size=16,
+            weight=ft.FontWeight.W_400,
+            **kwargs,
+        )
+
+
+class SecondaryText(ft.Text):  # type: ignore[misc]
+    """
+    Secondary text component using theme-aware ON_SURFACE_VARIANT color.
+
+    Automatically adapts to light/dark themes with reduced contrast.
+    Use for supporting text, captions, and less prominent information.
+    """
+
+    def __init__(
+        self, value: str, opacity: float = 1.0, no_wrap: bool = False, **kwargs: Any
+    ) -> None:
+        super().__init__(
+            value=value,
+            opacity=opacity,
+            no_wrap=no_wrap,
+            color=ft.Colors.GREY_600,  # Theme-aware secondary text color
+            font_family="Roboto",
+            size=14,
+            weight=ft.FontWeight.W_400,
+            **kwargs,
+        )
+
+
+class TitleText(ft.Text):  # type: ignore[misc]
+    """
+    Title text component for headings and prominent labels.
+
+    Uses theme-aware colors with larger size and bold weight.
+    """
+
+    def __init__(self, value: str, opacity: float = 1.0, **kwargs: Any) -> None:
+        # Set defaults, but allow kwargs to override
+        defaults = {
+            "color": ft.Colors.ON_SURFACE,  # Theme-aware primary text color
+            "font_family": "Roboto",
+            "size": 24,
+            "weight": ft.FontWeight.W_700,
+        }
+        # Update defaults with any provided kwargs
+        defaults.update(kwargs)
+
+        super().__init__(
+            value=value,
+            opacity=opacity,
+            **defaults,
+        )
+
+
+class ConfirmationText(ft.Text):  # type: ignore[misc]
+    """
+    Confirmation/error text component with error coloring.
+
+    Uses theme-aware error colors for warnings, confirmations, and alerts.
+    """
+
+    def __init__(self, value: str, opacity: float = 1.0, **kwargs: Any) -> None:
+        super().__init__(
+            value=value,
+            opacity=opacity,
+            color=ft.Colors.ERROR,  # Theme-aware error color
+            font_family="Roboto",
+            size=14,
+            weight=ft.FontWeight.W_400,
+            **kwargs,
+        )
+
+
+class MetricText(ft.Text):  # type: ignore[misc]
+    """
+    Specialized text for displaying metrics and numerical values.
+
+    Uses bold weight and primary color for emphasis on data points.
+    """
+
+    def __init__(self, value: str, opacity: float = 1.0, **kwargs: Any) -> None:
+        super().__init__(
+            value=value,
+            opacity=opacity,
+            color=ft.Colors.ON_SURFACE,  # Theme-aware primary text color
+            font_family="Roboto",
+            size=16,
+            weight=ft.FontWeight.W_700,  # Bold for emphasis
+            **kwargs,
+        )
+
+
+class LabelText(ft.Text):  # type: ignore[misc]
+    """
+    Label text component for form labels and small descriptive text.
+
+    Uses smaller size with medium weight for clear labeling.
+    """
+
+    def __init__(self, value: str, opacity: float = 1.0, **kwargs: Any) -> None:
+        # Set defaults, but allow kwargs to override
+        defaults = {
+            "color": ft.Colors.GREY_600,  # Theme-aware secondary color
+            "font_family": "Roboto",
+            "size": 12,
+            "weight": ft.FontWeight.W_600,  # Medium weight for labels
+        }
+        # Update defaults with any provided kwargs
+        defaults.update(kwargs)
+
+        super().__init__(
+            value=value,
+            opacity=opacity,
+            **defaults,
+        )

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/frontend/dashboard/cards/__init__.py.jinja

@@ -0,0 +1,47 @@
+"""Dashboard component cards."""
+
+from .fastapi_card import FastAPICard
+from .flet_card import FletCard
+{%- if include_ai %}
+from .ai_card import AICard
+{%- endif %}
+{%- if include_auth %}
+from .auth_card import AuthCard
+from .services_card import ServicesCard
+{%- endif %}
+{%- if include_database %}
+from .database_card import DatabaseCard
+{%- endif %}
+{%- if include_redis %}
+from .redis_card import RedisCard
+{%- endif %}
+{%- if include_scheduler %}
+from .scheduler_card import SchedulerCard
+{%- endif %}
+{%- if include_worker %}
+from .worker_card import WorkerCard
+{%- endif %}
+
+__all__ = [
+    "FastAPICard",
+    "FletCard",
+    {%- if include_ai %}
+    "AICard",
+    {%- endif %}
+    {%- if include_auth %}
+    "AuthCard",
+    "ServicesCard",
+    {%- endif %}
+    {%- if include_database %}
+    "DatabaseCard",
+    {%- endif %}
+    {%- if include_redis %}
+    "RedisCard",
+    {%- endif %}
+    {%- if include_scheduler %}
+    "SchedulerCard",
+    {%- endif %}
+    {%- if include_worker %}
+    "WorkerCard",
+    {%- endif %}
+]

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/frontend/dashboard/cards/ai_card.py

@@ -0,0 +1,287 @@
+"""
+AI Service Card
+
+Modern card component for displaying AI service status, provider configuration,
+and conversation metrics in a clean 2-column layout.
+"""
+
+import flet as ft
+from app.components.frontend.controls import LabelText, PrimaryText
+from app.services.system.models import ComponentStatus
+
+from .card_utils import (
+    create_hover_handler,
+    create_standard_card_container,
+    create_tech_badge,
+    get_status_colors,
+)
+
+
+class AICard:
+    """
+    A clean AI service card with provider info and key metrics.
+
+    Features:
+    - Real AI service metrics from health checks
+    - Clean 2-column layout (auth card pattern)
+    - Provider-specific color coding
+    - Highlighted metric containers
+    - Config validation display
+    - Responsive design
+    """
+
+    # Provider color mapping for visual consistency
+    PROVIDER_COLORS = {
+        "groq": ft.Colors.PURPLE,
+        "openai": ft.Colors.GREEN,
+        "anthropic": ft.Colors.ORANGE,
+        "google": ft.Colors.BLUE,
+        "mistral": ft.Colors.INDIGO,
+        "cohere": ft.Colors.TEAL,
+        "gemini": ft.Colors.BLUE,
+    }
+
+    def __init__(self, component_data: ComponentStatus):
+        """Initialize with AI service data from health check."""
+        self.component_data = component_data
+        self.metadata = component_data.metadata or {}
+
+    def _get_provider_color(self, provider: str) -> str:
+        """Get color for provider badge."""
+        return self.PROVIDER_COLORS.get(provider.lower(), ft.Colors.GREY)
+
+    def _truncate_model_name(self, model: str) -> str:
+        """Intelligently truncate model name for display."""
+        if not model:
+            return "Unknown"
+
+        # Keep it concise but recognizable
+        if len(model) <= 20:
+            return model
+
+        # Handle common patterns
+        if "claude" in model.lower():
+            # "claude-3-5-sonnet-20241022" -> "claude-3.5-sonnet"
+            parts = model.split("-")
+            if len(parts) >= 4:
+                return f"{parts[0]}-{parts[1]}.{parts[2]}-{parts[3]}"
+        elif "llama" in model.lower():
+            # "llama-3.1-70b-versatile" -> "llama-3.1-70b"
+            parts = model.split("-")
+            if len(parts) >= 3:
+                return "-".join(parts[:3])
+        elif "gpt" in model.lower():
+            # "gpt-4-turbo-preview" -> "gpt-4-turbo"
+            parts = model.split("-")
+            if len(parts) >= 3:
+                return "-".join(parts[:3])
+
+        # Fallback: truncate with ellipsis
+        return model[:20] + "..."
+
+    def _create_metric_container(
+        self, label: str, value: str, color: str = ft.Colors.BLUE
+    ) -> ft.Container:
+        """Create a properly sized metric container."""
+        return ft.Container(
+            content=ft.Column(
+                [
+                    LabelText(label),
+                    ft.Container(height=8),  # Spacing
+                    PrimaryText(value),
+                ],
+                spacing=0,
+                horizontal_alignment=ft.CrossAxisAlignment.START,
+            ),
+            padding=ft.padding.all(16),
+            bgcolor=ft.Colors.with_opacity(0.08, color),
+            border_radius=8,
+            border=ft.border.all(1, ft.Colors.with_opacity(0.15, color)),
+            height=80,  # Match auth card metric height
+            expand=True,
+        )
+
+    def _create_left_section(self) -> ft.Container:
+        """Create the left section with tech badge."""
+        return ft.Container(
+            content=ft.Column(
+                [
+                    self._create_technology_badge(),
+                ],
+                spacing=0,
+            ),
+            width=200,
+            padding=ft.padding.all(16),
+        )
+
+    def _create_technology_badge(self) -> ft.Container:
+        """Create technology badge for AI service."""
+        _, primary_color, _ = get_status_colors(self.component_data)
+
+        # Get provider for subtitle
+        provider = self.metadata.get("provider", "Unknown")
+        provider_display = provider.title()
+
+        return create_tech_badge(
+            title="AI Service",
+            subtitle=f"{provider_display} + PydanticAI",
+            icon="🤖",
+            badge_text="CHAT",
+            badge_color=primary_color,
+            primary_color=primary_color,
+        )
+
+    def _get_config_status_display(self) -> tuple[str, str]:
+        """
+        Get config status display text and color.
+
+        Returns:
+            Tuple of (status_text, color)
+        """
+        config_valid = self.metadata.get("configuration_valid", False)
+        validation_errors = self.metadata.get("validation_errors", [])
+
+        if config_valid:
+            return ("✅ Valid", ft.Colors.GREEN)
+
+        # Show specific error if only one
+        if len(validation_errors) == 1:
+            error_msg = validation_errors[0]
+            if "api key" in error_msg.lower():
+                return ("Missing API Key", ft.Colors.RED)
+            elif "disabled" in error_msg.lower():
+                return ("Disabled", ft.Colors.ORANGE)
+            else:
+                return ("Invalid", ft.Colors.RED)
+
+        # Multiple errors
+        if len(validation_errors) > 1:
+            return (f"Issues ({len(validation_errors)})", ft.Colors.RED)
+
+        # Shouldn't reach here, but just in case
+        return ("Unknown", ft.Colors.GREY)
+
+    def _get_response_time_color(self, response_time: float | None) -> str:
+        """Get color for response time based on value."""
+        if not response_time:
+            return ft.Colors.GREY
+
+        if response_time < 100:
+            return ft.Colors.GREEN
+        elif response_time < 500:
+            return ft.Colors.ORANGE
+        else:
+            return ft.Colors.RED
+
+    def _create_metrics_section(self) -> ft.Container:
+        """Create the metrics section with a clean grid layout."""
+        # Get real data from metadata
+        provider = self.metadata.get("provider", "Unknown")
+        model = self.metadata.get("model", "Unknown")
+        total_conversations = self.metadata.get("total_conversations", 0)
+        response_time = self.component_data.response_time_ms
+        enabled = self.metadata.get("enabled", True)
+
+        # Format values for display
+        provider_display = provider.title()
+        provider_color = self._get_provider_color(provider)
+        model_display = self._truncate_model_name(model)
+        conversations_display = str(total_conversations)
+        streaming_display = "✅ Available"
+        config_status, config_color = self._get_config_status_display()
+        response_time_display = f"{response_time:.1f}ms" if response_time else "N/A"
+        response_time_color = self._get_response_time_color(response_time)
+
+        # If service disabled, show that prominently
+        if not enabled:
+            config_status = "🔴 Disabled"
+            config_color = ft.Colors.RED
+
+        # Create metrics grid (3 rows x 2 columns)
+        return ft.Container(
+            content=ft.Column(
+                [
+                    # Row 1: Provider and Model
+                    ft.Row(
+                        [
+                            self._create_metric_container(
+                                "Provider", provider_display, provider_color
+                            ),
+                            self._create_metric_container(
+                                "Model", model_display, ft.Colors.BLUE
+                            ),
+                        ],
+                        expand=True,
+                    ),
+                    ft.Container(height=12),  # Vertical spacing
+                    # Row 2: Conversations and Streaming
+                    ft.Row(
+                        [
+                            self._create_metric_container(
+                                "Conversations", conversations_display, ft.Colors.PURPLE
+                            ),
+                            self._create_metric_container(
+                                "Streaming", streaming_display, ft.Colors.GREEN
+                            ),
+                        ],
+                        expand=True,
+                    ),
+                    ft.Container(height=12),  # Vertical spacing
+                    # Row 3: Config Status and Response Time
+                    ft.Row(
+                        [
+                            self._create_metric_container(
+                                "Configuration", config_status, config_color
+                            ),
+                            self._create_metric_container(
+                                "Response Time",
+                                response_time_display,
+                                response_time_color,
+                            ),
+                        ],
+                        expand=True,
+                    ),
+                ],
+                spacing=0,
+            ),
+            expand=True,
+            padding=ft.padding.all(16),
+        )
+
+    def build(self) -> ft.Container:
+        """Build and return the complete AI service card."""
+        # Get colors based on component status
+        background_color, primary_color, border_color = get_status_colors(
+            self.component_data
+        )
+
+        # Create clean 2-column layout
+        content = ft.Row(
+            [
+                self._create_left_section(),
+                ft.Container(
+                    width=1,
+                    height=160,  # Adjust height to match content
+                    bgcolor=ft.Colors.with_opacity(0.1, ft.Colors.GREY_400),
+                    margin=ft.margin.symmetric(horizontal=16),
+                ),
+                self._create_metrics_section(),
+            ],
+            expand=True,
+            vertical_alignment=ft.CrossAxisAlignment.START,
+        )
+
+        # Create the container
+        card_container = create_standard_card_container(
+            content=content,
+            primary_color=primary_color,
+            border_color=border_color,
+            width=None,
+            hover_handler=None,
+        )
+
+        # Create hover handler for the card
+        hover_handler = create_hover_handler(card_container)
+        card_container.on_hover = hover_handler
+
+        return card_container