aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/templates/copier-aegis-project/{{ project_slug }}/app/cli/tasks.py.jinja

@@ -0,0 +1,328 @@
+{%- if scheduler_backend != "memory" -%}
+"""
+Scheduled task CLI commands.
+
+Provides command-line interface for managing scheduled jobs,
+viewing job statistics, and manually triggering tasks.
+"""
+
+import asyncio
+import json
+from datetime import datetime
+from typing import Any
+
+from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+import typer
+
+from app.core.log import logger
+from app.services.scheduler import ScheduledTaskManager
+from app.services.scheduler.models import ScheduledTask
+
+app = typer.Typer(
+    name="tasks",
+    help="Scheduled task management commands",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+@app.command("list")
+def list_jobs() -> None:
+    """
+    List all scheduled jobs with their current status.
+
+    Shows job details including next run time, status, and configuration.
+    """
+
+    rprint("📋 [bold blue]Listing Scheduled Jobs[/bold blue]")
+
+    try:
+        tasks = asyncio.run(_get_scheduled_tasks())
+
+        if not tasks:
+            rprint("ℹ️  [yellow]No scheduled jobs found[/yellow]")
+            return
+
+        table = Table(
+            title="🕒 Scheduled Jobs",
+            show_header=True,
+            header_style="bold magenta",
+        )
+        table.add_column("Job ID", style="cyan", no_wrap=True)
+        table.add_column("Name", style="green")
+        table.add_column("Status", style="bold")
+        table.add_column("Next Run", style="yellow")
+        table.add_column("Trigger", style="dim")
+
+        for task in tasks:
+            status_color = "green" if task.is_active else "red"
+            next_run = (
+                task.next_run_time.strftime("%Y-%m-%d %H:%M:%S")
+                if task.next_run_time
+                else "Not scheduled"
+            )
+
+            table.add_row(
+                task.job_id,
+                task.name or task.job_id,
+                (
+                    f"[{status_color}]{'Active' if task.is_active else 'Paused'}"
+                    f"[/{status_color}]"
+                ),
+                next_run,
+                task.trigger_type or "Unknown"
+            )
+
+        console.print(table)
+        rprint(f"\n📊 [cyan]Total jobs:[/cyan] {len(tasks)}")
+
+    except Exception as e:
+        rprint(f"❌ [red]Failed to list jobs:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("stats")
+def job_statistics(
+    job_id: str | None = typer.Argument(
+        None, help="Specific job ID to show stats for"
+    ),
+    json_output: bool = typer.Option(
+        False, "--json", help="Output stats in JSON format"
+    ),
+) -> None:
+    """
+    Show job execution statistics and performance metrics.
+
+    Without job_id: Shows overall scheduler statistics
+    With job_id: Shows detailed statistics for specific job
+    """
+
+    try:
+        if job_id:
+            rprint(f"📊 [bold blue]Job Statistics for: {job_id}[/bold blue]")
+            stats = asyncio.run(_get_job_statistics(job_id))
+        else:
+            rprint("📊 [bold blue]Overall Scheduler Statistics[/bold blue]")
+            stats = asyncio.run(_get_overall_statistics())
+
+        if json_output:
+            print(json.dumps(stats, indent=2, default=str))
+            return
+
+        _display_statistics(stats, job_id)
+
+    except Exception as e:
+        rprint(f"❌ [red]Failed to get statistics:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("history")
+def job_history(
+    limit: int = typer.Option(
+        20, "--limit", "-l", help="Number of recent executions to show", min=1, max=100
+    ),
+    job_id: str | None = typer.Option(
+        None, "--job-id", "-j", help="Filter by specific job ID"
+    ),
+    json_output: bool = typer.Option(
+        False, "--json", help="Output history in JSON format"
+    ),
+) -> None:
+    """
+    Show recent job execution history.
+
+    Displays execution times, durations, and results for recent job runs.
+    """
+
+    try:
+        if job_id:
+            rprint(
+                f"📚 [bold blue]Execution History for: {job_id}[/bold blue] "
+                f"(last {limit})"
+            )
+        else:
+            rprint(
+                f"📚 [bold blue]Recent Job Execution History[/bold blue] "
+                f"(last {limit})"
+            )
+
+        history = asyncio.run(_get_job_history(limit, job_id))
+
+        if json_output:
+            print(json.dumps(history, indent=2, default=str))
+            return
+
+        if not history:
+            rprint("ℹ️  [yellow]No execution history found[/yellow]")
+            return
+
+        table = Table(
+            title="🕰️  Job Execution History",
+            show_header=True,
+            header_style="bold magenta",
+        )
+        table.add_column("Timestamp", style="cyan")
+        table.add_column("Job ID", style="green")
+        table.add_column("Duration", style="yellow")
+        table.add_column("Status", style="bold")
+        table.add_column("Details", style="dim")
+
+        for execution in history:
+            status_color = "green" if execution.get("status") == "success" else "red"
+            duration = f"{execution.get('duration_ms', 0):.1f}ms"
+
+            status_value = execution.get('status', 'Unknown')
+            status_display = f"[{status_color}]{status_value}[/{status_color}]"
+            details = execution.get("details", "")[:50]
+            if len(execution.get("details", "")) > 50:
+                details += "..."
+
+            table.add_row(
+                execution.get("timestamp", "Unknown"),
+                execution.get("job_id", "Unknown"),
+                duration,
+                status_display,
+                details,
+            )
+
+        console.print(table)
+
+    except Exception as e:
+        rprint(f"❌ [red]Failed to get job history:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("trigger")
+def trigger_job(
+    job_id: str = typer.Argument(..., help="Job ID to trigger manually"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for job completion"),
+    timeout: int = typer.Option(
+        30, "--timeout", help="Timeout for waiting (seconds)", min=1, max=300
+    ),
+) -> None:
+    """
+    Manually trigger a scheduled job.
+
+    Executes the specified job immediately, bypassing the normal schedule.
+    Useful for testing job functionality or running jobs on-demand.
+    """
+
+    rprint(f"🚀 [bold blue]Triggering job:[/bold blue] {job_id}")
+
+    try:
+        # First verify the job exists
+        tasks = asyncio.run(_get_scheduled_tasks())
+        job_exists = any(task.job_id == job_id for task in tasks)
+
+        if not job_exists:
+            rprint(f"❌ [red]Job not found:[/red] {job_id}")
+            rprint("💡 [yellow]Use 'tasks list' to see available jobs[/yellow]")
+            raise typer.Exit(1)
+
+        # Trigger the job
+        result = asyncio.run(_trigger_job_execution(job_id, wait, timeout))
+
+        if result.get("status") == "success":
+            rprint(f"✅ [green]Job triggered successfully![/green]")
+            if wait and result.get("execution_details"):
+                details = result["execution_details"]
+                duration_ms = details.get('duration_ms', 0)
+                rprint(f"⏱️  [cyan]Duration:[/cyan] {duration_ms:.1f}ms")
+                rprint(f"📋 [cyan]Result:[/cyan] {details.get('result', 'No result')}")
+        else:
+            error_msg = result.get('error', 'Unknown error')
+            rprint(f"❌ [red]Job execution failed:[/red] {error_msg}")
+
+    except Exception as e:
+        rprint(f"❌ [red]Failed to trigger job:[/red] {e}")
+        raise typer.Exit(1)
+
+
+async def _get_scheduled_tasks() -> list[ScheduledTask]:
+    """Get list of scheduled tasks from the scheduler."""
+    manager = ScheduledTaskManager()
+    return await manager.list_tasks()
+
+
+async def _get_job_statistics(job_id: str) -> dict[str, Any]:
+    """Get statistics for a specific job."""
+    manager = ScheduledTaskManager()
+    return await manager.get_job_statistics(job_id)
+
+
+async def _get_overall_statistics() -> dict[str, Any]:
+    """Get overall scheduler statistics."""
+    manager = ScheduledTaskManager()
+    return await manager.get_overall_statistics()
+
+
+async def _get_job_history(limit: int, job_id: str | None) -> list[dict[str, Any]]:
+    """Get recent job execution history."""
+    manager = ScheduledTaskManager()
+    return await manager.get_job_history(limit, job_id)
+
+
+async def _trigger_job_execution(
+    job_id: str, wait: bool, timeout: int
+) -> dict[str, Any]:
+    """Trigger manual job execution."""
+    manager = ScheduledTaskManager()
+    return await manager.trigger_job(job_id, wait, timeout)
+
+
+def _display_statistics(stats: dict[str, Any], job_id: str | None) -> None:
+    """Display formatted statistics."""
+
+    if job_id:
+        # Job-specific statistics
+        info_text = f"""
+[bold cyan]Job Performance Metrics[/bold cyan]
+
+🏃 [yellow]Executions:[/yellow] {stats.get('total_executions', 0)}
+✅ [yellow]Successful:[/yellow] {stats.get('successful_executions', 0)}
+❌ [yellow]Failed:[/yellow] {stats.get('failed_executions', 0)}
+📊 [yellow]Success Rate:[/yellow] {stats.get('success_rate_percent', 0):.1f}%
+
+⏱️  [yellow]Avg Duration:[/yellow] {stats.get('avg_duration_ms', 0):.1f}ms
+🚀 [yellow]Min Duration:[/yellow] {stats.get('min_duration_ms', 0):.1f}ms
+🐌 [yellow]Max Duration:[/yellow] {stats.get('max_duration_ms', 0):.1f}ms
+
+🕐 [yellow]Last Execution:[/yellow] {stats.get('last_execution', 'Never')}
+🕑 [yellow]Next Scheduled:[/yellow] {stats.get('next_run', 'Not scheduled')}
+        """.strip()
+
+        title = f"📊 Statistics for {job_id}"
+        console.print(Panel(info_text, title=title, border_style="blue"))
+
+    else:
+        # Overall scheduler statistics
+        info_text = f"""
+[bold cyan]Scheduler Overview[/bold cyan]
+
+📋 [yellow]Total Jobs:[/yellow] {stats.get('total_jobs', 0)}
+🟢 [yellow]Active Jobs:[/yellow] {stats.get('active_jobs', 0)}
+🔴 [yellow]Paused Jobs:[/yellow] {stats.get('paused_jobs', 0)}
+
+🏃 [yellow]Total Executions:[/yellow] {stats.get('total_executions', 0)}
+✅ [yellow]Successful:[/yellow] {stats.get('successful_executions', 0)}
+❌ [yellow]Failed:[/yellow] {stats.get('failed_executions', 0)}
+
+📊 [yellow]Overall Success Rate:[/yellow] {stats.get('success_rate_percent', 0):.1f}%
+⏱️  [yellow]Avg Execution Time:[/yellow] {stats.get('avg_duration_ms', 0):.1f}ms
+
+🕐 [yellow]Scheduler Uptime:[/yellow] {stats.get('uptime', 'Unknown')}
+🔄 [yellow]Last Activity:[/yellow] {stats.get('last_activity', 'No recent activity')}
+        """.strip()
+
+        console.print(
+            Panel(info_text, title="📊 Scheduler Statistics", border_style="green")
+        )
+
+
+if __name__ == "__main__":
+    app()
+{%- endif -%}

aegis/templates/copier-aegis-project/{{ project_slug }}/app/components/backend/api/ai/__init__.py

@@ -0,0 +1,8 @@
+"""
+AI service API routes.
+
+REST API endpoints for AI chat functionality.
+"""
+
+# API routes will be exported here in ticket #159
+__all__ = []

aegis/templates/copier-aegis-project/{{ 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/copier-aegis-project/{{ project_slug }}/app/components/backend/api/auth/__init__.py

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