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

claude_mpm/services/ticket_manager.py

@@ -1,213 +1,29 @@
-"""Ticket management using ai-trackdown-pytools."""
+"""Ticket manager stub for backward compatibility."""
 
-from pathlib import Path
-from typing import Optional, Dict, Any, List
-from datetime import datetime
 
-try:
-    from ..core.logger import get_logger
-except ImportError:
-    from core.logger import get_logger
+class TicketManager:
+    """Stub TicketManager class for backward compatibility."""
 
+    def create_task(self, *args, **kwargs):
+        """Stub method."""
+        return "TSK-STUB-001"  # Return a stub ticket ID
 
-class TicketManager:
-    """
-    Manage ticket creation using ai-trackdown-pytools.
-    
-    This wraps the ai-trackdown-pytools API for creating tickets
-    in the standard tickets/ directory structure.
-    """
-    
-    def __init__(self, project_path: Optional[Path] = None):
-        """
-        Initialize ticket manager.
-        
-        Args:
-            project_path: Project root (defaults to current directory)
-        """
-        self.logger = get_logger("ticket_manager")
-        self.project_path = project_path or Path.cwd()
-        self.task_manager = self._init_task_manager()
-        
-    def _init_task_manager(self):
-        """Initialize ai-trackdown-pytools TaskManager."""
-        try:
-            from ai_trackdown_pytools.core.task import TaskManager
-            from ai_trackdown_pytools import Config, Project
-            
-            # First, ensure tickets directory exists
-            tickets_dir = self.project_path / "tickets"
-            if not tickets_dir.exists():
-                tickets_dir.mkdir(exist_ok=True)
-                (tickets_dir / "epics").mkdir(exist_ok=True)
-                (tickets_dir / "issues").mkdir(exist_ok=True)
-                (tickets_dir / "tasks").mkdir(exist_ok=True)
-                self.logger.info(f"Created tickets directory structure at: {tickets_dir}")
-            
-            # Check if we need to configure ai-trackdown
-            config_file = self.project_path / ".trackdown.yaml"
-            if not config_file.exists():
-                # Create default config that uses tickets/ directory
-                config = Config.create_default(config_file)
-                config.set("paths.tickets_dir", "tickets")
-                config.set("paths.epics_dir", "tickets/epics")
-                config.set("paths.issues_dir", "tickets/issues")
-                config.set("paths.tasks_dir", "tickets/tasks")
-                config.save()
-                self.logger.info("Created .trackdown.yaml configuration")
-            
-            # Initialize TaskManager directly with the project path
-            # TaskManager will handle project initialization internally
-            task_manager = TaskManager(self.project_path)
-            
-            # Verify it's using the right directory
-            if hasattr(task_manager, 'tasks_dir'):
-                self.logger.info(f"TaskManager using tasks directory: {task_manager.tasks_dir}")
-            else:
-                self.logger.info(f"Initialized TaskManager for: {self.project_path}")
-            
-            return task_manager
-            
-        except ImportError:
-            self.logger.error("ai-trackdown-pytools not installed")
-            self.logger.info("Install with: pip install ai-trackdown-pytools")
-            return None
-        except Exception as e:
-            self.logger.error(f"Failed to initialize TaskManager: {e}")
-            self.logger.debug(f"Error details: {str(e)}", exc_info=True)
-            return None
-    
-    def create_ticket(
-        self,
-        title: str,
-        ticket_type: str = "task",
-        description: str = "",
-        priority: str = "medium",
-        tags: Optional[List[str]] = None,
-        source: str = "claude-mpm",
-        parent_epic: Optional[str] = None,
-        parent_issue: Optional[str] = None,
-        **kwargs
-    ) -> Optional[str]:
-        """
-        Create a ticket using ai-trackdown-pytools.
-        
-        Args:
-            title: Ticket title
-            ticket_type: Type (task, bug, feature, etc.)
-            description: Detailed description
-            priority: Priority level (low, medium, high)
-            tags: List of tags/labels
-            source: Source identifier
-            **kwargs: Additional metadata
-            
-        Returns:
-            Ticket ID if created, None on failure
-        """
-        if not self.task_manager:
-            self.logger.error("TaskManager not available")
-            return None
-        
-        try:
-            # Prepare tags
-            if tags is None:
-                tags = []
-            
-            # Add type and source tags
-            tags.extend([ticket_type, f"source:{source}", "auto-extracted"])
-            
-            # Remove duplicates
-            tags = list(set(tags))
-            
-            # Prepare task data
-            task_data = {
-                'title': title,
-                'description': description or f"Auto-extracted {ticket_type} from Claude MPM session",
-                'status': 'open',
-                'priority': priority.lower(),
-                'assignees': [],
-                'tags': tags,
-                'metadata': {
-                    'source': source,
-                    'ticket_type': ticket_type,
-                    'created_by': 'claude-mpm',
-                    'extracted_at': datetime.now().isoformat(),
-                    **kwargs
-                }
-            }
-            
-            # Create the task
-            task = self.task_manager.create_task(**task_data)
-            
-            self.logger.info(f"Created ticket: {task.id} - {title}")
-            return task.id
-            
-        except Exception as e:
-            self.logger.error(f"Failed to create ticket: {e}")
-            return None
-    
-    def list_recent_tickets(self, limit: int = 10) -> List[Dict[str, Any]]:
-        """
-        List recent tickets.
-        
-        Args:
-            limit: Maximum number of tickets to return
-            
-        Returns:
-            List of ticket summaries
-        """
-        if not self.task_manager:
-            return []
-        
-        try:
-            tasks = self.task_manager.get_recent_tasks(limit=limit)
-            
-            tickets = []
-            for task in tasks:
-                tickets.append({
-                    'id': task.id,
-                    'title': task.title,
-                    'status': task.status,
-                    'priority': task.priority,
-                    'tags': task.tags,
-                    'created_at': task.created_at,
-                })
-            
-            return tickets
-            
-        except Exception as e:
-            self.logger.error(f"Failed to list tickets: {e}")
-            return []
-    
-    def get_ticket(self, ticket_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get a specific ticket.
-        
-        Args:
-            ticket_id: Ticket ID
-            
-        Returns:
-            Ticket data or None
-        """
-        if not self.task_manager:
-            return None
-        
-        try:
-            task = self.task_manager.load_task(ticket_id)
-            
-            return {
-                'id': task.id,
-                'title': task.title,
-                'description': task.description,
-                'status': task.status,
-                'priority': task.priority,
-                'tags': task.tags,
-                'assignees': task.assignees,
-                'created_at': task.created_at,
-                'updated_at': task.updated_at,
-                'metadata': task.metadata,
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Failed to get ticket {ticket_id}: {e}")
-            return None
+    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."""
+        return []
+
+    def get_ticket(self, *args, **kwargs):
+        """Stub method."""
+        return
+
+    def update_task(self, *args, **kwargs):
+        """Stub method."""
+        return False
+
+    def close_task(self, *args, **kwargs):
+        """Stub method."""
+        return False

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)}