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

mcp_ticketer/cli/ticket_commands.py

@@ -213,11 +213,25 @@ def create(
         "--epic",
         help="Parent epic/project ID (synonym for --project)",
     ),
+    wait: bool = typer.Option(
+        False,
+        "--wait",
+        "-w",
+        help="Wait for operation to complete (synchronous mode, returns actual ticket ID)",
+    ),
+    timeout: float = typer.Option(
+        30.0,
+        "--timeout",
+        help="Timeout in seconds for --wait mode (default: 30)",
+    ),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
 ) -> None:
     """Create a new ticket with comprehensive health checks."""
+    from .utils import format_error_json, format_json_response, serialize_task
+
     # IMMEDIATE HEALTH CHECK - Critical for reliability
     health_monitor = QueueHealthMonitor()
     health = health_monitor.check_health()
@@ -336,22 +350,35 @@ def create(
 
             result = asyncio.run(adapter_instance.create(task))
 
-            console.print(f"[green]✓[/green] Ticket created successfully: {result.id}")
-            console.print(f"  Title: {result.title}")
-            console.print(f"  Priority: {result.priority}")
-            console.print(f"  State: {result.state}")
-            # Get URL from metadata if available
-            if (
-                result.metadata
-                and "linear" in result.metadata
-                and "url" in result.metadata["linear"]
-            ):
-                console.print(f"  URL: {result.metadata['linear']['url']}")
+            if output_json:
+                data = serialize_task(result)
+                console.print(
+                    format_json_response(
+                        "success", data, message="Ticket created successfully"
+                    )
+                )
+            else:
+                console.print(
+                    f"[green]✓[/green] Ticket created successfully: {result.id}"
+                )
+                console.print(f"  Title: {result.title}")
+                console.print(f"  Priority: {result.priority}")
+                console.print(f"  State: {result.state}")
+                # Get URL from metadata if available
+                if (
+                    result.metadata
+                    and "linear" in result.metadata
+                    and "url" in result.metadata["linear"]
+                ):
+                    console.print(f"  URL: {result.metadata['linear']['url']}")
 
             return result.id
 
         except Exception as e:
-            console.print(f"[red]❌[/red] Failed to create ticket: {e}")
+            if output_json:
+                console.print(format_error_json(e))
+            else:
+                console.print(f"[red]❌[/red] Failed to create ticket: {e}")
             raise
 
     # Use queue for other adapters
@@ -369,51 +396,113 @@ def create(
         queue_id, adapter_name, "create", title, task_data
     )
 
-    console.print(f"[green]✓[/green] Queued ticket creation: {queue_id}")
-    console.print(f"  Title: {title}")
-    console.print(f"  Priority: {priority}")
-    console.print(f"  Adapter: {adapter_name}")
-    console.print(
-        "[dim]Use 'mcp-ticketer ticket check {queue_id}' to check progress[/dim]"
-    )
-
-    # Start worker if needed with immediate feedback
+    # Start worker if needed - must happen before polling
     manager = WorkerManager()
     worker_started = manager.start_if_needed()
 
     if worker_started:
-        console.print("[dim]Worker started to process request[/dim]")
-
-        # Give immediate feedback on processing
-        import time
-
-        time.sleep(1)  # Brief pause to let worker start
+        if not output_json:
+            console.print("[dim]Worker started to process request[/dim]")
 
-        # Check if item is being processed
-        item = queue.get_item(queue_id)
-        if item and item.status == QueueStatus.PROCESSING:
-            console.print("[green]✓ Item is being processed by worker[/green]")
-        elif item and item.status == QueueStatus.PENDING:
-            console.print("[yellow]⏳ Item is queued for processing[/yellow]")
-        else:
+    # SYNCHRONOUS MODE: Poll until completion if --wait flag is set
+    if wait:
+        if not output_json:
             console.print(
-                "[red]⚠️  Item status unclear - check with 'mcp-ticketer ticket check {queue_id}'[/red]"
+                f"[yellow]⏳[/yellow] Waiting for operation to complete (timeout: {timeout}s)..."
             )
+
+        try:
+            # Poll the queue until operation completes
+            completed_item = queue.poll_until_complete(queue_id, timeout=timeout)
+
+            # Extract result data
+            result = completed_item.result
+
+            # Extract ticket ID from result
+            ticket_id = result.get("id") if result else queue_id
+
+            if output_json:
+                # Return actual ticket data in JSON format
+                data = result if result else {"queue_id": queue_id}
+                console.print(
+                    format_json_response(
+                        "success", data, message="Ticket created successfully"
+                    )
+                )
+            else:
+                # Display ticket creation success with actual ID
+                console.print(
+                    f"[green]✓[/green] Ticket created successfully: {ticket_id}"
+                )
+                console.print(f"  Title: {title}")
+                console.print(f"  Priority: {priority}")
+
+                # Display additional metadata if available
+                if result:
+                    if "url" in result:
+                        console.print(f"  URL: {result['url']}")
+                    if "state" in result:
+                        console.print(f"  State: {result['state']}")
+
+            return ticket_id
+
+        except TimeoutError as e:
+            if output_json:
+                console.print(format_error_json(str(e), queue_id=queue_id))
+            else:
+                console.print(f"[red]❌[/red] Operation timed out after {timeout}s")
+                console.print(f"  Queue ID: {queue_id}")
+                console.print(
+                    f"  Use 'mcp-ticketer ticket check {queue_id}' to check status later"
+                )
+            raise typer.Exit(1) from None
+
+        except RuntimeError as e:
+            if output_json:
+                console.print(format_error_json(str(e), queue_id=queue_id))
+            else:
+                console.print(f"[red]❌[/red] Operation failed: {e}")
+                console.print(f"  Queue ID: {queue_id}")
+            raise typer.Exit(1) from None
+
+    # ASYNCHRONOUS MODE (default): Return queue ID immediately
     else:
-        # Worker didn't start - this is a problem
-        pending_count = queue.get_pending_count()
-        if pending_count > 1:  # More than just this item
-            console.print(
-                f"[red]❌ Worker failed to start with {pending_count} pending items![/red]"
-            )
+        if output_json:
+            data = {
+                "queue_id": queue_id,
+                "title": title,
+                "priority": priority.value if hasattr(priority, "value") else priority,
+                "adapter": adapter_name,
+                "status": "queued",
+            }
             console.print(
-                "[red]This is a critical issue. Try 'mcp-ticketer queue worker start' manually.[/red]"
+                format_json_response("success", data, message="Ticket creation queued")
             )
         else:
+            console.print(f"[green]✓[/green] Queued ticket creation: {queue_id}")
+            console.print(f"  Title: {title}")
+            console.print(f"  Priority: {priority}")
+            console.print(f"  Adapter: {adapter_name}")
             console.print(
-                "[yellow]Worker not started (no other pending items)[/yellow]"
+                "[dim]Use 'mcp-ticketer ticket check {queue_id}' to check progress[/dim]"
             )
 
+            # Give immediate feedback on processing
+            import time
+
+            time.sleep(1)  # Brief pause to let worker start
+
+            # Check if item is being processed
+            item = queue.get_item(queue_id)
+            if item and item.status == QueueStatus.PROCESSING:
+                console.print("[green]✓ Item is being processed by worker[/green]")
+            elif item and item.status == QueueStatus.PENDING:
+                console.print("[yellow]⏳ Item is queued for processing[/yellow]")
+            else:
+                console.print(
+                    "[red]⚠️  Item status unclear - check with 'mcp-ticketer ticket check {queue_id}'[/red]"
+                )
+
 
 @app.command("list")
 def list_tickets(
@@ -424,11 +513,13 @@ def list_tickets(
         None, "--priority", "-p", help="Filter by priority"
     ),
     limit: int = typer.Option(10, "--limit", "-l", help="Maximum number of tickets"),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
 ) -> None:
     """List tickets with optional filters."""
+    from .utils import format_json_response, serialize_task
 
     async def _list() -> list[Any]:
         adapter_instance = get_adapter(
@@ -444,10 +535,29 @@ def list_tickets(
     tickets = asyncio.run(_list())
 
     if not tickets:
-        console.print("[yellow]No tickets found[/yellow]")
+        if output_json:
+            console.print(
+                format_json_response(
+                    "success", {"tickets": [], "count": 0, "has_more": False}
+                )
+            )
+        else:
+            console.print("[yellow]No tickets found[/yellow]")
         return
 
-    # Create table
+    # JSON output
+    if output_json:
+        tickets_data = [serialize_task(t) for t in tickets]
+        data = {
+            "tickets": tickets_data,
+            "count": len(tickets_data),
+            "has_more": len(tickets)
+            >= limit,  # Heuristic: if we got exactly limit, there might be more
+        }
+        console.print(format_json_response("success", data))
+        return
+
+    # Original table output
     table = Table(title="Tickets")
     table.add_column("ID", style="cyan", no_wrap=True)
     table.add_column("Title", style="white")
@@ -476,6 +586,7 @@ def show(
     no_comments: bool = typer.Option(
         False, "--no-comments", help="Hide comments (shown by default)"
     ),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
@@ -486,7 +597,9 @@ def show(
     a holistic view of the ticket's history and context.
 
     Use --no-comments to display only ticket metadata without comments.
+    Use --json to output in machine-readable JSON format.
     """
+    from .utils import format_error_json, format_json_response, serialize_task
 
     async def _show() -> tuple[Any, Any, Any]:
         adapter_instance = get_adapter(
@@ -513,11 +626,53 @@ def show(
 
         return ticket, ticket_comments, attachments
 
-    ticket, ticket_comments, attachments = asyncio.run(_show())
+    try:
+        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
+        if not ticket:
+            if output_json:
+                console.print(
+                    format_error_json(
+                        f"Ticket not found: {ticket_id}", ticket_id=ticket_id
+                    )
+                )
+            else:
+                console.print(f"[red]✗[/red] Ticket not found: {ticket_id}")
+            raise typer.Exit(1) from None
+
+        # JSON output
+        if output_json:
+            data = serialize_task(ticket)
+
+            # Add comments if available
+            if ticket_comments:
+                data["comments"] = [
+                    {
+                        "id": getattr(c, "id", None),
+                        "text": c.content,
+                        "author": c.author,
+                        "created_at": (
+                            c.created_at.isoformat()
+                            if hasattr(c.created_at, "isoformat")
+                            else str(c.created_at)
+                        ),
+                    }
+                    for c in ticket_comments
+                ]
+
+            # Add attachments if available
+            if attachments:
+                data["attachments"] = attachments
+
+            console.print(format_json_response("success", data))
+            return
+
+        # Original formatted output continues below...
+    except Exception as e:
+        if output_json:
+            console.print(format_error_json(e, ticket_id=ticket_id))
+            raise typer.Exit(1) from None
+        raise
 
     # Display ticket header with metadata
     console.print(f"\n[bold cyan]┌─ Ticket: {ticket.id}[/bold cyan]")
@@ -595,11 +750,13 @@ def show(
 def comment(
     ticket_id: str = typer.Argument(..., help="Ticket ID"),
     content: str = typer.Argument(..., help="Comment content"),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
 ) -> None:
     """Add a comment to a ticket."""
+    from .utils import format_error_json, format_json_response
 
     async def _comment() -> Comment:
         adapter_instance = get_adapter(
@@ -618,12 +775,34 @@ def comment(
 
     try:
         result = asyncio.run(_comment())
-        console.print("[green]✓[/green] Comment added successfully")
-        if result.id:
-            console.print(f"Comment ID: {result.id}")
-        console.print(f"Content: {content}")
+
+        if output_json:
+            data = {
+                "id": result.id,
+                "ticket_id": ticket_id,
+                "text": content,
+                "author": result.author,
+                "created_at": (
+                    result.created_at.isoformat()
+                    if hasattr(result.created_at, "isoformat")
+                    else str(result.created_at)
+                ),
+            }
+            console.print(
+                format_json_response(
+                    "success", data, message="Comment added successfully"
+                )
+            )
+        else:
+            console.print("[green]✓[/green] Comment added successfully")
+            if result.id:
+                console.print(f"Comment ID: {result.id}")
+            console.print(f"Content: {content}")
     except Exception as e:
-        console.print(f"[red]✗[/red] Failed to add comment: {e}")
+        if output_json:
+            console.print(format_error_json(e, ticket_id=ticket_id))
+        else:
+            console.print(f"[red]✗[/red] Failed to add comment: {e}")
         raise typer.Exit(1) from None
 
 
@@ -807,11 +986,25 @@ def update(
         None, "--priority", "-p", help="New priority"
     ),
     assignee: str | None = typer.Option(None, "--assignee", "-a", help="New assignee"),
+    wait: bool = typer.Option(
+        False,
+        "--wait",
+        "-w",
+        help="Wait for operation to complete (synchronous mode)",
+    ),
+    timeout: float = typer.Option(
+        30.0,
+        "--timeout",
+        help="Timeout in seconds for --wait mode (default: 30)",
+    ),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
 ) -> None:
     """Update ticket fields."""
+    from .utils import format_json_response
+
     updates = {}
     if title:
         updates["title"] = title
@@ -825,7 +1018,16 @@ def update(
         updates["assignee"] = assignee
 
     if not updates:
-        console.print("[yellow]No updates specified[/yellow]")
+        if output_json:
+            console.print(
+                format_json_response(
+                    "error",
+                    {"error": "No updates specified"},
+                    message="No updates specified",
+                )
+            )
+        else:
+            console.print("[yellow]No updates specified[/yellow]")
         raise typer.Exit(1) from None
 
     # Get the adapter name
@@ -846,18 +1048,77 @@ def update(
         project_dir=str(Path.cwd()),  # Explicitly pass current project directory
     )
 
-    console.print(f"[green]✓[/green] Queued ticket update: {queue_id}")
-    for key, value in updates.items():
-        if key != "ticket_id":
-            console.print(f"  {key}: {value}")
-    console.print(
-        "[dim]Use 'mcp-ticketer ticket check {queue_id}' to check progress[/dim]"
-    )
-
     # Start worker if needed
     manager = WorkerManager()
     if manager.start_if_needed():
-        console.print("[dim]Worker started to process request[/dim]")
+        if not output_json:
+            console.print("[dim]Worker started to process request[/dim]")
+
+    # SYNCHRONOUS MODE: Poll until completion if --wait flag is set
+    if wait:
+        from .utils import format_error_json
+
+        if not output_json:
+            console.print(
+                f"[yellow]⏳[/yellow] Waiting for update to complete (timeout: {timeout}s)..."
+            )
+
+        try:
+            # Poll the queue until operation completes
+            completed_item = queue.poll_until_complete(queue_id, timeout=timeout)
+            result = completed_item.result
+
+            if output_json:
+                data = result if result else {"queue_id": queue_id, "id": ticket_id}
+                console.print(
+                    format_json_response(
+                        "success", data, message="Ticket updated successfully"
+                    )
+                )
+            else:
+                console.print(
+                    f"[green]✓[/green] Ticket updated successfully: {ticket_id}"
+                )
+                for key, value in updates.items():
+                    if key != "ticket_id":
+                        console.print(f"  {key}: {value}")
+
+        except TimeoutError as e:
+            if output_json:
+                console.print(format_error_json(str(e), queue_id=queue_id))
+            else:
+                console.print(f"[red]❌[/red] Operation timed out after {timeout}s")
+                console.print(f"  Queue ID: {queue_id}")
+            raise typer.Exit(1) from None
+
+        except RuntimeError as e:
+            if output_json:
+                console.print(format_error_json(str(e), queue_id=queue_id))
+            else:
+                console.print(f"[red]❌[/red] Operation failed: {e}")
+            raise typer.Exit(1) from None
+
+    # ASYNCHRONOUS MODE (default)
+    else:
+        if output_json:
+            updated_fields = [k for k in updates.keys() if k != "ticket_id"]
+            data = {
+                "id": ticket_id,
+                "queue_id": queue_id,
+                "updated_fields": updated_fields,
+                **{k: v for k, v in updates.items() if k != "ticket_id"},
+            }
+            console.print(
+                format_json_response("success", data, message="Ticket update queued")
+            )
+        else:
+            console.print(f"[green]✓[/green] Queued ticket update: {queue_id}")
+            for key, value in updates.items():
+                if key != "ticket_id":
+                    console.print(f"  {key}: {value}")
+            console.print(
+                "[dim]Use 'mcp-ticketer ticket check {queue_id}' to check progress[/dim]"
+            )
 
 
 @app.command()
@@ -869,6 +1130,18 @@ def transition(
     state: TicketState | None = typer.Option(
         None, "--state", "-s", help="Target state (recommended)"
     ),
+    wait: bool = typer.Option(
+        False,
+        "--wait",
+        "-w",
+        help="Wait for operation to complete (synchronous mode)",
+    ),
+    timeout: float = typer.Option(
+        30.0,
+        "--timeout",
+        help="Timeout in seconds for --wait mode (default: 30)",
+    ),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
@@ -884,16 +1157,25 @@ def transition(
         mcp-ticketer ticket transition BTA-215 done
 
     """
+    from .utils import format_json_response
+
     # Determine which state to use (prefer flag over positional)
     target_state = state if state is not None else state_positional
 
     if target_state is None:
-        console.print("[red]Error: State is required[/red]")
-        console.print(
-            "Use either:\n"
-            "  - Flag syntax (recommended): mcp-ticketer ticket transition TICKET-ID --state STATE\n"
-            "  - Positional syntax: mcp-ticketer ticket transition TICKET-ID STATE"
-        )
+        if output_json:
+            console.print(
+                format_json_response(
+                    "error", {"error": "State is required"}, message="State is required"
+                )
+            )
+        else:
+            console.print("[red]Error: State is required[/red]")
+            console.print(
+                "Use either:\n"
+                "  - Flag syntax (recommended): mcp-ticketer ticket transition TICKET-ID --state STATE\n"
+                "  - Positional syntax: mcp-ticketer ticket transition TICKET-ID STATE"
+            )
         raise typer.Exit(1) from None
 
     # Get the adapter name
@@ -904,28 +1186,92 @@ def transition(
 
     # Add to queue with explicit project directory
     queue = Queue()
+    state_value = target_state.value if hasattr(target_state, "value") else target_state
     queue_id = queue.add(
         ticket_data={
             "ticket_id": ticket_id,
-            "state": (
-                target_state.value if hasattr(target_state, "value") else target_state
-            ),
+            "state": state_value,
         },
         adapter=adapter_name,
         operation="transition",
         project_dir=str(Path.cwd()),  # Explicitly pass current project directory
     )
 
-    console.print(f"[green]✓[/green] Queued state transition: {queue_id}")
-    console.print(f"  Ticket: {ticket_id} → {target_state}")
-    console.print(
-        "[dim]Use 'mcp-ticketer ticket check {queue_id}' to check progress[/dim]"
-    )
-
     # Start worker if needed
     manager = WorkerManager()
     if manager.start_if_needed():
-        console.print("[dim]Worker started to process request[/dim]")
+        if not output_json:
+            console.print("[dim]Worker started to process request[/dim]")
+
+    # SYNCHRONOUS MODE: Poll until completion if --wait flag is set
+    if wait:
+        from .utils import format_error_json
+
+        if not output_json:
+            console.print(
+                f"[yellow]⏳[/yellow] Waiting for transition to complete (timeout: {timeout}s)..."
+            )
+
+        try:
+            # Poll the queue until operation completes
+            completed_item = queue.poll_until_complete(queue_id, timeout=timeout)
+            result = completed_item.result
+
+            if output_json:
+                data = (
+                    result
+                    if result
+                    else {
+                        "id": ticket_id,
+                        "new_state": state_value,
+                        "matched_state": state_value,
+                        "confidence": 1.0,
+                    }
+                )
+                console.print(
+                    format_json_response(
+                        "success", data, message="State transition completed"
+                    )
+                )
+            else:
+                console.print(
+                    f"[green]✓[/green] State transition completed: {ticket_id} → {target_state}"
+                )
+
+        except TimeoutError as e:
+            if output_json:
+                console.print(format_error_json(str(e), queue_id=queue_id))
+            else:
+                console.print(f"[red]❌[/red] Operation timed out after {timeout}s")
+                console.print(f"  Queue ID: {queue_id}")
+            raise typer.Exit(1) from None
+
+        except RuntimeError as e:
+            if output_json:
+                console.print(format_error_json(str(e), queue_id=queue_id))
+            else:
+                console.print(f"[red]❌[/red] Operation failed: {e}")
+            raise typer.Exit(1) from None
+
+    # ASYNCHRONOUS MODE (default)
+    else:
+        if output_json:
+            data = {
+                "id": ticket_id,
+                "queue_id": queue_id,
+                "new_state": state_value,
+                "matched_state": state_value,
+                "confidence": 1.0,
+            }
+            console.print(
+                format_json_response("success", data, message="State transition queued")
+            )
+        else:
+            console.print(f"[green]✓[/green] Queued state transition: {queue_id}")
+            console.print(f"  Ticket: {ticket_id} → {target_state}")
+            console.print(
+                "[dim]Use 'mcp-ticketer ticket check {queue_id}' to check progress[/dim]"
+            )
 
 
 @app.command()
@@ -935,11 +1281,13 @@ def search(
     priority: Priority | None = typer.Option(None, "--priority", "-p"),
     assignee: str | None = typer.Option(None, "--assignee", "-a"),
     limit: int = typer.Option(10, "--limit", "-l"),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON"),
     adapter: AdapterType | None = typer.Option(
         None, "--adapter", help="Override default adapter"
     ),
 ) -> None:
     """Search tickets with advanced query."""
+    from .utils import format_json_response, serialize_task
 
     async def _search() -> list[Any]:
         adapter_instance = get_adapter(
@@ -957,7 +1305,21 @@ def search(
     tickets = asyncio.run(_search())
 
     if not tickets:
-        console.print("[yellow]No tickets found matching query[/yellow]")
+        if output_json:
+            console.print(
+                format_json_response(
+                    "success", {"tickets": [], "query": query, "count": 0}
+                )
+            )
+        else:
+            console.print("[yellow]No tickets found matching query[/yellow]")
+        return
+
+    # JSON output
+    if output_json:
+        tickets_data = [serialize_task(t) for t in tickets]
+        data = {"tickets": tickets_data, "query": query, "count": len(tickets_data)}
+        console.print(format_json_response("success", data))
         return
 
     # Display results