mcp-ticketer 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

mcp_ticketer/__version__.py

@@ -1,6 +1,6 @@
 """Version information for mcp-ticketer package."""
 
-__version__ = "0.1.26"
+__version__ = "0.1.28"
 __version_info__ = tuple(int(part) for part in __version__.split("."))
 
 # Package metadata

mcp_ticketer/adapters/aitrackdown.py

@@ -235,6 +235,64 @@ class AITrackdownAdapter(BaseAdapter[Task]):
 
         return ticket
 
+    async def create_epic(self, title: str, description: str = None, **kwargs) -> Epic:
+        """Create a new epic.
+
+        Args:
+            title: Epic title
+            description: Epic description
+            **kwargs: Additional epic properties
+
+        Returns:
+            Created Epic instance
+        """
+        epic = Epic(
+            title=title,
+            description=description,
+            **kwargs
+        )
+        return await self.create(epic)
+
+    async def create_issue(self, title: str, parent_epic: str = None, description: str = None, **kwargs) -> Task:
+        """Create a new issue.
+
+        Args:
+            title: Issue title
+            parent_epic: Parent epic ID
+            description: Issue description
+            **kwargs: Additional issue properties
+
+        Returns:
+            Created Task instance (representing an issue)
+        """
+        task = Task(
+            title=title,
+            description=description,
+            parent_epic=parent_epic,
+            **kwargs
+        )
+        return await self.create(task)
+
+    async def create_task(self, title: str, parent_id: str, description: str = None, **kwargs) -> Task:
+        """Create a new task under an issue.
+
+        Args:
+            title: Task title
+            parent_id: Parent issue ID
+            description: Task description
+            **kwargs: Additional task properties
+
+        Returns:
+            Created Task instance
+        """
+        task = Task(
+            title=title,
+            description=description,
+            parent_issue=parent_id,
+            **kwargs
+        )
+        return await self.create(task)
+
     async def read(self, ticket_id: str) -> Optional[Union[Task, Epic]]:
         """Read a task by ID."""
         if self.tracker:

mcp_ticketer/adapters/hybrid.py

@@ -8,7 +8,7 @@ import builtins
 import json
 import logging
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
 from ..core.adapter import BaseAdapter
 from ..core.models import Comment, Epic, SearchQuery, Task, TicketState
@@ -153,7 +153,7 @@ class HybridAdapter(BaseAdapter):
 
         return f"hybrid-{uuid.uuid4().hex[:12]}"
 
-    async def create(self, ticket: Task | Epic) -> Task | Epic:
+    async def create(self, ticket: Union[Task, Epic]) -> Union[Task, Epic]:
         """Create ticket in all configured adapters.
 
         Args:
@@ -208,7 +208,7 @@ class HybridAdapter(BaseAdapter):
         return primary_ticket
 
     def _add_cross_references(
-        self, ticket: Task | Epic, results: list[tuple[str, Task | Epic]]
+        self, ticket: Union[Task, Epic], results: list[tuple[str, Union[Task, Epic]]]
     ) -> None:
         """Add cross-references to ticket description.
 
@@ -226,7 +226,7 @@ class HybridAdapter(BaseAdapter):
         else:
             ticket.description = cross_refs.strip()
 
-    async def read(self, ticket_id: str) -> Optional[Task | Epic]:
+    async def read(self, ticket_id: str) -> Optional[Union[Task, Epic]]:
         """Read ticket from primary adapter.
 
         Args:
@@ -255,7 +255,7 @@ class HybridAdapter(BaseAdapter):
 
     async def update(
         self, ticket_id: str, updates: dict[str, Any]
-    ) -> Optional[Task | Epic]:
+    ) -> Optional[Union[Task, Epic]]:
         """Update ticket across all adapters.
 
         Args:
@@ -360,7 +360,7 @@ class HybridAdapter(BaseAdapter):
 
     async def list(
         self, limit: int = 10, offset: int = 0, filters: Optional[dict[str, Any]] = None
-    ) -> list[Task | Epic]:
+    ) -> list[Union[Task, Epic]]:
         """List tickets from primary adapter.
 
         Args:
@@ -375,7 +375,7 @@ class HybridAdapter(BaseAdapter):
         primary = self.adapters[self.primary_adapter_name]
         return await primary.list(limit, offset, filters)
 
-    async def search(self, query: SearchQuery) -> builtins.list[Task | Epic]:
+    async def search(self, query: SearchQuery) -> builtins.list[Union[Task, Epic]]:
         """Search tickets in primary adapter.
 
         Args:
@@ -390,7 +390,7 @@ class HybridAdapter(BaseAdapter):
 
     async def transition_state(
         self, ticket_id: str, target_state: TicketState
-    ) -> Optional[Task | Epic]:
+    ) -> Optional[Union[Task, Epic]]:
         """Transition ticket state across all adapters.
 
         Args:

mcp_ticketer/adapters/linear.py

@@ -973,6 +973,66 @@ class LinearAdapter(BaseAdapter[Task]):
         created_issue = result["issueCreate"]["issue"]
         return self._task_from_linear_issue(created_issue)
 
+    async def create_epic(self, title: str, description: str = None, **kwargs) -> Task:
+        """Create a new epic (Linear project).
+
+        Args:
+            title: Epic title
+            description: Epic description
+            **kwargs: Additional epic properties
+
+        Returns:
+            Created Task instance representing the epic
+        """
+        # In Linear, epics are represented as issues with special labels/properties
+        task = Task(
+            title=title,
+            description=description,
+            tags=kwargs.get('tags', []) + ['epic'],  # Add epic tag
+            **{k: v for k, v in kwargs.items() if k != 'tags'}
+        )
+        return await self.create(task)
+
+    async def create_issue(self, title: str, parent_epic: str = None, description: str = None, **kwargs) -> Task:
+        """Create a new issue.
+
+        Args:
+            title: Issue title
+            parent_epic: Parent epic ID
+            description: Issue description
+            **kwargs: Additional issue properties
+
+        Returns:
+            Created Task instance representing the issue
+        """
+        task = Task(
+            title=title,
+            description=description,
+            parent_epic=parent_epic,
+            **kwargs
+        )
+        return await self.create(task)
+
+    async def create_task(self, title: str, parent_id: str, description: str = None, **kwargs) -> Task:
+        """Create a new task under an issue.
+
+        Args:
+            title: Task title
+            parent_id: Parent issue ID
+            description: Task description
+            **kwargs: Additional task properties
+
+        Returns:
+            Created Task instance
+        """
+        task = Task(
+            title=title,
+            description=description,
+            parent_issue=parent_id,
+            **kwargs
+        )
+        return await self.create(task)
+
     async def read(self, ticket_id: str) -> Optional[Task]:
         """Read a Linear issue by identifier with full details."""
         # Validate credentials before attempting operation

mcp_ticketer/cli/main.py

@@ -16,6 +16,11 @@ from ..__version__ import __version__
 from ..core import AdapterRegistry, Priority, TicketState
 from ..core.models import SearchQuery
 from ..queue import Queue, QueueStatus, WorkerManager
+from ..queue.health_monitor import QueueHealthMonitor, HealthStatus
+from ..queue.ticket_registry import TicketRegistry
+
+# Import adapters module to trigger registration
+import mcp_ticketer.adapters  # noqa: F401
 from .configure import configure_wizard, set_adapter_config, show_current_config
 from .discover import app as discover_app
 from .migrate_config import migrate_config_command
@@ -791,6 +796,76 @@ def status_command():
             )
 
 
+@app.command()
+def health(
+    auto_repair: bool = typer.Option(False, "--auto-repair", help="Attempt automatic repair of issues"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed health information")
+) -> None:
+    """Check queue system health and detect issues immediately."""
+
+    health_monitor = QueueHealthMonitor()
+    health = health_monitor.check_health()
+
+    # Display overall status
+    status_color = {
+        HealthStatus.HEALTHY: "green",
+        HealthStatus.WARNING: "yellow",
+        HealthStatus.CRITICAL: "red",
+        HealthStatus.FAILED: "red"
+    }
+
+    status_icon = {
+        HealthStatus.HEALTHY: "✓",
+        HealthStatus.WARNING: "⚠️",
+        HealthStatus.CRITICAL: "🚨",
+        HealthStatus.FAILED: "❌"
+    }
+
+    color = status_color.get(health["status"], "white")
+    icon = status_icon.get(health["status"], "?")
+
+    console.print(f"[{color}]{icon} Queue Health: {health['status'].upper()}[/{color}]")
+    console.print(f"Last checked: {health['timestamp']}")
+
+    # Display alerts
+    if health["alerts"]:
+        console.print("\n[bold]Issues Found:[/bold]")
+        for alert in health["alerts"]:
+            alert_color = status_color.get(alert["level"], "white")
+            console.print(f"[{alert_color}]  • {alert['message']}[/{alert_color}]")
+
+            if verbose and alert.get("details"):
+                for key, value in alert["details"].items():
+                    console.print(f"    {key}: {value}")
+    else:
+        console.print("\n[green]✓ No issues detected[/green]")
+
+    # Auto-repair if requested
+    if auto_repair and health["status"] in [HealthStatus.CRITICAL, HealthStatus.WARNING]:
+        console.print("\n[yellow]Attempting automatic repair...[/yellow]")
+        repair_result = health_monitor.auto_repair()
+
+        if repair_result["actions_taken"]:
+            console.print("[green]Repair actions taken:[/green]")
+            for action in repair_result["actions_taken"]:
+                console.print(f"[green]  ✓ {action}[/green]")
+
+            # Re-check health
+            console.print("\n[yellow]Re-checking health after repair...[/yellow]")
+            new_health = health_monitor.check_health()
+            new_color = status_color.get(new_health["status"], "white")
+            new_icon = status_icon.get(new_health["status"], "?")
+            console.print(f"[{new_color}]{new_icon} Updated Health: {new_health['status'].upper()}[/{new_color}]")
+        else:
+            console.print("[yellow]No repair actions available[/yellow]")
+
+    # Exit with appropriate code
+    if health["status"] == HealthStatus.CRITICAL:
+        raise typer.Exit(1)
+    elif health["status"] == HealthStatus.WARNING:
+        raise typer.Exit(2)
+
+
 @app.command()
 def create(
     title: str = typer.Argument(..., help="Ticket title"),
@@ -810,7 +885,46 @@ def create(
         None, "--adapter", help="Override default adapter"
     ),
 ) -> None:
-    """Create a new ticket."""
+    """Create a new ticket with comprehensive health checks."""
+
+    # IMMEDIATE HEALTH CHECK - Critical for reliability
+    health_monitor = QueueHealthMonitor()
+    health = health_monitor.check_health()
+
+    # Display health status
+    if health["status"] == HealthStatus.CRITICAL:
+        console.print("[red]🚨 CRITICAL: Queue system has serious issues![/red]")
+        for alert in health["alerts"]:
+            if alert["level"] == "critical":
+                console.print(f"[red]  • {alert['message']}[/red]")
+
+        # Attempt auto-repair
+        console.print("[yellow]Attempting automatic repair...[/yellow]")
+        repair_result = health_monitor.auto_repair()
+
+        if repair_result["actions_taken"]:
+            for action in repair_result["actions_taken"]:
+                console.print(f"[yellow]  ✓ {action}[/yellow]")
+
+            # Re-check health after repair
+            health = health_monitor.check_health()
+            if health["status"] == HealthStatus.CRITICAL:
+                console.print("[red]❌ Auto-repair failed. Manual intervention required.[/red]")
+                console.print("[red]Cannot safely create ticket. Please check system status.[/red]")
+                raise typer.Exit(1)
+            else:
+                console.print("[green]✓ Auto-repair successful. Proceeding with ticket creation.[/green]")
+        else:
+            console.print("[red]❌ No repair actions available. Manual intervention required.[/red]")
+            raise typer.Exit(1)
+
+    elif health["status"] == HealthStatus.WARNING:
+        console.print("[yellow]⚠️  Warning: Queue system has minor issues[/yellow]")
+        for alert in health["alerts"]:
+            if alert["level"] == "warning":
+                console.print(f"[yellow]  • {alert['message']}[/yellow]")
+        console.print("[yellow]Proceeding with ticket creation...[/yellow]")
+
     # Get the adapter name
     config = load_config()
     adapter_name = (
@@ -832,16 +946,44 @@ def create(
         ticket_data=task_data, adapter=adapter_name, operation="create"
     )
 
+    # Register in ticket registry for tracking
+    registry = TicketRegistry()
+    registry.register_ticket_operation(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("[dim]Use 'mcp-ticketer status {queue_id}' to check progress[/dim]")
+    console.print(f"  Adapter: {adapter_name}")
+    console.print("[dim]Use 'mcp-ticketer check {queue_id}' to check progress[/dim]")
 
-    # Start worker if needed
+    # Start worker if needed with immediate feedback
     manager = WorkerManager()
-    if manager.start_if_needed():
+    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
+
+        # 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 check {queue_id}'[/red]")
+    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]")
+            console.print("[red]This is a critical issue. Try 'mcp-ticketer queue worker start' manually.[/red]")
+        else:
+            console.print("[yellow]Worker not started (no other pending items)[/yellow]")
+
 
 @app.command("list")
 def list_tickets(

mcp_ticketer/core/config.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any, Optional, Union
 
 import yaml
-from pydantic import BaseModel, Field, root_validator, validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 logger = logging.getLogger(__name__)
 
@@ -45,24 +45,27 @@ class GitHubConfig(BaseAdapterConfig):
     use_projects_v2: bool = False
     custom_priority_scheme: Optional[dict[str, list[str]]] = None
 
-    @validator("token", pre=True, always=True)
-    def validate_token(self, v):
+    @field_validator("token", mode="before")
+    @classmethod
+    def validate_token(cls, v):
         if not v:
             v = os.getenv("GITHUB_TOKEN")
         if not v:
             raise ValueError("GitHub token is required")
         return v
 
-    @validator("owner", pre=True, always=True)
-    def validate_owner(self, v):
+    @field_validator("owner", mode="before")
+    @classmethod
+    def validate_owner(cls, v):
         if not v:
             v = os.getenv("GITHUB_OWNER")
         if not v:
             raise ValueError("GitHub owner is required")
         return v
 
-    @validator("repo", pre=True, always=True)
-    def validate_repo(self, v):
+    @field_validator("repo", mode="before")
+    @classmethod
+    def validate_repo(cls, v):
         if not v:
             v = os.getenv("GITHUB_REPO")
         if not v:
@@ -81,24 +84,27 @@ class JiraConfig(BaseAdapterConfig):
     cloud: bool = True
     verify_ssl: bool = True
 
-    @validator("server", pre=True, always=True)
-    def validate_server(self, v):
+    @field_validator("server", mode="before")
+    @classmethod
+    def validate_server(cls, v):
         if not v:
             v = os.getenv("JIRA_SERVER")
         if not v:
             raise ValueError("JIRA server URL is required")
         return v.rstrip("/")
 
-    @validator("email", pre=True, always=True)
-    def validate_email(self, v):
+    @field_validator("email", mode="before")
+    @classmethod
+    def validate_email(cls, v):
         if not v:
             v = os.getenv("JIRA_EMAIL")
         if not v:
             raise ValueError("JIRA email is required")
         return v
 
-    @validator("api_token", pre=True, always=True)
-    def validate_api_token(self, v):
+    @field_validator("api_token", mode="before")
+    @classmethod
+    def validate_api_token(cls, v):
         if not v:
             v = os.getenv("JIRA_API_TOKEN")
         if not v:
@@ -115,8 +121,9 @@ class LinearConfig(BaseAdapterConfig):
     team_key: str
     api_url: str = "https://api.linear.app/graphql"
 
-    @validator("api_key", pre=True, always=True)
-    def validate_api_key(self, v):
+    @field_validator("api_key", mode="before")
+    @classmethod
+    def validate_api_key(cls, v):
         if not v:
             v = os.getenv("LINEAR_API_KEY")
         if not v:
@@ -163,23 +170,23 @@ class AppConfig(BaseModel):
     cache_ttl: int = 300  # Cache TTL in seconds
     default_adapter: Optional[str] = None
 
-    @root_validator(skip_on_failure=True)
-    def validate_adapters(self, values):
+    @model_validator(mode="after")
+    def validate_adapters(self):
         """Validate adapter configurations."""
-        adapters = values.get("adapters", {})
+        adapters = self.adapters
 
         if not adapters:
             logger.warning("No adapters configured")
-            return values
+            return self
 
         # Validate default adapter
-        default_adapter = values.get("default_adapter")
+        default_adapter = self.default_adapter
         if default_adapter and default_adapter not in adapters:
             raise ValueError(
                 f"Default adapter '{default_adapter}' not found in adapters"
             )
 
-        return values
+        return self
 
     def get_adapter_config(self, adapter_name: str) -> Optional[BaseAdapterConfig]:
         """Get configuration for a specific adapter."""