mcp-ticketer 0.1.30__py3-none-any.whl → 1.2.11__py3-none-any.whl

mcp_ticketer/cli/utils.py

@@ -4,9 +4,10 @@ import asyncio
 import json
 import logging
 import os
+from collections.abc import Callable
 from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, Optional, TypeVar
+from typing import Any, TypeVar
 
 import typer
 from rich.console import Console
@@ -31,7 +32,7 @@ class CommonPatterns:
 
     @staticmethod
     def load_config() -> dict:
-        """Load configuration from project-local config file ONLY.
+        """Load configuration from project-local config file with environment discovery fallback.
 
         SECURITY: This method ONLY reads from the current project directory
         to prevent configuration leakage across projects. It will NEVER read
@@ -39,7 +40,8 @@ class CommonPatterns:
 
         Resolution order:
         1. Project-specific config (.mcp-ticketer/config.json in cwd)
-        2. Default to aitrackdown adapter
+        2. Environment discovery (environment variables and .env files in cwd)
+        3. Default to aitrackdown adapter
 
         Returns:
             Configuration dictionary with adapter and config keys.
@@ -77,6 +79,43 @@ class CommonPatterns:
                     f"[yellow]Warning: Could not load project config: {e}[/yellow]"
                 )
 
+        # Try environment discovery as fallback
+        try:
+            from ..core.config import ConfigurationManager
+
+            config_manager = ConfigurationManager()
+            app_config = config_manager.load_config()
+
+            # Convert AppConfig to legacy dict format for CLI compatibility
+            enabled_adapters = app_config.get_enabled_adapters()
+            if enabled_adapters:
+                # Use the first enabled adapter as default
+                default_adapter = (
+                    app_config.default_adapter or list(enabled_adapters.keys())[0]
+                )
+
+                # Convert to legacy format
+                legacy_config = {"default_adapter": default_adapter, "adapters": {}}
+
+                # Convert adapter configs to dict format
+                for name, adapter_config in enabled_adapters.items():
+                    if hasattr(adapter_config, "model_dump"):
+                        legacy_config["adapters"][name] = adapter_config.model_dump(
+                            exclude_none=False
+                        )
+                    elif hasattr(adapter_config, "dict"):
+                        legacy_config["adapters"][name] = adapter_config.dict()
+                    else:
+                        legacy_config["adapters"][name] = adapter_config
+
+                logger.info(
+                    f"Loaded configuration from environment discovery: {list(enabled_adapters.keys())}"
+                )
+                return legacy_config
+
+        except Exception as e:
+            logger.warning(f"Environment discovery failed: {e}")
+
         # Default to aitrackdown with local base path
         logger.info("No project-local config found, defaulting to aitrackdown adapter")
         return {"adapter": "aitrackdown", "config": {"base_path": ".aitrackdown"}}
@@ -116,8 +155,8 @@ class CommonPatterns:
 
     @staticmethod
     def get_adapter(
-        override_adapter: Optional[str] = None, override_config: Optional[dict] = None
-    ):
+        override_adapter: str | None = None, override_config: dict | None = None
+    ) -> Any:
         """Get configured adapter instance with environment variable support."""
         config = CommonPatterns.load_config()
 
@@ -168,7 +207,7 @@ class CommonPatterns:
     def queue_operation(
         ticket_data: dict[str, Any],
         operation: str,
-        adapter_name: Optional[str] = None,
+        adapter_name: str | None = None,
         show_progress: bool = True,
     ) -> str:
         """Queue an operation and optionally start the worker."""
@@ -176,10 +215,15 @@ class CommonPatterns:
             config = CommonPatterns.load_config()
             adapter_name = config.get("default_adapter", "aitrackdown")
 
-        # Add to queue
+        # Add to queue with explicit project directory
+        from pathlib import Path
+
         queue = Queue()
         queue_id = queue.add(
-            ticket_data=ticket_data, adapter=adapter_name, operation=operation
+            ticket_data=ticket_data,
+            adapter=adapter_name,
+            operation=operation,
+            project_dir=str(Path.cwd()),  # Explicitly pass current project directory
         )
 
         if show_progress:
@@ -222,7 +266,7 @@ class CommonPatterns:
         console.print(table)
 
     @staticmethod
-    def display_ticket_details(ticket: Task, comments: Optional[list] = None) -> None:
+    def display_ticket_details(ticket: Task, comments: list | None = None) -> None:
         """Display detailed ticket information."""
         console.print(f"\n[bold]Ticket: {ticket.id}[/bold]")
         console.print(f"Title: {ticket.title}")
@@ -277,33 +321,35 @@ class CommonPatterns:
                 )
 
 
-def async_command(f: Callable[..., T]) -> Callable[..., T]:
-    """Decorator to handle async CLI commands."""
+def async_command(f: Callable[..., Any]) -> Callable[..., Any]:
+    """Handle async CLI commands via decorator."""
 
     @wraps(f)
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
         return asyncio.run(f(*args, **kwargs))
 
     return wrapper
 
 
-def with_adapter(f: Callable) -> Callable:
-    """Decorator to inject adapter instance into CLI commands."""
+def with_adapter(f: Callable[..., Any]) -> Callable[..., Any]:
+    """Inject adapter instance into CLI commands via decorator."""
 
     @wraps(f)
-    def wrapper(adapter: Optional[str] = None, *args, **kwargs):
+    def wrapper(adapter: str | None = None, *args: Any, **kwargs: Any) -> Any:
         adapter_instance = CommonPatterns.get_adapter(override_adapter=adapter)
         return f(adapter_instance, *args, **kwargs)
 
     return wrapper
 
 
-def with_progress(message: str = "Processing..."):
-    """Decorator to show progress spinner for long-running operations."""
+def with_progress(
+    message: str = "Processing...",
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Show progress spinner for long-running operations via decorator."""
 
-    def decorator(f: Callable) -> Callable:
+    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
         @wraps(f)
-        def wrapper(*args, **kwargs):
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
             with Progress(
                 SpinnerColumn(),
                 TextColumn("[progress.description]{task.description}"),
@@ -317,12 +363,14 @@ def with_progress(message: str = "Processing..."):
     return decorator
 
 
-def validate_required_fields(**field_map):
-    """Decorator to validate required fields are provided."""
+def validate_required_fields(
+    **field_map: str,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Validate required fields are provided via decorator."""
 
-    def decorator(f: Callable) -> Callable:
+    def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
         @wraps(f)
-        def wrapper(*args, **kwargs):
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
             missing_fields = []
             for field_name, display_name in field_map.items():
                 if field_name in kwargs and kwargs[field_name] is None:
@@ -332,7 +380,7 @@ def validate_required_fields(**field_map):
                 console.print(
                     f"[red]Error:[/red] Missing required fields: {', '.join(missing_fields)}"
                 )
-                raise typer.Exit(1)
+                raise typer.Exit(1) from None
 
             return f(*args, **kwargs)
 
@@ -341,24 +389,24 @@ def validate_required_fields(**field_map):
     return decorator
 
 
-def handle_adapter_errors(f: Callable) -> Callable:
-    """Decorator to handle common adapter errors gracefully."""
+def handle_adapter_errors(f: Callable[..., Any]) -> Callable[..., Any]:
+    """Handle common adapter errors gracefully via decorator."""
 
     @wraps(f)
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return f(*args, **kwargs)
         except ConnectionError as e:
             console.print(f"[red]Connection Error:[/red] {e}")
             console.print("Check your network connection and adapter configuration")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
         except ValueError as e:
             console.print(f"[red]Configuration Error:[/red] {e}")
             console.print("Run 'mcp-ticketer init' to configure your adapter")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
         except Exception as e:
             console.print(f"[red]Unexpected Error:[/red] {e}")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
 
     return wrapper
 
@@ -403,7 +451,7 @@ class ConfigValidator:
         return issues
 
     @staticmethod
-    def _get_env_var(adapter_type: str, field: str) -> Optional[str]:
+    def _get_env_var(adapter_type: str, field: str) -> str | None:
         """Get corresponding environment variable name for a config field."""
         env_mapping = {
             "github": {
@@ -424,39 +472,39 @@ class ConfigValidator:
 class CommandBuilder:
     """Builder for common CLI command patterns."""
 
-    def __init__(self):
-        self._validators = []
-        self._handlers = []
-        self._decorators = []
+    def __init__(self) -> None:
+        self._validators: list[Callable[..., Any]] = []
+        self._handlers: list[Callable[..., Any]] = []
+        self._decorators: list[Callable[..., Any]] = []
 
-    def with_adapter_validation(self):
+    def with_adapter_validation(self) -> "CommandBuilder":
         """Add adapter configuration validation."""
         self._validators.append(self._validate_adapter)
         return self
 
-    def with_async_support(self):
+    def with_async_support(self) -> "CommandBuilder":
         """Add async support to command."""
         self._decorators.append(async_command)
         return self
 
-    def with_error_handling(self):
+    def with_error_handling(self) -> "CommandBuilder":
         """Add error handling decorator."""
         self._decorators.append(handle_adapter_errors)
         return self
 
-    def with_progress(self, message: str = "Processing..."):
+    def with_progress(self, message: str = "Processing...") -> "CommandBuilder":
         """Add progress spinner."""
         self._decorators.append(with_progress(message))
         return self
 
-    def build(self, func: Callable) -> Callable:
+    def build(self, func: Callable[..., Any]) -> Callable[..., Any]:
         """Build the decorated function."""
         decorated_func = func
         for decorator in reversed(self._decorators):
             decorated_func = decorator(decorated_func)
         return decorated_func
 
-    def _validate_adapter(self, *args, **kwargs):
+    def _validate_adapter(self, *args: Any, **kwargs: Any) -> None:
         """Validate adapter configuration."""
         config = CommonPatterns.load_config()
         default_adapter = config.get("default_adapter", "aitrackdown")
@@ -470,22 +518,22 @@ class CommandBuilder:
             for issue in issues:
                 console.print(f"  • {issue}")
             console.print("Run 'mcp-ticketer init' to fix configuration")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
 
 
-def create_standard_ticket_command(operation: str):
+def create_standard_ticket_command(operation: str) -> Callable[..., str]:
     """Create a standard ticket operation command."""
 
     def command_template(
-        ticket_id: Optional[str] = None,
-        title: Optional[str] = None,
-        description: Optional[str] = None,
-        priority: Optional[Priority] = None,
-        state: Optional[TicketState] = None,
-        assignee: Optional[str] = None,
-        tags: Optional[list[str]] = None,
-        adapter: Optional[str] = None,
-    ):
+        ticket_id: str | None = None,
+        title: str | None = None,
+        description: str | None = None,
+        priority: Priority | None = None,
+        state: TicketState | None = None,
+        assignee: str | None = None,
+        tags: list[str] | None = None,
+        adapter: str | None = None,
+    ) -> str:
         """Template for ticket commands."""
         # Build ticket data
         ticket_data = {}
@@ -524,11 +572,11 @@ class TicketCommands:
     @async_command
     @handle_adapter_errors
     async def list_tickets(
-        adapter_instance,
-        state: Optional[TicketState] = None,
-        priority: Optional[Priority] = None,
+        adapter_instance: Any,
+        state: TicketState | None = None,
+        priority: Priority | None = None,
         limit: int = 10,
-    ):
+    ) -> None:
         """List tickets with filters."""
         filters = {}
         if state:
@@ -543,13 +591,13 @@ class TicketCommands:
     @async_command
     @handle_adapter_errors
     async def show_ticket(
-        adapter_instance, ticket_id: str, show_comments: bool = False
-    ):
+        adapter_instance: Any, ticket_id: str, show_comments: bool = False
+    ) -> None:
         """Show ticket details."""
         ticket = await adapter_instance.read(ticket_id)
         if not ticket:
             console.print(f"[red]✗[/red] Ticket not found: {ticket_id}")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
 
         comments = None
         if show_comments:
@@ -560,11 +608,11 @@ class TicketCommands:
     @staticmethod
     def create_ticket(
         title: str,
-        description: Optional[str] = None,
+        description: str | None = None,
         priority: Priority = Priority.MEDIUM,
-        tags: Optional[list[str]] = None,
-        assignee: Optional[str] = None,
-        adapter: Optional[str] = None,
+        tags: list[str] | None = None,
+        assignee: str | None = None,
+        adapter: str | None = None,
     ) -> str:
         """Create a new ticket."""
         ticket_data = {
@@ -579,19 +627,19 @@ class TicketCommands:
 
     @staticmethod
     def update_ticket(
-        ticket_id: str, updates: dict[str, Any], adapter: Optional[str] = None
+        ticket_id: str, updates: dict[str, Any], adapter: str | None = None
     ) -> str:
         """Update a ticket."""
         if not updates:
             console.print("[yellow]No updates specified[/yellow]")
-            raise typer.Exit(1)
+            raise typer.Exit(1) from None
 
         updates["ticket_id"] = ticket_id
         return CommonPatterns.queue_operation(updates, "update", adapter)
 
     @staticmethod
     def transition_ticket(
-        ticket_id: str, state: TicketState, adapter: Optional[str] = None
+        ticket_id: str, state: TicketState, adapter: str | None = None
     ) -> str:
         """Transition ticket state."""
         ticket_data = {

mcp_ticketer/core/__init__.py

@@ -1,16 +1,39 @@
 """Core models and abstractions for MCP Ticketer."""
 
 from .adapter import BaseAdapter
-from .models import Comment, Epic, Priority, Task, TicketState, TicketType
+from .instructions import (
+    InstructionsError,
+    InstructionsNotFoundError,
+    InstructionsValidationError,
+    TicketInstructionsManager,
+    get_instructions,
+)
+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",
     "TicketState",
     "Priority",
     "TicketType",
     "BaseAdapter",
     "AdapterRegistry",
+    "TicketInstructionsManager",
+    "InstructionsError",
+    "InstructionsNotFoundError",
+    "InstructionsValidationError",
+    "get_instructions",
+    "SemanticStateMatcher",
+    "StateMatchResult",
+    "ValidationResult",
+    "get_state_matcher",
 ]