claude-mpm 4.1.4__py3-none-any.whl → 4.1.6__py3-none-any.whl

claude_mpm/services/socketio/server/main.py

@@ -35,6 +35,7 @@ from ....core.logging_config import get_logger
 from ...core.interfaces.communication import SocketIOServiceInterface
 from ..handlers import EventHandlerRegistry, FileEventHandler, GitEventHandler
 from .broadcaster import SocketIOEventBroadcaster
+from .connection_manager import ConnectionManager
 from .core import SocketIOServerCore
 from .eventbus_integration import EventBusIntegration
 
@@ -91,6 +92,9 @@ class SocketIOServer(SocketIOServiceInterface):
         # EventBus integration
         self.eventbus_integration = None
 
+        # Connection manager for robust connection tracking
+        self.connection_manager = None
+
     def start_sync(self):
         """Start the Socket.IO server in a background thread (synchronous version)."""
         if not SOCKETIO_AVAILABLE:
@@ -110,7 +114,13 @@ class SocketIOServer(SocketIOServiceInterface):
         # Start the core server
         self.core.start_sync()
 
-        # Initialize broadcaster with core server components
+        # Initialize connection manager for robust connection tracking
+        self.connection_manager = ConnectionManager(
+            max_buffer_size=getattr(SystemLimits, "MAX_EVENTS_BUFFER", 1000),
+            event_ttl=300,  # 5 minutes TTL for buffered events
+        )
+
+        # Initialize broadcaster with core server components and connection manager
         self.broadcaster = SocketIOEventBroadcaster(
             sio=self.core.sio,
             connected_clients=self.connected_clients,
@@ -119,6 +129,7 @@ class SocketIOServer(SocketIOServiceInterface):
             stats=self.stats,
             logger=self.logger,
             server=self,  # Pass server reference for event history access
+            connection_manager=self.connection_manager,  # Pass connection manager
         )
 
         # Wait for the event loop to be initialized in the background thread
@@ -146,6 +157,12 @@ class SocketIOServer(SocketIOServiceInterface):
             # Start the retry processor for resilient event delivery
             self.broadcaster.start_retry_processor()
 
+            # Start connection health monitoring
+            if self.connection_manager:
+                asyncio.run_coroutine_threadsafe(
+                    self.connection_manager.start_health_monitoring(), self.core.loop
+                )
+
         # Register events
         self._register_events()
 
@@ -200,6 +217,15 @@ class SocketIOServer(SocketIOServiceInterface):
         if self.broadcaster:
             self.broadcaster.stop_retry_processor()
 
+        # Stop connection health monitoring
+        if self.connection_manager and self.core.loop:
+            try:
+                asyncio.run_coroutine_threadsafe(
+                    self.connection_manager.stop_health_monitoring(), self.core.loop
+                ).result(timeout=2)
+            except Exception as e:
+                self.logger.warning(f"Error stopping health monitoring: {e}")
+
         # Teardown EventBus integration
         if self.eventbus_integration:
             try:

claude_mpm/services/ticket_manager.py

@@ -6,7 +6,11 @@ class TicketManager:
 
     def create_task(self, *args, **kwargs):
         """Stub method."""
-        return
+        return "TSK-STUB-001"  # Return a stub ticket ID
+
+    def create_ticket(self, *args, **kwargs):
+        """Stub method - alias for create_task."""
+        return self.create_task(*args, **kwargs)
 
     def list_recent_tickets(self, *args, **kwargs):
         """Stub method."""

claude_mpm/services/ticket_services/__init__.py

@@ -0,0 +1,26 @@
+"""
+Ticket services for clean separation of concerns.
+
+WHY: Extract business logic from the god class TicketsCommand into
+focused, testable service modules following SOLID principles.
+
+DESIGN DECISIONS:
+- Each service has a single responsibility
+- Services use dependency injection for flexibility
+- Clear interfaces for each service
+- Services are stateless for better testability
+"""
+
+from .crud_service import TicketCRUDService
+from .formatter_service import TicketFormatterService
+from .search_service import TicketSearchService
+from .validation_service import TicketValidationService
+from .workflow_service import TicketWorkflowService
+
+__all__ = [
+    "TicketCRUDService",
+    "TicketFormatterService",
+    "TicketSearchService",
+    "TicketValidationService",
+    "TicketWorkflowService",
+]

claude_mpm/services/ticket_services/crud_service.py

@@ -0,0 +1,328 @@
+"""
+CRUD operations service for tickets.
+
+WHY: Centralizes all Create, Read, Update, Delete operations for tickets,
+separating data access from presentation logic.
+
+DESIGN DECISIONS:
+- Uses TicketManager as backend (can be replaced with actual implementation)
+- Returns standardized response objects
+- Handles aitrackdown CLI fallback for operations not in TicketManager
+- Provides consistent error handling
+"""
+
+import json
+import subprocess
+from typing import Any, Dict, List, Optional
+
+from ...core.logger import get_logger
+
+
+class TicketCRUDService:
+    """Service for ticket CRUD operations."""
+
+    def __init__(self, ticket_manager=None):
+        """
+        Initialize the CRUD service.
+
+        Args:
+            ticket_manager: Optional ticket manager instance for testing
+        """
+        self.logger = get_logger("services.ticket_crud")
+        self._ticket_manager = ticket_manager
+
+    @property
+    def ticket_manager(self):
+        """Lazy load ticket manager."""
+        if self._ticket_manager is None:
+            try:
+                from ..ticket_manager import TicketManager
+            except ImportError:
+                from claude_mpm.services.ticket_manager import TicketManager
+            self._ticket_manager = TicketManager()
+        return self._ticket_manager
+
+    def create_ticket(
+        self,
+        title: str,
+        ticket_type: str = "task",
+        priority: str = "medium",
+        description: str = "",
+        tags: Optional[List[str]] = None,
+        parent_epic: Optional[str] = None,
+        parent_issue: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new ticket.
+
+        Returns:
+            Dict with success status and ticket_id or error message
+        """
+        try:
+            ticket_id = self.ticket_manager.create_ticket(
+                title=title,
+                ticket_type=ticket_type,
+                description=description,
+                priority=priority,
+                tags=tags or [],
+                source="claude-mpm-cli",
+                parent_epic=parent_epic,
+                parent_issue=parent_issue,
+            )
+
+            if ticket_id:
+                return {
+                    "success": True,
+                    "ticket_id": ticket_id,
+                    "message": f"Created ticket: {ticket_id}",
+                }
+            return {"success": False, "error": "Failed to create ticket"}
+        except Exception as e:
+            self.logger.error(f"Error creating ticket: {e}")
+            return {"success": False, "error": str(e)}
+
+    def get_ticket(self, ticket_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get a specific ticket by ID.
+
+        Returns:
+            Ticket data or None if not found
+        """
+        try:
+            return self.ticket_manager.get_ticket(ticket_id)
+        except Exception as e:
+            self.logger.error(f"Error getting ticket {ticket_id}: {e}")
+            return None
+
+    def list_tickets(
+        self,
+        limit: int = 20,
+        page: int = 1,
+        page_size: int = 20,
+        type_filter: str = "all",
+        status_filter: str = "all",
+    ) -> Dict[str, Any]:
+        """
+        List tickets with pagination and filtering.
+
+        Returns:
+            Dict with tickets list and pagination info
+        """
+        try:
+            # Try aitrackdown CLI first for better pagination
+            tickets = self._list_via_aitrackdown(
+                limit, page, page_size, type_filter, status_filter
+            )
+
+            if tickets is None:
+                # Fallback to TicketManager
+                tickets = self._list_via_manager(
+                    limit, page, page_size, type_filter, status_filter
+                )
+
+            return {
+                "success": True,
+                "tickets": tickets,
+                "page": page,
+                "page_size": page_size,
+                "total_shown": len(tickets),
+            }
+        except Exception as e:
+            self.logger.error(f"Error listing tickets: {e}")
+            return {"success": False, "error": str(e), "tickets": []}
+
+    def _list_via_aitrackdown(
+        self,
+        limit: int,
+        page: int,
+        page_size: int,
+        type_filter: str,
+        status_filter: str,
+    ) -> Optional[List[Dict]]:
+        """List tickets using aitrackdown CLI."""
+        try:
+            cmd = ["aitrackdown", "status", "tasks"]
+
+            # Calculate offset for pagination
+            offset = (page - 1) * page_size
+            total_needed = offset + page_size
+            cmd.extend(["--limit", str(total_needed * 2)])
+
+            # Add filters
+            if type_filter != "all":
+                cmd.extend(["--type", type_filter])
+            if status_filter != "all":
+                cmd.extend(["--status", status_filter])
+
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+            if result.stdout.strip():
+                all_tickets = json.loads(result.stdout)
+                if isinstance(all_tickets, list):
+                    # Apply pagination
+                    return all_tickets[offset : offset + page_size]
+            return []
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            json.JSONDecodeError,
+        ) as e:
+            self.logger.debug(f"aitrackdown not available: {e}")
+            return None
+
+    def _list_via_manager(
+        self,
+        limit: int,
+        page: int,
+        page_size: int,
+        type_filter: str,
+        status_filter: str,
+    ) -> List[Dict]:
+        """List tickets using TicketManager."""
+        all_tickets = self.ticket_manager.list_recent_tickets(limit=limit * 2)
+
+        # Apply filters
+        filtered_tickets = []
+        for ticket in all_tickets:
+            if type_filter != "all":
+                ticket_type = ticket.get("metadata", {}).get("ticket_type", "unknown")
+                if ticket_type != type_filter:
+                    continue
+
+            if status_filter != "all":
+                if ticket.get("status") != status_filter:
+                    continue
+
+            filtered_tickets.append(ticket)
+
+        # Apply pagination
+        offset = (page - 1) * page_size
+        return filtered_tickets[offset : offset + page_size]
+
+    def update_ticket(
+        self,
+        ticket_id: str,
+        status: Optional[str] = None,
+        priority: Optional[str] = None,
+        description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        assignees: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Update a ticket's properties.
+
+        Returns:
+            Dict with success status and message
+        """
+        try:
+            updates = {}
+            if status:
+                updates["status"] = status
+            if priority:
+                updates["priority"] = priority
+            if description:
+                updates["description"] = description
+            if tags:
+                updates["tags"] = tags
+            if assignees:
+                updates["assignees"] = assignees
+
+            if not updates:
+                return {"success": False, "error": "No updates specified"}
+
+            # Try TicketManager first
+            success = self.ticket_manager.update_task(ticket_id, **updates)
+
+            if success:
+                return {"success": True, "message": f"Updated ticket: {ticket_id}"}
+
+            # Fallback to aitrackdown CLI for status transitions
+            if status:
+                return self._update_via_aitrackdown(ticket_id, status, updates)
+
+            return {"success": False, "error": f"Failed to update ticket: {ticket_id}"}
+        except Exception as e:
+            self.logger.error(f"Error updating ticket {ticket_id}: {e}")
+            return {"success": False, "error": str(e)}
+
+    def _update_via_aitrackdown(
+        self, ticket_id: str, status: str, updates: Dict
+    ) -> Dict[str, Any]:
+        """Update ticket using aitrackdown CLI."""
+        try:
+            cmd = ["aitrackdown", "transition", ticket_id, status]
+
+            # Add comment with other updates
+            comment_parts = []
+            if updates.get("priority"):
+                comment_parts.append(f"Priority: {updates['priority']}")
+            if updates.get("assignees"):
+                comment_parts.append(f"Assigned to: {', '.join(updates['assignees'])}")
+            if updates.get("tags"):
+                comment_parts.append(f"Tags: {', '.join(updates['tags'])}")
+
+            if comment_parts:
+                comment = " | ".join(comment_parts)
+                cmd.extend(["--comment", comment])
+
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+            return {"success": True, "message": f"Updated ticket: {ticket_id}"}
+        except subprocess.CalledProcessError as e:
+            self.logger.error(f"Failed to update via CLI: {e}")
+            return {"success": False, "error": f"Failed to update ticket: {ticket_id}"}
+
+    def close_ticket(
+        self, ticket_id: str, resolution: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Close a ticket.
+
+        Returns:
+            Dict with success status and message
+        """
+        try:
+            # Try TicketManager first
+            success = self.ticket_manager.close_task(ticket_id, resolution=resolution)
+
+            if success:
+                return {"success": True, "message": f"Closed ticket: {ticket_id}"}
+
+            # Fallback to aitrackdown CLI
+            return self._close_via_aitrackdown(ticket_id, resolution)
+        except Exception as e:
+            self.logger.error(f"Error closing ticket {ticket_id}: {e}")
+            return {"success": False, "error": str(e)}
+
+    def _close_via_aitrackdown(
+        self, ticket_id: str, resolution: Optional[str]
+    ) -> Dict[str, Any]:
+        """Close ticket using aitrackdown CLI."""
+        try:
+            cmd = ["aitrackdown", "close", ticket_id]
+            if resolution:
+                cmd.extend(["--comment", resolution])
+
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+            return {"success": True, "message": f"Closed ticket: {ticket_id}"}
+        except subprocess.CalledProcessError:
+            return {"success": False, "error": f"Failed to close ticket: {ticket_id}"}
+
+    def delete_ticket(self, ticket_id: str, force: bool = False) -> Dict[str, Any]:
+        """
+        Delete a ticket.
+
+        Returns:
+            Dict with success status and message
+        """
+        try:
+            cmd = ["aitrackdown", "delete", ticket_id]
+            if force:
+                cmd.append("--force")
+
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+            return {"success": True, "message": f"Deleted ticket: {ticket_id}"}
+        except subprocess.CalledProcessError:
+            return {"success": False, "error": f"Failed to delete ticket: {ticket_id}"}
+        except Exception as e:
+            self.logger.error(f"Error deleting ticket {ticket_id}: {e}")
+            return {"success": False, "error": str(e)}