claude-mpm 5.4.85__py3-none-any.whl → 5.6.1__py3-none-any.whl

claude_mpm/commander/api/routes/events.py

@@ -0,0 +1,184 @@
+"""REST API routes for event resolution.
+
+Provides HTTP endpoints for resolving events and managing event responses.
+"""
+
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+
+from ...events.manager import EventManager
+
+router = APIRouter()
+
+
+def get_event_manager() -> EventManager:
+    """Dependency to get the global event manager instance.
+
+    Returns:
+        The global event manager instance
+
+    Raises:
+        RuntimeError: If event manager is not initialized
+    """
+    from ..app import event_manager
+
+    if event_manager is None:
+        raise RuntimeError("Event manager not initialized")
+    return event_manager
+
+
+def get_event_handler():
+    """Dependency to get the global event handler instance.
+
+    Returns:
+        The global event handler instance
+
+    Raises:
+        RuntimeError: If event handler is not initialized
+    """
+    from ..app import event_handler
+
+    if event_handler is None:
+        raise RuntimeError("Event handler not initialized")
+    return event_handler
+
+
+class EventResponse(BaseModel):
+    """Request model for event resolution.
+
+    Attributes:
+        response: User's response to the event
+    """
+
+    response: str
+
+
+class EventResolutionResponse(BaseModel):
+    """Response model for event resolution.
+
+    Attributes:
+        event_id: ID of resolved event
+        status: Resolution status
+        session_resumed: Whether project session was resumed
+    """
+
+    event_id: str
+    status: str
+    session_resumed: bool
+
+
+class PendingEventResponse(BaseModel):
+    """Response model for pending event.
+
+    Attributes:
+        event_id: Unique event identifier
+        project_id: Project that raised this event
+        event_type: Type of event
+        priority: Urgency level
+        status: Current lifecycle status
+        title: Short event summary
+        content: Detailed event message
+        options: For DECISION_NEEDED events, list of choices
+        is_blocking: Whether event blocks progress
+    """
+
+    event_id: str
+    project_id: str
+    event_type: str
+    priority: str
+    status: str
+    title: str
+    content: str
+    options: Optional[List[str]]
+    is_blocking: bool
+
+
+@router.post("/events/{event_id}/resolve", response_model=EventResolutionResponse)
+async def resolve_event(
+    event_id: str,
+    response: EventResponse,
+    event_handler=Depends(get_event_handler),
+) -> EventResolutionResponse:
+    """Resolve an event with user response.
+
+    Marks the event as resolved and resumes the project session if it was
+    paused for this event.
+
+    Args:
+        event_id: ID of event to resolve
+        response: User's response to the event
+
+    Returns:
+        Resolution status and whether session was resumed
+
+    Raises:
+        HTTPException: If event not found (404) or resolution fails (500)
+
+    Example:
+        POST /api/events/evt_123/resolve
+        {
+            "response": "Use authlib for OAuth2"
+        }
+
+        Response:
+        {
+            "event_id": "evt_123",
+            "status": "resolved",
+            "session_resumed": true
+        }
+    """
+    try:
+        session_resumed = await event_handler.resolve_event(event_id, response.response)
+        return EventResolutionResponse(
+            event_id=event_id,
+            status="resolved",
+            session_resumed=session_resumed,
+        )
+    except KeyError as e:
+        raise HTTPException(
+            status_code=404, detail=f"Event not found: {event_id}"
+        ) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to resolve event: {e!s}"
+        ) from e
+
+
+@router.get("/events/pending", response_model=List[PendingEventResponse])
+async def get_pending_events(
+    project_id: Optional[str] = Query(None, description="Filter by project ID"),
+    event_handler=Depends(get_event_handler),
+) -> List[PendingEventResponse]:
+    """Get pending events requiring resolution.
+
+    Returns all unresolved events, optionally filtered by project.
+    Events are sorted by priority (high to low) then created time (old to new).
+
+    Args:
+        project_id: If provided, only return events for this project
+
+    Returns:
+        List of pending events
+
+    Example:
+        GET /api/events/pending
+        GET /api/events/pending?project_id=proj_123
+    """
+    events = await event_handler.get_pending_events(project_id)
+
+    return [
+        PendingEventResponse(
+            event_id=event.id,
+            project_id=event.project_id,
+            event_type=event.type.value,
+            priority=event.priority.value,
+            status=event.status.value,
+            title=event.title,
+            content=event.content,
+            options=event.options,
+            is_blocking=event_handler.is_blocking(event),
+        )
+        for event in events
+    ]

claude_mpm/commander/api/routes/inbox.py

@@ -0,0 +1,171 @@
+"""REST API routes for inbox system.
+
+Provides HTTP endpoints for querying and managing the event inbox.
+"""
+
+from datetime import datetime
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, Query
+from pydantic import BaseModel
+
+from ...inbox import Inbox
+from ...models.events import EventPriority, EventType
+
+router = APIRouter()
+
+
+def get_inbox() -> Inbox:
+    """Dependency to get the global inbox instance.
+
+    Returns:
+        The global inbox instance
+
+    Raises:
+        RuntimeError: If inbox is not initialized
+    """
+    from ..app import inbox
+
+    if inbox is None:
+        raise RuntimeError("Inbox not initialized")
+    return inbox
+
+
+class InboxItemResponse(BaseModel):
+    """Response model for inbox item.
+
+    Attributes:
+        event_id: Unique event identifier
+        project_id: Project that raised this event
+        project_name: Human-readable project name
+        project_path: Filesystem path to project
+        event_type: Type of event (decision, error, status, etc.)
+        priority: Urgency level (critical, high, normal, low, info)
+        status: Current lifecycle status
+        title: Short event summary
+        content: Detailed event message
+        options: For DECISION_NEEDED events, list of choices
+        age_display: Human-readable age (e.g., "5m ago")
+        created_at: When event was created
+        session_runtime: Optional session runtime identifier
+    """
+
+    event_id: str
+    project_id: str
+    project_name: str
+    project_path: str
+    event_type: str
+    priority: str
+    status: str
+    title: str
+    content: str
+    options: Optional[List[str]]
+    age_display: str
+    created_at: datetime
+    session_runtime: Optional[str]
+
+
+class InboxCountsResponse(BaseModel):
+    """Response model for inbox counts.
+
+    Attributes:
+        critical: Count of CRITICAL priority events
+        high: Count of HIGH priority events
+        normal: Count of NORMAL priority events
+        low: Count of LOW priority events
+        info: Count of INFO priority events
+        total: Total count of all pending events
+    """
+
+    critical: int
+    high: int
+    normal: int
+    low: int
+    info: int
+    total: int
+
+
+@router.get("/inbox", response_model=List[InboxItemResponse])
+async def get_inbox_items(
+    limit: int = Query(50, ge=1, le=100, description="Maximum items to return"),
+    offset: int = Query(0, ge=0, description="Number of items to skip"),
+    priority: Optional[str] = Query(None, description="Filter by priority level"),
+    project_id: Optional[str] = Query(None, description="Filter by project ID"),
+    event_type: Optional[str] = Query(None, description="Filter by event type"),
+    inbox: Inbox = Depends(get_inbox),
+) -> List[InboxItemResponse]:
+    """Get inbox items with optional filtering and pagination.
+
+    Returns a list of inbox items sorted by priority (high to low) then
+    created time (old to new). Supports filtering by priority, project,
+    and event type.
+
+    Args:
+        limit: Maximum number of items to return (1-100, default: 50)
+        offset: Number of items to skip for pagination (default: 0)
+        priority: Filter by priority (critical, high, normal, low, info)
+        project_id: Filter by project ID
+        event_type: Filter by event type (decision_needed, error, etc.)
+
+    Returns:
+        List of inbox items matching the filters
+
+    Example:
+        GET /api/inbox?limit=20&priority=critical
+        GET /api/inbox?project_id=proj_123&event_type=error
+        GET /api/inbox?offset=50&limit=50  # Pagination
+    """
+    # Parse enum values if provided
+    pri = EventPriority(priority) if priority else None
+    evt = EventType(event_type) if event_type else None
+
+    items = inbox.get_items(
+        limit=limit,
+        offset=offset,
+        priority=pri,
+        project_id=project_id,
+        event_type=evt,
+    )
+
+    return [
+        InboxItemResponse(
+            event_id=item.event.id,
+            project_id=item.event.project_id,
+            project_name=item.project_name,
+            project_path=item.project_path,
+            event_type=item.event.type.value,
+            priority=item.event.priority.value,
+            status=item.event.status.value,
+            title=item.event.title,
+            content=item.event.content,
+            options=item.event.options,
+            age_display=item.age_display,
+            created_at=item.event.created_at,
+            session_runtime=item.session_runtime,
+        )
+        for item in items
+    ]
+
+
+@router.get("/inbox/counts", response_model=InboxCountsResponse)
+async def get_inbox_counts(
+    project_id: Optional[str] = Query(None, description="Filter by project ID"),
+    inbox: Inbox = Depends(get_inbox),
+) -> InboxCountsResponse:
+    """Get count of pending events by priority.
+
+    Returns summary statistics showing how many events exist at each
+    priority level. Optionally filtered to a specific project.
+
+    Args:
+        project_id: If provided, only count events for this project
+
+    Returns:
+        Breakdown of event counts by priority
+
+    Example:
+        GET /api/inbox/counts
+        GET /api/inbox/counts?project_id=proj_123
+    """
+    counts = inbox.get_counts(project_id)
+    return InboxCountsResponse(**counts.__dict__)

claude_mpm/commander/api/routes/messages.py

@@ -0,0 +1,148 @@
+"""Message and thread management endpoints for MPM Commander API.
+
+This module implements REST endpoints for sending messages and retrieving
+conversation threads for projects.
+"""
+
+import uuid
+from typing import List
+
+from fastapi import APIRouter
+
+from ...models import ThreadMessage
+from ..errors import ProjectNotFoundError
+from ..schemas import MessageResponse, SendMessageRequest
+
+router = APIRouter()
+
+
+def _get_registry():
+    """Get registry instance from app global."""
+    from ..app import registry
+
+    if registry is None:
+        raise RuntimeError("Registry not initialized")
+    return registry
+
+
+def _message_to_response(message: ThreadMessage) -> MessageResponse:
+    """Convert ThreadMessage model to MessageResponse schema.
+
+    Args:
+        message: ThreadMessage instance
+
+    Returns:
+        MessageResponse with message data
+    """
+    return MessageResponse(
+        id=message.id,
+        role=message.role,
+        content=message.content,
+        session_id=message.session_id,
+        timestamp=message.timestamp,
+    )
+
+
+@router.get("/projects/{project_id}/thread", response_model=List[MessageResponse])
+async def get_thread(project_id: str) -> List[MessageResponse]:
+    """Get conversation thread for a project.
+
+    Returns all messages in chronological order.
+
+    Args:
+        project_id: Unique project identifier
+
+    Returns:
+        List of messages in thread (may be empty)
+
+    Raises:
+        ProjectNotFoundError: If project_id doesn't exist
+
+    Example:
+        GET /api/projects/abc-123/thread
+        Response: [
+            {
+                "id": "msg-1",
+                "role": "user",
+                "content": "Fix the login bug",
+                "session_id": null,
+                "timestamp": "2025-01-12T10:00:00Z"
+            },
+            {
+                "id": "msg-2",
+                "role": "assistant",
+                "content": "I'll investigate the login issue",
+                "session_id": "sess-456",
+                "timestamp": "2025-01-12T10:00:30Z"
+            }
+        ]
+    """
+    registry = _get_registry()
+    project = registry.get(project_id)
+
+    if project is None:
+        raise ProjectNotFoundError(project_id)
+
+    # Convert thread messages to responses
+    return [_message_to_response(m) for m in project.thread]
+
+
+@router.post(
+    "/projects/{project_id}/messages", response_model=MessageResponse, status_code=201
+)
+async def send_message(project_id: str, req: SendMessageRequest) -> MessageResponse:
+    """Send a message to a project's active session.
+
+    Adds message to conversation thread and sends to specified or active session.
+
+    Args:
+        project_id: Unique project identifier
+        req: Message request with content and optional session_id
+
+    Returns:
+        Created message information
+
+    Raises:
+        ProjectNotFoundError: If project_id doesn't exist
+
+    Example:
+        POST /api/projects/abc-123/messages
+        Body: {
+            "content": "Fix the login bug",
+            "session_id": "sess-456"
+        }
+        Response: {
+            "id": "msg-1",
+            "role": "user",
+            "content": "Fix the login bug",
+            "session_id": "sess-456",
+            "timestamp": "2025-01-12T10:00:00Z"
+        }
+    """
+    registry = _get_registry()
+    project = registry.get(project_id)
+
+    if project is None:
+        raise ProjectNotFoundError(project_id)
+
+    # Generate message ID
+    message_id = str(uuid.uuid4())
+
+    # Create message object
+    message = ThreadMessage(
+        id=message_id,
+        role="user",
+        content=req.content,
+        session_id=req.session_id,
+    )
+
+    # Add to project thread
+    project.thread.append(message)
+
+    # Update last activity
+    registry.touch(project_id)
+
+    # TODO: Send to session/runtime adapter (Phase 2)
+    # For Phase 1, message is just stored in thread
+
+    return _message_to_response(message)