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

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

claude_mpm/services/ticket_services/search_service.py

@@ -0,0 +1,324 @@
+"""
+Search service for tickets.
+
+WHY: Extracts search logic into a dedicated service for better
+organization and testability of search functionality.
+
+DESIGN DECISIONS:
+- Supports text-based search across multiple fields
+- Handles filtering by type and status
+- Provides relevance ranking for search results
+- Abstracts search backend (can switch between different implementations)
+"""
+
+from typing import Any, Dict, List, Optional
+
+from ...core.logger import get_logger
+
+
+class TicketSearchService:
+    """Service for searching tickets."""
+
+    def __init__(self, ticket_manager=None):
+        """
+        Initialize the search service.
+
+        Args:
+            ticket_manager: Optional ticket manager instance for testing
+        """
+        self.logger = get_logger("services.ticket_search")
+        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 search_tickets(
+        self,
+        query: str,
+        type_filter: str = "all",
+        status_filter: str = "all",
+        limit: int = 10,
+        search_fields: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        Search tickets by query string.
+
+        Args:
+            query: Search query
+            type_filter: Filter by ticket type
+            status_filter: Filter by status
+            limit: Maximum results to return
+            search_fields: Fields to search in (default: title, description, tags)
+
+        Returns:
+            List of matching tickets
+        """
+        if not search_fields:
+            search_fields = ["title", "description", "tags"]
+
+        try:
+            # Get all available tickets
+            all_tickets = self.ticket_manager.list_recent_tickets(limit=100)
+
+            # Search and filter
+            matched_tickets = []
+            query_lower = query.lower()
+
+            for ticket in all_tickets:
+                # Check if query matches any search field
+                if self._matches_query(ticket, query_lower, search_fields):
+                    # Apply type filter
+                    if not self._passes_type_filter(ticket, type_filter):
+                        continue
+
+                    # Apply status filter
+                    if not self._passes_status_filter(ticket, status_filter):
+                        continue
+
+                    matched_tickets.append(ticket)
+
+                    if len(matched_tickets) >= limit:
+                        break
+
+            # Sort by relevance
+            return self._sort_by_relevance(matched_tickets, query_lower)
+
+        except Exception as e:
+            self.logger.error(f"Error searching tickets: {e}")
+            return []
+
+    def _matches_query(
+        self, ticket: Dict[str, Any], query: str, search_fields: List[str]
+    ) -> bool:
+        """
+        Check if ticket matches the search query.
+
+        Returns:
+            True if ticket matches query in any search field
+        """
+        for field in search_fields:
+            if field == "title" and query in ticket.get("title", "").lower():
+                return True
+
+            if (
+                field == "description"
+                and query in ticket.get("description", "").lower()
+            ):
+                return True
+
+            if field == "tags":
+                tags = ticket.get("tags", [])
+                if any(query in tag.lower() for tag in tags):
+                    return True
+
+            if field == "id" and query in ticket.get("id", "").lower():
+                return True
+
+            # Search in metadata fields
+            if field == "metadata":
+                metadata = ticket.get("metadata", {})
+                for value in metadata.values():
+                    if isinstance(value, str) and query in value.lower():
+                        return True
+
+        return False
+
+    def _passes_type_filter(self, ticket: Dict[str, Any], type_filter: str) -> bool:
+        """
+        Check if ticket passes type filter.
+
+        Returns:
+            True if ticket matches type filter
+        """
+        if type_filter == "all":
+            return True
+
+        ticket_type = ticket.get("metadata", {}).get("ticket_type", "unknown")
+        return ticket_type == type_filter
+
+    def _passes_status_filter(self, ticket: Dict[str, Any], status_filter: str) -> bool:
+        """
+        Check if ticket passes status filter.
+
+        Returns:
+            True if ticket matches status filter
+        """
+        if status_filter == "all":
+            return True
+
+        return ticket.get("status") == status_filter
+
+    def _sort_by_relevance(
+        self, tickets: List[Dict[str, Any]], query: str
+    ) -> List[Dict[str, Any]]:
+        """
+        Sort tickets by relevance to search query.
+
+        Returns:
+            Sorted list of tickets (most relevant first)
+        """
+
+        def relevance_score(ticket):
+            score = 0
+
+            # Title matches are most relevant
+            if query in ticket.get("title", "").lower():
+                score += 10
+
+            # ID matches are very relevant
+            if query in ticket.get("id", "").lower():
+                score += 8
+
+            # Tag matches are moderately relevant
+            tags = ticket.get("tags", [])
+            for tag in tags:
+                if query in tag.lower():
+                    score += 5
+
+            # Description matches are less relevant
+            if query in ticket.get("description", "").lower():
+                score += 2
+
+            # Boost recent tickets slightly
+            if ticket.get("status") in ["open", "in_progress"]:
+                score += 1
+
+            return score
+
+        return sorted(tickets, key=relevance_score, reverse=True)
+
+    def find_similar_tickets(
+        self, ticket_id: str, limit: int = 5
+    ) -> List[Dict[str, Any]]:
+        """
+        Find tickets similar to a given ticket.
+
+        Args:
+            ticket_id: ID of the reference ticket
+            limit: Maximum similar tickets to return
+
+        Returns:
+            List of similar tickets
+        """
+        try:
+            # Get the reference ticket
+            reference = self.ticket_manager.get_ticket(ticket_id)
+            if not reference:
+                return []
+
+            # Extract keywords from title and tags
+            keywords = self._extract_keywords(reference)
+
+            # Search for similar tickets
+            similar = []
+            all_tickets = self.ticket_manager.list_recent_tickets(limit=50)
+
+            for ticket in all_tickets:
+                if ticket["id"] == ticket_id:
+                    continue  # Skip the reference ticket
+
+                # Calculate similarity score
+                score = self._calculate_similarity(reference, ticket, keywords)
+
+                if score > 0:
+                    similar.append((score, ticket))
+
+            # Sort by similarity and return top results
+            similar.sort(key=lambda x: x[0], reverse=True)
+            return [ticket for _, ticket in similar[:limit]]
+
+        except Exception as e:
+            self.logger.error(f"Error finding similar tickets: {e}")
+            return []
+
+    def _extract_keywords(self, ticket: Dict[str, Any]) -> List[str]:
+        """
+        Extract keywords from a ticket for similarity matching.
+
+        Returns:
+            List of keywords
+        """
+        keywords = []
+
+        # Extract words from title
+        title = ticket.get("title", "")
+        keywords.extend(title.lower().split())
+
+        # Add tags as keywords
+        keywords.extend([tag.lower() for tag in ticket.get("tags", [])])
+
+        # Extract key words from description (first 100 chars)
+        desc = ticket.get("description", "")[:100]
+        keywords.extend(desc.lower().split()[:10])
+
+        # Remove common words
+        common_words = {
+            "the",
+            "a",
+            "an",
+            "and",
+            "or",
+            "but",
+            "in",
+            "on",
+            "at",
+            "to",
+            "for",
+        }
+        keywords = [w for w in keywords if w not in common_words and len(w) > 2]
+
+        return list(set(keywords))  # Remove duplicates
+
+    def _calculate_similarity(
+        self, ref_ticket: Dict[str, Any], ticket: Dict[str, Any], keywords: List[str]
+    ) -> float:
+        """
+        Calculate similarity score between two tickets.
+
+        Returns:
+            Similarity score (0-100)
+        """
+        score = 0.0
+
+        # Same type bonus
+        ref_type = ref_ticket.get("metadata", {}).get("ticket_type")
+        ticket_type = ticket.get("metadata", {}).get("ticket_type")
+        if ref_type and ticket_type and ref_type == ticket_type:
+            score += 10
+
+        # Same status bonus
+        if ref_ticket.get("status") == ticket.get("status"):
+            score += 5
+
+        # Same priority bonus
+        if ref_ticket.get("priority") == ticket.get("priority"):
+            score += 3
+
+        # Keyword matches
+        ticket_text = (
+            ticket.get("title", "").lower()
+            + " "
+            + ticket.get("description", "").lower()
+            + " "
+            + " ".join(ticket.get("tags", []))
+        ).lower()
+
+        for keyword in keywords:
+            if keyword in ticket_text:
+                score += 2
+
+        # Common tags
+        ref_tags = set(ref_ticket.get("tags", []))
+        ticket_tags = set(ticket.get("tags", []))
+        common_tags = ref_tags.intersection(ticket_tags)
+        score += len(common_tags) * 5
+
+        return min(score, 100)  # Cap at 100