aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/app/core/log.py

@@ -0,0 +1,92 @@
+# app/core/log.py
+"""
+Core logging configuration for the application.
+
+This module sets up structlog to provide structured, context-aware logging.
+It supports both human-readable console output for development and JSON
+output for production environments.
+"""
+
+import logging
+import sys
+
+import structlog
+from app.core.config import settings
+from structlog.types import Processor
+
+# A global logger instance for easy access throughout the application
+logger: structlog.stdlib.BoundLogger = structlog.get_logger()
+
+
+def setup_logging() -> None:
+    """
+    Configures logging for the entire application.
+
+    This function sets up structlog with processors for structured logging.
+    It routes all standard library logging through structlog to ensure
+    consistent log formats. The output format is determined by the APP_ENV
+    setting (dev-friendly console format or production-ready JSON format).
+    """
+    # Type hint for the list of processors
+    shared_processors: list[Processor] = [
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+    ]
+
+    # Configure structlog
+    structlog.configure(
+        processors=shared_processors
+        + [
+            # Prepare event dict for `ProcessorFormatter`.
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+    # Define the formatter based on the environment
+    if settings.APP_ENV == "dev":
+        formatter = structlog.stdlib.ProcessorFormatter(
+            # The final processor formats the log entry for console output.
+            processor=structlog.dev.ConsoleRenderer(colors=True),
+        )
+    else:
+        formatter = structlog.stdlib.ProcessorFormatter(
+            # The final processor formats the log entry as JSON.
+            processor=structlog.processors.JSONRenderer(),
+            # Remove metadata added by ProcessorFormatter
+            foreign_pre_chain=shared_processors,
+        )
+
+    # Configure the root logger
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+    root_logger = logging.getLogger()
+
+    # CRITICAL: Set log level BEFORE adding handler
+    # This ensures all loggers (including import-time loggers) respect the level
+    log_level = settings.LOG_LEVEL.upper()
+    root_logger.setLevel(getattr(logging, log_level))
+
+    # Add handler after level is set
+    root_logger.addHandler(handler)
+
+    # Adjust log levels for noisy third-party libraries
+    logging.getLogger("flet_core").setLevel(logging.INFO)
+    logging.getLogger("flet_runtime").setLevel(logging.INFO)
+    logging.getLogger("flet_fastapi").setLevel(logging.INFO)
+    logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+    log_format = "DEV" if settings.APP_ENV == "dev" else "JSON"
+    logger.info(
+        "Logging setup complete",
+        level=log_level,
+        log_format=log_format,
+        root_level=root_logger.level,
+        effective_level=root_logger.getEffectiveLevel(),
+    )

aegis/templates/copier-aegis-project/{{ project_slug }}/app/core/security.py

@@ -0,0 +1,62 @@
+"""Security utilities for authentication and authorization."""
+
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from app.core.config import settings
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(
+    schemes=["bcrypt"],
+    deprecated="auto",
+)
+
+
+def _truncate_password(password: str) -> str:
+    """Truncate password to 72 bytes for bcrypt compatibility.
+
+    bcrypt has a 72-byte limit. We explicitly truncate here rather than
+    rely on library defaults for clarity and consistency.
+    """
+    return password[:72]
+
+
+def create_access_token(
+    data: dict[str, Any], expires_delta: timedelta | None = None
+) -> str:
+    """Create a JWT access token."""
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.now(UTC) + expires_delta
+    else:
+        expire = datetime.now(UTC) + timedelta(
+            minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
+        )
+
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(
+        to_encode, settings.SECRET_KEY, algorithm=settings.JWT_ALGORITHM
+    )
+    return encoded_jwt
+
+
+def verify_token(token: str) -> dict[str, Any] | None:
+    """Verify and decode a JWT token."""
+    try:
+        payload = jwt.decode(
+            token, settings.SECRET_KEY, algorithms=[settings.JWT_ALGORITHM]
+        )
+        return payload
+    except JWTError:
+        return None
+
+
+def get_password_hash(password: str) -> str:
+    """Hash a password."""
+    return pwd_context.hash(_truncate_password(password))
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Verify a password against its hash."""
+    return pwd_context.verify(_truncate_password(plain_password), hashed_password)

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

@@ -0,0 +1 @@
+# Entry points for different Aegis Stack execution modes

aegis/templates/copier-aegis-project/{{ project_slug }}/app/entrypoints/scheduler.py.jinja

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""
+Scheduler entrypoint for {{ project_name }}.
+
+This entrypoint starts the scheduler component.
+"""
+
+import asyncio
+
+from app.components.scheduler.main import run_scheduler
+from app.core.log import setup_logging
+
+
+async def main() -> None:
+    """Main scheduler entry point"""
+    setup_logging()
+    await run_scheduler()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

aegis/templates/copier-aegis-project/{{ project_slug }}/app/entrypoints/webserver.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+Web server entry point for Aegis Stack.
+Runs FastAPI + Flet only (clean separation of concerns).
+"""
+
+import uvicorn
+from app.core.config import settings
+from app.core.log import logger, setup_logging
+from app.integrations.main import create_integrated_app
+
+
+def main() -> None:
+    """Main webserver entry point"""
+    setup_logging()
+    logger.info("Starting Aegis Stack Web Server...")
+
+    # Run the web server
+    if settings.AUTO_RELOAD:
+        # When reload is enabled, uvicorn requires an import string
+        uvicorn.run(
+            "app.integrations.main:create_integrated_app",
+            factory=True,
+            host="0.0.0.0",
+            port=settings.PORT,
+            reload=True,
+        )
+    else:
+        # Use the integration layer (handles webserver hooks, service discovery, etc.)
+        app = create_integrated_app()
+        uvicorn.run(
+            app,
+            host="0.0.0.0",
+            port=settings.PORT,
+        )
+
+
+if __name__ == "__main__":
+    main()

aegis/templates/copier-aegis-project/{{ project_slug }}/app/integrations/main.py

@@ -0,0 +1,61 @@
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import flet.fastapi as flet_fastapi
+from app.components.backend.hooks import backend_hooks
+from app.components.backend.main import create_backend_app
+from app.components.frontend.main import create_frontend_app
+from app.core.config import settings
+from app.core.log import logger
+from fastapi import FastAPI
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """
+    Application lifespan manager.
+    Handles startup/shutdown concerns using component-specific hooks.
+    """
+    # --- STARTUP ---
+    logger.info("--- Running application startup ---")
+
+    # Discover startup and shutdown hooks
+    await backend_hooks.discover_lifespan_hooks()
+
+    # Start Flet app manager
+    await flet_fastapi.app_manager.start()
+
+    # Execute backend startup hooks
+    await backend_hooks.execute_startup_hooks()
+
+    logger.info("--- Application startup complete ---")
+
+    yield
+
+    # --- SHUTDOWN ---
+    logger.info("--- Running application shutdown ---")
+
+    # Execute backend shutdown hooks
+    await backend_hooks.execute_shutdown_hooks()
+
+    # Stop Flet app manager
+    await flet_fastapi.app_manager.shutdown()
+
+    logger.info("--- Application shutdown complete ---")
+
+
+def create_integrated_app() -> FastAPI:
+    """
+    Creates the integrated Flet+FastAPI application using the officially
+    recommended pattern and component-specific hooks.
+    """
+    app = FastAPI(lifespan=lifespan)
+
+    create_backend_app(app)
+    # Create and mount the Flet app using the flet.fastapi module
+    # First, get the actual session handler function from the factory
+    session_handler = create_frontend_app()
+    flet_app = flet_fastapi.app(session_handler, assets_dir=settings.FLET_ASSETS_DIR)
+    # Mount Flet at /dashboard to avoid intercepting FastAPI routes like /health
+    app.mount("/dashboard", flet_app)
+    return app

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

@@ -0,0 +1 @@
+"""Data models for the application."""

aegis/templates/copier-aegis-project/{{ project_slug }}/app/models/user.py

@@ -0,0 +1,44 @@
+"""User data models."""
+
+from datetime import UTC, datetime
+
+from pydantic import EmailStr
+from sqlmodel import Field, SQLModel
+
+
+class UserBase(SQLModel):
+    """Base user model with shared fields."""
+
+    email: EmailStr = Field(unique=True, index=True)
+    full_name: str | None = None
+    is_active: bool = Field(default=True)
+
+
+class User(UserBase, table=True):
+    """User database model."""
+
+    id: int | None = Field(default=None, primary_key=True)
+    hashed_password: str
+    created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
+    updated_at: datetime | None = None
+
+
+class UserCreate(UserBase):
+    """User creation model."""
+
+    password: str = Field(min_length=8)
+
+
+class UserLogin(SQLModel):
+    """User login model."""
+
+    email: str
+    password: str
+
+
+class UserResponse(UserBase):
+    """User response model (excludes sensitive data)."""
+
+    id: int
+    created_at: datetime
+    updated_at: datetime | None = None

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

@@ -0,0 +1 @@
+# Business logic services

aegis/templates/copier-aegis-project/{{ project_slug }}/app/services/ai/__init__.py

@@ -0,0 +1,8 @@
+"""
+AI service module.
+
+Provides AI chatbot functionality with PydanticAI engine.
+"""
+
+# AI service exports will be added in ticket #159
+__all__ = []

aegis/templates/copier-aegis-project/{{ project_slug }}/app/services/ai/config.py

@@ -0,0 +1,130 @@
+"""
+AI service configuration models.
+
+Configuration management for AI service providers, models, and settings.
+Integrates with main application settings through app.core.config.
+"""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from .models import (
+    AIProvider,
+    ProviderConfig,
+    get_provider_capabilities,
+)
+
+
+class AIServiceConfig(BaseModel):
+    """
+    AI service configuration that integrates with main app settings.
+
+    This class provides convenience methods and validation for AI service
+    configuration while the actual settings live in app.core.config.Settings.
+    """
+
+    enabled: bool = True
+    provider: AIProvider = (
+        AIProvider.PUBLIC
+    )  # Default to public endpoints (no API key required)
+    model: str = "gpt-3.5-turbo"  # Default to widely supported model
+    temperature: float = Field(default=0.7, ge=0.0, le=2.0)
+    max_tokens: int = Field(default=1000, gt=0, le=8000)
+    timeout_seconds: float = Field(default=30.0, gt=0)
+
+    class Config:
+        use_enum_values = True
+
+    @classmethod
+    def from_settings(cls, settings: Any) -> "AIServiceConfig":
+        """Create configuration from main application settings."""
+        return cls(
+            enabled=getattr(settings, "AI_ENABLED", True),
+            provider=AIProvider(getattr(settings, "AI_PROVIDER", "public")),
+            model=getattr(settings, "AI_MODEL", "gpt-3.5-turbo"),
+            temperature=getattr(settings, "AI_TEMPERATURE", 0.7),
+            max_tokens=getattr(settings, "AI_MAX_TOKENS", 1000),
+            timeout_seconds=getattr(settings, "AI_TIMEOUT_SECONDS", 30.0),
+        )
+
+    def get_provider_config(self, settings: Any) -> ProviderConfig:
+        """Get provider-specific configuration."""
+        # Get API key based on provider
+        api_key_mapping = {
+            AIProvider.OPENAI: getattr(settings, "OPENAI_API_KEY", None),
+            AIProvider.ANTHROPIC: getattr(settings, "ANTHROPIC_API_KEY", None),
+            AIProvider.GOOGLE: getattr(settings, "GOOGLE_API_KEY", None),
+            AIProvider.GROQ: getattr(settings, "GROQ_API_KEY", None),
+            AIProvider.MISTRAL: getattr(settings, "MISTRAL_API_KEY", None),
+            AIProvider.COHERE: getattr(settings, "COHERE_API_KEY", None),
+            AIProvider.PUBLIC: None,  # No API key required for public endpoints
+        }
+
+        return ProviderConfig(
+            name=self.provider,
+            api_key=api_key_mapping.get(self.provider),
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            timeout_seconds=self.timeout_seconds,
+        )
+
+    def validate_configuration(self, settings: Any) -> list[str]:
+        """
+        Validate AI service configuration and return list of issues.
+
+        Returns:
+            List of validation error messages (empty if valid)
+        """
+        errors = []
+
+        if not self.enabled:
+            return errors  # Skip validation if disabled
+
+        # Check if provider is supported
+        capabilities = get_provider_capabilities(self.provider)
+        if not capabilities:
+            errors.append(f"Unsupported provider: {self.provider}")
+
+        # Check API key requirement (only PUBLIC provider requires no API key)
+        provider_config = self.get_provider_config(settings)
+
+        if self.provider != AIProvider.PUBLIC and not provider_config.api_key:
+            errors.append(
+                f"Missing API key for {self.provider} provider. "
+                f"Set {self.provider.upper()}_API_KEY environment variable."
+            )
+
+        # Note: Token limits vary by model within each provider,
+        # so we don't validate them here
+
+        return errors
+
+    def is_provider_available(self, settings: Any) -> bool:
+        """Check if the configured provider is available and properly configured."""
+        errors = self.validate_configuration(settings)
+        return len(errors) == 0
+
+    def get_available_providers(self, settings: Any) -> list[AIProvider]:
+        """Get list of providers that are properly configured."""
+        available = []
+
+        for provider in AIProvider:
+            # Temporarily check each provider
+            temp_config = AIServiceConfig(
+                enabled=True,
+                provider=provider,
+                model=self.model,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens,
+            )
+
+            if len(temp_config.validate_configuration(settings)) == 0:
+                available.append(provider)
+
+        return available
+
+
+def get_ai_config(settings: Any) -> AIServiceConfig:
+    """Get AI service configuration from application settings."""
+    return AIServiceConfig.from_settings(settings)

aegis/templates/copier-aegis-project/{{ project_slug }}/app/services/ai/conversation.py

@@ -0,0 +1,213 @@
+"""
+AI conversation management.
+
+In-memory conversation storage and management for AI chat sessions.
+This provides conversation persistence during application runtime.
+"""
+
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from app.core.log import logger
+
+from .models import AIProvider, Conversation
+
+
+class ConversationManager:
+    """
+    Manages AI conversations in memory.
+
+    This is a simple in-memory implementation. In production, you might want
+    to use a database or external storage for persistence across restarts.
+    """
+
+    def __init__(self):
+        """Initialize conversation manager with empty storage."""
+        self.conversations: dict[str, Conversation] = {}
+        # logger.info("Conversation manager initialized")
+
+    def create_conversation(
+        self,
+        provider: AIProvider,
+        model: str,
+        user_id: str = "default",
+        conversation_id: str | None = None,
+    ) -> Conversation:
+        """
+        Create a new conversation.
+
+        Args:
+            provider: AI provider being used
+            model: Model name
+            user_id: User identifier
+            conversation_id: Optional custom conversation ID
+
+        Returns:
+            Conversation: The created conversation
+        """
+        if conversation_id is None:
+            conversation_id = str(uuid.uuid4())
+
+        conversation = Conversation(
+            id=conversation_id,
+            provider=provider,
+            model=model,
+            metadata={"user_id": user_id, "created_by": "ai_service"},
+        )
+
+        self.conversations[conversation_id] = conversation
+        # logger.debug(f"Created conversation {conversation_id} for user {user_id}")
+
+        return conversation
+
+    def get_conversation(self, conversation_id: str) -> Conversation | None:
+        """
+        Get a conversation by ID.
+
+        Args:
+            conversation_id: The conversation identifier
+
+        Returns:
+            Conversation | None: The conversation if found, None otherwise
+        """
+        return self.conversations.get(conversation_id)
+
+    def save_conversation(self, conversation: Conversation) -> None:
+        """
+        Save a conversation (update in memory storage).
+
+        Args:
+            conversation: The conversation to save
+        """
+        conversation.updated_at = datetime.now(UTC)
+        self.conversations[conversation.id] = conversation
+        # logger.debug(f"Saved conversation {conversation.id}")
+
+    def list_conversations(self, user_id: str | None = None) -> list[Conversation]:
+        """
+        List conversations, optionally filtered by user.
+
+        Args:
+            user_id: Optional user ID to filter by
+
+        Returns:
+            list[Conversation]: List of conversations
+        """
+        conversations = list(self.conversations.values())
+
+        if user_id:
+            conversations = [
+                conv
+                for conv in conversations
+                if conv.metadata.get("user_id") == user_id
+            ]
+
+        # Sort by most recent activity
+        conversations.sort(key=lambda c: c.updated_at, reverse=True)
+        return conversations
+
+    def delete_conversation(self, conversation_id: str) -> bool:
+        """
+        Delete a conversation.
+
+        Args:
+            conversation_id: The conversation identifier
+
+        Returns:
+            bool: True if conversation was deleted, False if not found
+        """
+        if conversation_id in self.conversations:
+            del self.conversations[conversation_id]
+            # logger.debug(f"Deleted conversation {conversation_id}")
+            return True
+        return False
+
+    def get_conversation_count(self, user_id: str | None = None) -> int:
+        """
+        Get count of conversations.
+
+        Args:
+            user_id: Optional user ID to filter by
+
+        Returns:
+            int: Number of conversations
+        """
+        if user_id:
+            return len(
+                [
+                    conv
+                    for conv in self.conversations.values()
+                    if conv.metadata.get("user_id") == user_id
+                ]
+            )
+        return len(self.conversations)
+
+    def get_recent_conversations(
+        self, limit: int = 10, user_id: str | None = None
+    ) -> list[Conversation]:
+        """
+        Get recent conversations.
+
+        Args:
+            limit: Maximum number of conversations to return
+            user_id: Optional user ID to filter by
+
+        Returns:
+            list[Conversation]: Recent conversations
+        """
+        conversations = self.list_conversations(user_id)
+        return conversations[:limit]
+
+    def cleanup_old_conversations(self, max_age_hours: int = 24) -> int:
+        """
+        Clean up old conversations.
+
+        Args:
+            max_age_hours: Maximum age in hours before cleanup
+
+        Returns:
+            int: Number of conversations cleaned up
+        """
+        cutoff_time = datetime.now(UTC).timestamp() - (max_age_hours * 3600)
+        to_delete = []
+
+        for conv_id, conversation in self.conversations.items():
+            if conversation.updated_at.timestamp() < cutoff_time:
+                to_delete.append(conv_id)
+
+        for conv_id in to_delete:
+            del self.conversations[conv_id]
+
+        if to_delete:
+            logger.info(f"Cleaned up {len(to_delete)} old conversations")
+
+        return len(to_delete)
+
+    def get_stats(self) -> dict[str, Any]:
+        """
+        Get conversation manager statistics.
+
+        Returns:
+            dict: Statistics about conversations
+        """
+        total_conversations = len(self.conversations)
+        total_messages = sum(
+            conv.get_message_count() for conv in self.conversations.values()
+        )
+
+        # Get user breakdown
+        users = set()
+        for conv in self.conversations.values():
+            user_id = conv.metadata.get("user_id")
+            if user_id:
+                users.add(user_id)
+
+        return {
+            "total_conversations": total_conversations,
+            "total_messages": total_messages,
+            "unique_users": len(users),
+            "average_messages_per_conversation": (
+                total_messages / total_conversations if total_conversations > 0 else 0
+            ),
+        }