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

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

claude_mpm/services/ticket_services/formatter_service.py

@@ -0,0 +1,290 @@
+"""
+Output formatting service for tickets.
+
+WHY: Separates presentation logic from business logic, allowing for
+consistent formatting across different output modes and contexts.
+
+DESIGN DECISIONS:
+- Supports multiple output formats (text, json, yaml, table)
+- Uses emoji for visual status indicators
+- Handles pagination display
+- Provides consistent formatting patterns
+"""
+
+from typing import Any, Dict, List, Optional
+
+
+class TicketFormatterService:
+    """Service for formatting ticket output."""
+
+    # Status emoji mapping for visual indicators
+    STATUS_EMOJI = {
+        "open": "🔵",
+        "in_progress": "🟡",
+        "done": "🟢",
+        "closed": "⚫",
+        "blocked": "🔴",
+        "ready": "🟣",
+        "tested": "🟢",
+        "waiting": "🟠",
+    }
+
+    DEFAULT_EMOJI = "⚪"
+
+    def format_ticket_created(
+        self, ticket_id: str, verbose: bool = False, **metadata
+    ) -> List[str]:
+        """
+        Format output for created ticket.
+
+        Returns:
+            List of formatted output lines
+        """
+        lines = [f"✅ Created ticket: {ticket_id}"]
+
+        if verbose:
+            if metadata.get("type"):
+                lines.append(f"   Type: {metadata['type']}")
+            if metadata.get("priority"):
+                lines.append(f"   Priority: {metadata['priority']}")
+            if metadata.get("tags"):
+                lines.append(f"   Tags: {', '.join(metadata['tags'])}")
+            if metadata.get("parent_epic"):
+                lines.append(f"   Parent Epic: {metadata['parent_epic']}")
+            if metadata.get("parent_issue"):
+                lines.append(f"   Parent Issue: {metadata['parent_issue']}")
+
+        return lines
+
+    def format_ticket_list(
+        self,
+        tickets: List[Dict[str, Any]],
+        page: int = 1,
+        page_size: int = 20,
+        verbose: bool = False,
+    ) -> List[str]:
+        """
+        Format a list of tickets for display.
+
+        Returns:
+            List of formatted output lines
+        """
+        if not tickets:
+            return ["No tickets found matching criteria"]
+
+        total_shown = len(tickets)
+        lines = [f"Tickets (page {page}, showing {total_shown} tickets):", "-" * 80]
+
+        for ticket in tickets:
+            # Get status emoji
+            status = ticket.get("status", "unknown")
+            emoji = self.STATUS_EMOJI.get(status, self.DEFAULT_EMOJI)
+
+            lines.append(f"{emoji} [{ticket['id']}] {ticket['title']}")
+
+            if verbose:
+                ticket_type = ticket.get("metadata", {}).get("ticket_type", "task")
+                priority = ticket.get("priority", "medium")
+                lines.append(
+                    f"   Type: {ticket_type} | Status: {status} | Priority: {priority}"
+                )
+
+                if ticket.get("tags"):
+                    lines.append(f"   Tags: {', '.join(ticket['tags'])}")
+
+                lines.append(f"   Created: {ticket.get('created_at', 'Unknown')}")
+                lines.append("")
+
+        # Add pagination hints
+        if total_shown == page_size:
+            lines.extend(
+                [
+                    "-" * 80,
+                    f"📄 Page {page} | Showing {total_shown} tickets",
+                    f"💡 Next page: claude-mpm tickets list --page {page + 1} --page-size {page_size}",
+                ]
+            )
+            if page > 1:
+                lines.append(
+                    f"💡 Previous page: claude-mpm tickets list --page {page - 1} --page-size {page_size}"
+                )
+
+        return lines
+
+    def format_ticket_detail(
+        self, ticket: Dict[str, Any], verbose: bool = False
+    ) -> List[str]:
+        """
+        Format a single ticket's details for display.
+
+        Returns:
+            List of formatted output lines
+        """
+        if not ticket:
+            return ["❌ Ticket not found"]
+
+        lines = [
+            f"Ticket: {ticket['id']}",
+            "=" * 80,
+            f"Title: {ticket['title']}",
+            f"Type: {ticket.get('metadata', {}).get('ticket_type', 'unknown')}",
+            f"Status: {ticket['status']}",
+            f"Priority: {ticket['priority']}",
+        ]
+
+        if ticket.get("tags"):
+            lines.append(f"Tags: {', '.join(ticket['tags'])}")
+
+        if ticket.get("assignees"):
+            lines.append(f"Assignees: {', '.join(ticket['assignees'])}")
+
+        # Show parent references
+        metadata = ticket.get("metadata", {})
+        if metadata.get("parent_epic"):
+            lines.append(f"Parent Epic: {metadata['parent_epic']}")
+        if metadata.get("parent_issue"):
+            lines.append(f"Parent Issue: {metadata['parent_issue']}")
+
+        lines.extend(
+            [
+                "",
+                "Description:",
+                "-" * 40,
+                ticket.get("description", "No description"),
+                "",
+                f"Created: {ticket['created_at']}",
+                f"Updated: {ticket['updated_at']}",
+            ]
+        )
+
+        if verbose and metadata:
+            lines.extend(["", "Metadata:", "-" * 40])
+            for key, value in metadata.items():
+                if key not in ["parent_epic", "parent_issue", "ticket_type"]:
+                    lines.append(f"  {key}: {value}")
+
+        return lines
+
+    def format_search_results(
+        self, tickets: List[Dict[str, Any]], query: str, show_snippets: bool = True
+    ) -> List[str]:
+        """
+        Format search results with optional context snippets.
+
+        Returns:
+            List of formatted output lines
+        """
+        if not tickets:
+            return [f"No tickets found matching '{query}'"]
+
+        lines = [f"Search results for '{query}' (showing {len(tickets)}):", "-" * 80]
+
+        for ticket in tickets:
+            status = ticket.get("status", "unknown")
+            emoji = self.STATUS_EMOJI.get(status, self.DEFAULT_EMOJI)
+
+            lines.append(f"{emoji} [{ticket['id']}] {ticket['title']}")
+
+            if show_snippets:
+                # Show snippet if query appears in description
+                desc = ticket.get("description", "")
+                if query.lower() in desc.lower():
+                    snippet = self._get_search_snippet(desc, query)
+                    lines.append(f"   {snippet}")
+
+        return lines
+
+    def _get_search_snippet(
+        self, text: str, query: str, context_chars: int = 30
+    ) -> str:
+        """
+        Extract a snippet of text around the search query.
+
+        Returns:
+            Formatted snippet with ellipsis if truncated
+        """
+        lower_text = text.lower()
+        query_lower = query.lower()
+
+        if query_lower not in lower_text:
+            return ""
+
+        idx = lower_text.index(query_lower)
+        start = max(0, idx - context_chars)
+        end = min(len(text), idx + len(query) + context_chars)
+
+        snippet = text[start:end]
+
+        if start > 0:
+            snippet = "..." + snippet
+        if end < len(text):
+            snippet = snippet + "..."
+
+        return snippet
+
+    def format_operation_result(
+        self,
+        operation: str,
+        ticket_id: str,
+        success: bool,
+        message: Optional[str] = None,
+    ) -> str:
+        """
+        Format the result of a ticket operation.
+
+        Returns:
+            Formatted result message
+        """
+        if success:
+            emoji = "✅"
+            default_messages = {
+                "update": f"Updated ticket: {ticket_id}",
+                "close": f"Closed ticket: {ticket_id}",
+                "delete": f"Deleted ticket: {ticket_id}",
+                "comment": f"Added comment to ticket: {ticket_id}",
+                "workflow": f"Updated workflow state for {ticket_id}",
+            }
+            msg = message or default_messages.get(
+                operation, f"Operation completed: {ticket_id}"
+            )
+        else:
+            emoji = "❌"
+            default_messages = {
+                "update": f"Failed to update ticket: {ticket_id}",
+                "close": f"Failed to close ticket: {ticket_id}",
+                "delete": f"Failed to delete ticket: {ticket_id}",
+                "comment": f"Failed to add comment to ticket: {ticket_id}",
+                "workflow": f"Failed to update workflow state for ticket: {ticket_id}",
+            }
+            msg = message or default_messages.get(
+                operation, f"Operation failed: {ticket_id}"
+            )
+
+        return f"{emoji} {msg}"
+
+    def format_error(self, error: str) -> str:
+        """
+        Format an error message.
+
+        Returns:
+            Formatted error message
+        """
+        return f"❌ {error}"
+
+    def format_info(self, info: str) -> str:
+        """
+        Format an informational message.
+
+        Returns:
+            Formatted info message
+        """
+        return f"ℹ️ {info}"
+
+    def format_warning(self, warning: str) -> str:
+        """
+        Format a warning message.
+
+        Returns:
+            Formatted warning message
+        """
+        return f"⚠️ {warning}"