mcp-ticketer 0.12.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

mcp_ticketer/cli/ticket_commands.py

@@ -473,51 +473,122 @@ def list_tickets(
 @app.command()
 def show(
     ticket_id: str = typer.Argument(..., help="Ticket ID"),
-    comments: bool = typer.Option(False, "--comments", "-c", help="Show comments"),
+    no_comments: bool = typer.Option(
+        False, "--no-comments", help="Hide comments (shown by default)"
+    ),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
 ) -> None:
-    """Show detailed ticket information."""
+    """Show detailed ticket information with full context.
+
+    By default, displays ticket details along with all comments to provide
+    a holistic view of the ticket's history and context.
 
-    async def _show() -> tuple[Any, Any]:
+    Use --no-comments to display only ticket metadata without comments.
+    """
+
+    async def _show() -> tuple[Any, Any, Any]:
         adapter_instance = get_adapter(
             override_adapter=adapter.value if adapter else None
         )
         ticket = await adapter_instance.read(ticket_id)
         ticket_comments = None
-        if comments and ticket:
-            ticket_comments = await adapter_instance.get_comments(ticket_id)
-        return ticket, ticket_comments
+        attachments = None
+
+        # Fetch comments by default (unless explicitly disabled)
+        if not no_comments and ticket:
+            try:
+                ticket_comments = await adapter_instance.get_comments(ticket_id)
+            except (NotImplementedError, AttributeError):
+                # Adapter doesn't support comments
+                pass
+
+        # Try to fetch attachments if available
+        if ticket and hasattr(adapter_instance, "list_attachments"):
+            try:
+                attachments = await adapter_instance.list_attachments(ticket_id)
+            except (NotImplementedError, AttributeError):
+                pass
+
+        return ticket, ticket_comments, attachments
 
-    ticket, ticket_comments = asyncio.run(_show())
+    ticket, ticket_comments, attachments = asyncio.run(_show())
 
     if not ticket:
         console.print(f"[red]✗[/red] Ticket not found: {ticket_id}")
         raise typer.Exit(1) from None
 
-    # Display ticket details
-    console.print(f"\n[bold]Ticket: {ticket.id}[/bold]")
-    console.print(f"Title: {ticket.title}")
-    console.print(f"State: [green]{ticket.state}[/green]")
-    console.print(f"Priority: [yellow]{ticket.priority}[/yellow]")
+    # Display ticket header with metadata
+    console.print(f"\n[bold cyan]┌─ Ticket: {ticket.id}[/bold cyan]")
+    console.print(f"[bold]│ {ticket.title}[/bold]")
+    console.print("└" + "─" * 60)
 
-    if ticket.description:
-        console.print("\n[dim]Description:[/dim]")
-        console.print(ticket.description)
-
-    if ticket.tags:
-        console.print(f"\nTags: {', '.join(ticket.tags)}")
+    # Display metadata in organized sections
+    console.print("\n[bold]Status[/bold]")
+    console.print(f"  State: [green]{ticket.state}[/green]")
+    console.print(f"  Priority: [yellow]{ticket.priority}[/yellow]")
 
     if ticket.assignee:
-        console.print(f"Assignee: {ticket.assignee}")
+        console.print(f"  Assignee: {ticket.assignee}")
 
-    # Display comments if requested
+    # Display timestamps if available
+    if ticket.created_at or ticket.updated_at:
+        console.print("\n[bold]Timeline[/bold]")
+        if ticket.created_at:
+            console.print(f"  Created: {ticket.created_at}")
+        if ticket.updated_at:
+            console.print(f"  Updated: {ticket.updated_at}")
+
+    # Display tags
+    if ticket.tags:
+        console.print("\n[bold]Tags[/bold]")
+        console.print(f"  {', '.join(ticket.tags)}")
+
+    # Display description
+    if ticket.description:
+        console.print("\n[bold]Description[/bold]")
+        console.print(f"  {ticket.description}")
+
+    # Display parent/child relationships
+    parent_info = []
+    if hasattr(ticket, "parent_epic") and ticket.parent_epic:
+        parent_info.append(f"Epic: {ticket.parent_epic}")
+    if hasattr(ticket, "parent_issue") and ticket.parent_issue:
+        parent_info.append(f"Parent Issue: {ticket.parent_issue}")
+
+    if parent_info:
+        console.print("\n[bold]Hierarchy[/bold]")
+        for info in parent_info:
+            console.print(f"  {info}")
+
+    # Display attachments if available
+    if attachments and len(attachments) > 0:
+        console.print(f"\n[bold]Attachments ({len(attachments)})[/bold]")
+        for att in attachments:
+            att_title = att.get("title", "Untitled")
+            att_url = att.get("url", "")
+            console.print(f"  📎 {att_title}")
+            if att_url:
+                console.print(f"     {att_url}")
+
+    # Display comments with enhanced formatting
     if ticket_comments:
-        console.print(f"\n[bold]Comments ({len(ticket_comments)}):[/bold]")
-        for comment in ticket_comments:
-            console.print(f"\n[dim]{comment.created_at} - {comment.author}:[/dim]")
-            console.print(comment.content)
+        console.print(f"\n[bold]Activity & Comments ({len(ticket_comments)})[/bold]")
+        for i, comment in enumerate(ticket_comments, 1):
+            # Format timestamp
+            timestamp = comment.created_at if comment.created_at else "Unknown time"
+            author = comment.author if comment.author else "Unknown author"
+
+            console.print(f"\n[dim]  {i}. {timestamp}[/dim]")
+            console.print(f"  [cyan]@{author}[/cyan]")
+            console.print(f"  {comment.content}")
+
+    # Footer with hint
+    if no_comments:
+        console.print(
+            "\n[dim]💡 Tip: Remove --no-comments to see activity and comments[/dim]"
+        )
 
 
 @app.command()
@@ -556,6 +627,175 @@ def comment(
         raise typer.Exit(1) from None
 
 
+@app.command()
+def attach(
+    ticket_id: str = typer.Argument(..., help="Ticket ID or URL"),
+    file_path: Path = typer.Argument(..., help="Path to file to attach", exists=True),
+    description: str | None = typer.Option(
+        None, "--description", "-d", help="Attachment description or comment"
+    ),
+    adapter: AdapterType | None = typer.Option(
+        None, "--adapter", help="Override default adapter"
+    ),
+) -> None:
+    """Attach a file to a ticket.
+
+    Examples:
+        mcp-ticketer ticket attach 1M-157 docs/analysis.md
+        mcp-ticketer ticket attach PROJ-123 screenshot.png -d "Error screenshot"
+        mcp-ticketer ticket attach https://linear.app/.../issue/ABC-123 diagram.pdf
+    """
+
+    async def _attach() -> dict[str, Any]:
+        import mimetypes
+
+        adapter_instance = get_adapter(
+            override_adapter=adapter.value if adapter else None
+        )
+
+        # Detect MIME type
+        mime_type, _ = mimetypes.guess_type(str(file_path))
+        if not mime_type:
+            mime_type = "application/octet-stream"
+
+        # Method 1: Try Linear-specific upload (if available)
+        if hasattr(adapter_instance, "upload_file") and hasattr(
+            adapter_instance, "attach_file_to_issue"
+        ):
+            try:
+                # Upload file to Linear's S3
+                file_url = await adapter_instance.upload_file(
+                    file_path=str(file_path), mime_type=mime_type
+                )
+
+                # Attach to issue
+                attachment = await adapter_instance.attach_file_to_issue(
+                    issue_id=ticket_id,
+                    file_url=file_url,
+                    title=file_path.name,
+                    subtitle=description,
+                )
+
+                return {
+                    "status": "completed",
+                    "attachment": attachment,
+                    "file_url": file_url,
+                    "method": "linear_native_upload",
+                }
+            except Exception:
+                # If Linear upload fails, fall through to next method
+                pass
+
+        # Method 2: Try generic add_attachment (if available)
+        if hasattr(adapter_instance, "add_attachment"):
+            try:
+                attachment = await adapter_instance.add_attachment(
+                    ticket_id=ticket_id,
+                    file_path=str(file_path),
+                    description=description or "",
+                )
+                return {
+                    "status": "completed",
+                    "attachment": attachment,
+                    "method": "adapter_native",
+                }
+            except NotImplementedError:
+                pass
+
+        # Method 3: Fallback - Add file reference as comment
+        from ..core.models import Comment
+
+        comment_content = f"📎 File reference: {file_path.name}"
+        if description:
+            comment_content += f"\n\n{description}"
+
+        comment_obj = Comment(
+            ticket_id=ticket_id,
+            content=comment_content,
+            author="cli-user",
+        )
+
+        comment = await adapter_instance.add_comment(comment_obj)
+        return {
+            "status": "completed",
+            "comment": comment,
+            "method": "comment_reference",
+            "note": "Adapter doesn't support attachments - added file reference as comment",
+        }
+
+    # Validate file before attempting upload
+    if not file_path.exists():
+        console.print(f"[red]✗[/red] File not found: {file_path}")
+        raise typer.Exit(1) from None
+
+    if not file_path.is_file():
+        console.print(f"[red]✗[/red] Path is not a file: {file_path}")
+        raise typer.Exit(1) from None
+
+    # Display file info
+    file_size = file_path.stat().st_size
+    size_mb = file_size / (1024 * 1024)
+    console.print(f"\n[dim]Attaching file to ticket {ticket_id}...[/dim]")
+    console.print(f"  File: {file_path.name} ({size_mb:.2f} MB)")
+
+    # Detect MIME type
+    import mimetypes
+
+    mime_type, _ = mimetypes.guess_type(str(file_path))
+    if mime_type:
+        console.print(f"  Type: {mime_type}")
+
+    try:
+        result = asyncio.run(_attach())
+
+        if result["status"] == "completed":
+            console.print(
+                f"\n[green]✓[/green] File attached successfully to {ticket_id}"
+            )
+
+            # Display attachment details based on method used
+            method = result.get("method", "unknown")
+
+            if method == "linear_native_upload":
+                console.print("  Method: Linear native upload")
+                if "file_url" in result:
+                    console.print(f"  URL: {result['file_url']}")
+                if "attachment" in result and isinstance(result["attachment"], dict):
+                    att = result["attachment"]
+                    if "id" in att:
+                        console.print(f"  ID: {att['id']}")
+                    if "title" in att:
+                        console.print(f"  Title: {att['title']}")
+
+            elif method == "adapter_native":
+                console.print("  Method: Adapter native")
+                if "attachment" in result:
+                    att = result["attachment"]
+                    if isinstance(att, dict):
+                        if "id" in att:
+                            console.print(f"  ID: {att['id']}")
+                        if "url" in att:
+                            console.print(f"  URL: {att['url']}")
+
+            elif method == "comment_reference":
+                console.print("  Method: Comment reference")
+                console.print(f"  [dim]{result.get('note', '')}[/dim]")
+                if "comment" in result:
+                    comment = result["comment"]
+                    if isinstance(comment, dict) and "id" in comment:
+                        console.print(f"  Comment ID: {comment['id']}")
+
+        else:
+            # Error case
+            error_msg = result.get("error", "Unknown error")
+            console.print(f"\n[red]✗[/red] Failed to attach file: {error_msg}")
+            raise typer.Exit(1) from None
+
+    except Exception as e:
+        console.print(f"\n[red]✗[/red] Failed to attach file: {e}")
+        raise typer.Exit(1) from None
+
+
 @app.command()
 def update(
     ticket_id: str = typer.Argument(..., help="Ticket ID"),

mcp_ticketer/core/__init__.py

@@ -2,20 +2,38 @@
 
 from .adapter import BaseAdapter
 from .instructions import (
-                           InstructionsError,
-                           InstructionsNotFoundError,
-                           InstructionsValidationError,
-                           TicketInstructionsManager,
-                           get_instructions,
+    InstructionsError,
+    InstructionsNotFoundError,
+    InstructionsValidationError,
+    TicketInstructionsManager,
+    get_instructions,
+)
+from .models import (
+    Attachment,
+    Comment,
+    Epic,
+    Priority,
+    ProjectUpdate,
+    ProjectUpdateHealth,
+    Task,
+    TicketState,
+    TicketType,
 )
-from .models import Attachment, Comment, Epic, Priority, Task, TicketState, TicketType
 from .registry import AdapterRegistry
+from .state_matcher import (
+    SemanticStateMatcher,
+    StateMatchResult,
+    ValidationResult,
+    get_state_matcher,
+)
 
 __all__ = [
     "Epic",
     "Task",
     "Comment",
     "Attachment",
+    "ProjectUpdate",
+    "ProjectUpdateHealth",
     "TicketState",
     "Priority",
     "TicketType",
@@ -26,4 +44,8 @@ __all__ = [
     "InstructionsNotFoundError",
     "InstructionsValidationError",
     "get_instructions",
+    "SemanticStateMatcher",
+    "StateMatchResult",
+    "ValidationResult",
+    "get_state_matcher",
 ]