aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/api/ai/router.py

@@ -0,0 +1,329 @@
+"""
+AI service API router.
+
+FastAPI router for AI chat endpoints implementing core chat functionality,
+conversation management, and service status.
+"""
+
+import json
+from collections.abc import AsyncIterator
+from typing import Any
+
+from app.core.config import settings
+from app.services.ai.service import (
+    AIService,
+    AIServiceError,
+    ConversationError,
+    ProviderError,
+)
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/ai", tags=["ai"])
+
+# Initialize AI service
+ai_service = AIService(settings)
+
+
+# Request/Response models
+class ChatRequest(BaseModel):
+    """Request model for chat messages."""
+
+    message: str
+    conversation_id: str | None = None
+    user_id: str = "api-user"
+
+
+class ChatResponse(BaseModel):
+    """Response model for chat messages."""
+
+    message_id: str
+    content: str
+    conversation_id: str
+    response_time_ms: float | None = None
+
+
+class ConversationSummary(BaseModel):
+    """Summary model for conversation listing."""
+
+    id: str
+    title: str | None
+    message_count: int
+    last_activity: str
+    provider: str
+    model: str
+
+
+@router.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest) -> ChatResponse:
+    """
+    Send a chat message and get AI response.
+
+    Args:
+        request: Chat request with message and optional conversation ID
+
+    Returns:
+        ChatResponse: AI response with conversation details
+
+    Raises:
+        HTTPException: If chat processing fails
+    """
+    try:
+        response_message = await ai_service.chat(
+            message=request.message,
+            conversation_id=request.conversation_id,
+            user_id=request.user_id,
+        )
+
+        # Get updated conversation for metadata
+        conversation_id = response_message.metadata.get("conversation_id")
+        conversation = (
+            ai_service.get_conversation(conversation_id) if conversation_id else None
+        )
+        response_time = None
+        if conversation and "last_response_time_ms" in conversation.metadata:
+            response_time = conversation.metadata["last_response_time_ms"]
+
+        return ChatResponse(
+            message_id=response_message.id,
+            content=response_message.content,
+            conversation_id=conversation.id if conversation else "unknown",
+            response_time_ms=response_time,
+        )
+
+    except AIServiceError as e:
+        raise HTTPException(status_code=503, detail=f"AI service error: {e}")
+    except ProviderError as e:
+        raise HTTPException(status_code=502, detail=f"AI provider error: {e}")
+    except ConversationError as e:
+        raise HTTPException(status_code=400, detail=f"Conversation error: {e}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {e}")
+
+
+@router.post("/chat/stream")
+async def chat_stream(request: ChatRequest) -> StreamingResponse:
+    """
+    Stream a chat message with real-time Server-Sent Events.
+
+    Args:
+        request: Chat request with message and optional conversation ID
+
+    Returns:
+        StreamingResponse: SSE stream with real-time AI response
+
+    Raises:
+        HTTPException: If streaming fails
+    """
+
+    async def generate_sse_stream() -> AsyncIterator[str]:
+        """Generate Server-Sent Events stream for chat response."""
+        try:
+            # Send initial connection event
+            connect_data = {"status": "connected", "message": "Streaming started"}
+            yield f"event: connect\ndata: {json.dumps(connect_data)}\n\n"
+
+            # Stream the AI response
+            async for chunk in ai_service.stream_chat(
+                message=request.message,
+                conversation_id=request.conversation_id,
+                user_id=request.user_id,
+                stream_delta=True,
+            ):
+                # Format chunk as SSE event
+                event_data = {
+                    "content": chunk.content,
+                    "is_final": chunk.is_final,
+                    "is_delta": chunk.is_delta,
+                    "message_id": chunk.message_id,
+                    "conversation_id": chunk.conversation_id,
+                    "timestamp": chunk.timestamp.isoformat(),
+                }
+
+                # Add metadata for final chunk
+                if chunk.is_final:
+                    event_data.update(chunk.metadata)
+
+                # Send chunk as SSE event
+                event_type = "final" if chunk.is_final else "chunk"
+                yield f"event: {event_type}\ndata: {json.dumps(event_data)}\n\n"
+
+                # Break after final chunk
+                if chunk.is_final:
+                    break
+
+            # Send stream complete event
+            complete_data = {"status": "completed", "message": "Stream finished"}
+            yield f"event: complete\ndata: {json.dumps(complete_data)}\n\n"
+
+        except AIServiceError as e:
+            error_data = {"error": "AI service error", "detail": str(e)}
+            yield f"event: error\ndata: {json.dumps(error_data)}\n\n"
+        except ProviderError as e:
+            error_data = {"error": "AI provider error", "detail": str(e)}
+            yield f"event: error\ndata: {json.dumps(error_data)}\n\n"
+        except ConversationError as e:
+            error_data = {"error": "Conversation error", "detail": str(e)}
+            yield f"event: error\ndata: {json.dumps(error_data)}\n\n"
+        except Exception as e:
+            error_data = {"error": "Unexpected error", "detail": str(e)}
+            yield f"event: error\ndata: {json.dumps(error_data)}\n\n"
+
+    # Create streaming response with proper SSE headers
+    return StreamingResponse(
+        generate_sse_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Headers": "Content-Type",
+        },
+    )
+
+
+@router.get("/conversations", response_model=list[ConversationSummary])
+async def list_conversations(
+    user_id: str = "api-user", limit: int = 50
+) -> list[ConversationSummary]:
+    """
+    List conversations for a user.
+
+    Args:
+        user_id: User identifier
+        limit: Maximum number of conversations to return
+
+    Returns:
+        List of conversation summaries
+    """
+    try:
+        conversations = ai_service.list_conversations(user_id)[:limit]
+
+        return [
+            ConversationSummary(
+                id=conv.id,
+                title=conv.title,
+                message_count=conv.get_message_count(),
+                last_activity=conv.updated_at.isoformat(),
+                provider=conv.provider.value,
+                model=conv.model,
+            )
+            for conv in conversations
+        ]
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to list conversations: {e}"
+        )
+
+
+@router.get("/conversations/{conversation_id}")
+async def get_conversation(
+    conversation_id: str, user_id: str = "api-user"
+) -> dict[str, Any]:
+    """
+    Get a specific conversation with full message history.
+
+    Args:
+        conversation_id: The conversation identifier
+        user_id: User identifier for access control
+
+    Returns:
+        Full conversation details with messages
+
+    Raises:
+        HTTPException: If conversation not found or access denied
+    """
+    try:
+        conversation = ai_service.get_conversation(conversation_id)
+
+        if not conversation:
+            raise HTTPException(status_code=404, detail="Conversation not found")
+
+        # Check access (basic user matching)
+        if conversation.metadata.get("user_id") != user_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        return {
+            "id": conversation.id,
+            "title": conversation.title,
+            "provider": conversation.provider.value,
+            "model": conversation.model,
+            "created_at": conversation.created_at.isoformat(),
+            "updated_at": conversation.updated_at.isoformat(),
+            "message_count": conversation.get_message_count(),
+            "messages": [
+                {
+                    "id": msg.id,
+                    "role": msg.role.value,
+                    "content": msg.content,
+                    "timestamp": msg.timestamp.isoformat(),
+                }
+                for msg in conversation.messages
+            ],
+            "metadata": conversation.metadata,
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get conversation: {e}")
+
+
+@router.get("/health")
+async def ai_health() -> dict[str, Any]:
+    """
+    AI service health endpoint.
+
+    Returns comprehensive health status including configuration,
+    conversation count, and service availability.
+    """
+    try:
+        status = ai_service.get_service_status()
+        validation_errors = ai_service.validate_service()
+
+        return {
+            "service": "ai",
+            "status": "healthy" if not validation_errors else "unhealthy",
+            "enabled": status["enabled"],
+            "provider": status["provider"],
+            "model": status["model"],
+            "agent_ready": status["agent_initialized"],
+            "total_conversations": status["total_conversations"],
+            "configuration_valid": status["configuration_valid"],
+            "validation_errors": validation_errors,
+        }
+
+    except Exception as e:
+        return {
+            "service": "ai",
+            "status": "error",
+            "error": str(e),
+        }
+
+
+@router.get("/version")
+async def ai_version() -> dict[str, Any]:
+    """AI service version and feature information."""
+    return {
+        "service": "ai",
+        "engine": "pydantic-ai",
+        "version": "1.0",
+        "features": [
+            "chat",
+            "conversation_management",
+            "multi_provider_support",
+            "health_monitoring",
+            "api_endpoints",
+            "cli_commands",
+        ],
+        "providers_supported": [
+            "openai",
+            "anthropic",
+            "google",
+            "groq",
+            "mistral",
+            "cohere",
+        ],
+    }

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

@@ -0,0 +1 @@
+"""Auth API endpoints."""

aegis/templates/cookiecutter-aegis-project/{{cookiecutter.project_slug}}/app/components/backend/api/auth/router.py

@@ -0,0 +1,64 @@
+"""Authentication API routes."""
+
+from app.components.backend.api.deps import get_async_db
+from app.core.security import create_access_token, verify_password
+from app.models.user import UserCreate, UserResponse
+from app.services.auth.auth_service import get_current_user_from_token
+from app.services.auth.user_service import UserService
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+router = APIRouter(prefix="/auth", tags=["authentication"])
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/v1/auth/token")
+
+
+@router.post("/register", response_model=UserResponse)
+async def register(user_data: UserCreate, db: AsyncSession = Depends(get_async_db)):
+    """Register a new user."""
+    user_service = UserService(db)
+
+    # Check if user already exists
+    existing_user = await user_service.get_user_by_email(user_data.email)
+    if existing_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="Email already registered"
+        )
+
+    # Create new user
+    user = await user_service.create_user(user_data)
+    return UserResponse.model_validate(user)
+
+
+@router.post("/token")
+async def login(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """Login and get access token."""
+    user_service = UserService(db)
+
+    # Get user by email (username field in OAuth2 form)
+    user = await user_service.get_user_by_email(form_data.username)
+
+    if not user or not verify_password(form_data.password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    # Create access token
+    access_token = create_access_token(data={"sub": user.email})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+@router.get("/me", response_model=UserResponse)
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_async_db),
+):
+    """Get current authenticated user."""
+    user = await get_current_user_from_token(token, db)
+    return UserResponse.model_validate(user)

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

@@ -0,0 +1,58 @@
+"""FastAPI dependencies for the backend API."""
+
+from collections.abc import AsyncGenerator, Generator
+
+from app.core.db import AsyncSessionLocal, SessionLocal
+from sqlmodel import Session
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+
+def get_db() -> Generator[Session, None, None]:
+    """
+    Database dependency that provides a database session.
+
+    This dependency is used in FastAPI route functions to get access to
+    the database. It automatically handles session lifecycle - creating,
+    yielding, and closing the session properly.
+
+    Usage:
+        @router.get("/example")
+        def example_endpoint(db: Session = Depends(get_db)):
+            # Use db for database operations
+            pass
+
+    Yields:
+        Session: SQLModel database session
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+async def get_async_db() -> AsyncGenerator[AsyncSession, None]:
+    """
+    Async database dependency that provides an async database session.
+
+    This dependency is used in async FastAPI route functions to get access to
+    the database with non-blocking I/O operations. It automatically handles
+    session lifecycle - creating, yielding, committing and closing the session properly.
+
+    Usage:
+        @router.get("/example")
+        async def example_endpoint(db: AsyncSession = Depends(get_async_db)):
+            # Use db for async database operations with await
+            result = await db.exec(select(MyModel))
+            return result.first()
+
+    Yields:
+        AsyncSession: SQLModel async database session
+    """
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise

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

@@ -0,0 +1,163 @@
+from typing import Any
+
+from app.services.system import (
+    DetailedHealthResponse,
+    HealthResponse,
+    get_system_status,
+)
+from fastapi import APIRouter, HTTPException
+from starlette import status
+
+router = APIRouter()
+
+
+@router.get("/", response_model=HealthResponse)
+async def health_check() -> HealthResponse:
+    """
+    Quick health check endpoint.
+
+    Returns basic healthy/unhealthy status for load balancers and monitoring.
+    """
+    try:
+        system_status = await get_system_status()
+        return HealthResponse(
+            healthy=system_status.overall_healthy,
+            status="healthy" if system_status.overall_healthy else "unhealthy",
+            components=system_status.components,
+            timestamp=system_status.timestamp.isoformat(),
+        )
+    except Exception:
+        # If health checks fail completely, consider unhealthy
+        return HealthResponse(
+            healthy=False,
+            status="unhealthy",
+            components={},
+            timestamp="",
+        )
+
+
+@router.get("/detailed", response_model=DetailedHealthResponse)
+async def detailed_health() -> DetailedHealthResponse:
+    """
+    Detailed health check with component information.
+
+    Returns comprehensive system status including individual component health,
+    system metrics, and diagnostic information.
+    """
+    try:
+        system_status = await get_system_status()
+
+        # Always return 200 OK - service is available even if components are unhealthy
+        return DetailedHealthResponse(
+            healthy=system_status.overall_healthy,
+            status="healthy" if system_status.overall_healthy else "unhealthy",
+            service="{{ cookiecutter.project_name }}",
+            version="0.1.0",
+            components=system_status.components,
+            system_info=system_status.system_info,
+            timestamp=system_status.timestamp.isoformat(),
+            healthy_components=system_status.healthy_components,
+            unhealthy_components=system_status.unhealthy_components,
+            health_percentage=system_status.health_percentage,
+            # Service-specific information
+            has_services=system_status.has_services,
+            service_names=system_status.service_names,
+            healthy_services=system_status.healthy_services,
+            unhealthy_services=system_status.unhealthy_services,
+        )
+
+    except HTTPException:
+        # Re-raise HTTP exceptions from unexpected errors
+        raise
+    except Exception as e:
+        # Handle unexpected errors
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail={
+                "message": "Health check failed",
+                "error": str(e),
+                "status": "unhealthy",
+            },
+        )
+
+
+@router.get("/dashboard")
+async def system_dashboard() -> dict[str, Any]:
+    """
+    System dashboard endpoint optimized for frontend consumption.
+
+    Returns system status with additional dashboard metadata like
+    alert counts, trend data, and formatted display information.
+    """
+    try:
+        system_status = await get_system_status()
+
+        # TODO: Implement alert tracking when alert management is enhanced
+        recent_alerts = 0
+
+        return {
+            "status": "healthy" if system_status.overall_healthy else "unhealthy",
+            "service": "{{ cookiecutter.project_name }}",
+            "version": "0.1.0",
+            "dashboard_data": {
+                "overall_status": {
+                    "healthy": system_status.overall_healthy,
+                    "percentage": system_status.health_percentage,
+                    "status_text": (
+                        "System Healthy"
+                        if system_status.overall_healthy
+                        else "Issues Detected"
+                    ),
+                },
+                "components": {
+                    name: {
+                        "name": name,
+                        "healthy": component.healthy,
+                        "message": component.message,
+                        "response_time_ms": component.response_time_ms,
+                        "metadata": component.metadata,
+                    }
+                    for name, component in system_status.components.items()
+                },
+                "summary": {
+                    "total_components": len(system_status.components),
+                    "healthy_components": len(system_status.healthy_components),
+                    "unhealthy_components": len(system_status.unhealthy_components),
+                    "recent_alerts": recent_alerts,
+                    # Service summary information
+                    "has_services": system_status.has_services,
+                    "total_services": len(system_status.service_names),
+                    "healthy_services": len(system_status.healthy_services),
+                    "unhealthy_services": len(system_status.unhealthy_services),
+                },
+                # Services section for frontend consumption
+                "services": {
+                    "enabled": system_status.has_services,
+                    "services": {
+                        name: {
+                            "name": name,
+                            "healthy": service.healthy,
+                            "message": service.message,
+                            "response_time_ms": service.response_time_ms,
+                            "metadata": service.metadata,
+                        }
+                        for name, service in (
+                            system_status.services_status.sub_components.items()
+                            if system_status.services_status
+                            else {}
+                        ).items()
+                    }
+                    if system_status.has_services
+                    else {},
+                },
+                "system_info": system_status.system_info,
+                "timestamp": system_status.timestamp.isoformat(),
+                "last_updated": system_status.timestamp.strftime("%H:%M:%S"),
+            },
+        }
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail={"message": "Dashboard data unavailable", "error": str(e)},
+        )