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

mcp_ticketer/queue/worker.py

@@ -7,17 +7,17 @@ import threading
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from dotenv import load_dotenv
 
+# Import adapters module to trigger registration
+import mcp_ticketer.adapters  # noqa: F401
+
 from ..core import AdapterRegistry, Task
 from .queue import Queue, QueueItem, QueueStatus
 from .ticket_registry import TicketRegistry
 
-# Import adapters module to trigger registration
-import mcp_ticketer.adapters  # noqa: F401
-
 # Load environment variables from .env.local
 env_path = Path.cwd() / ".env.local"
 if env_path.exists():
@@ -58,7 +58,7 @@ class Worker:
 
     def __init__(
         self,
-        queue: Optional[Queue] = None,
+        queue: Queue | None = None,
         batch_size: int = DEFAULT_BATCH_SIZE,
         max_concurrent: int = DEFAULT_MAX_CONCURRENT,
     ):
@@ -97,12 +97,12 @@ class Worker:
             f"Worker initialized with batch_size={batch_size}, max_concurrent={max_concurrent}"
         )
 
-    def _signal_handler(self, signum, frame):
+    def _signal_handler(self, signum: int, frame: Any) -> None:
         """Handle shutdown signals."""
         logger.info(f"Received signal {signum}, shutting down...")
         self.stop()
 
-    def start(self, daemon: bool = True):
+    def start(self, daemon: bool = True) -> None:
         """Start the worker.
 
         Args:
@@ -126,14 +126,14 @@ class Worker:
             # Run in main thread
             self._run_loop()
 
-    def stop(self):
+    def stop(self) -> None:
         """Stop the worker."""
         logger.info("Stopping worker...")
         self.running = False
         self.stop_event.set()
 
-    def _run_loop(self):
-        """Main worker loop with batch processing."""
+    def _run_loop(self) -> None:
+        """Run main worker loop with batch processing."""
         logger.info("Worker loop started")
 
         # Reset any stuck items on startup
@@ -174,7 +174,7 @@ class Worker:
                 break
         return batch
 
-    async def _process_batch(self, batch: list[QueueItem]):
+    async def _process_batch(self, batch: list[QueueItem]) -> None:
         """Process a batch of queue items with concurrency control.
 
         Args:
@@ -184,7 +184,7 @@ class Worker:
         logger.info(f"Processing batch of {len(batch)} items")
 
         # Group items by adapter for concurrent processing
-        adapter_groups = {}
+        adapter_groups: dict[str, list[Any]] = {}
         for item in batch:
             if item.adapter not in adapter_groups:
                 adapter_groups[item.adapter] = []
@@ -199,7 +199,9 @@ class Worker:
         # Wait for all adapter groups to complete
         await asyncio.gather(*tasks, return_exceptions=True)
 
-    async def _process_adapter_group(self, adapter: str, items: list[QueueItem]):
+    async def _process_adapter_group(
+        self, adapter: str, items: list[QueueItem]
+    ) -> None:
         """Process items for a specific adapter with concurrency control.
 
         Args:
@@ -216,7 +218,7 @@ class Worker:
         semaphore = self.adapter_semaphores[adapter]
 
         # Process items with concurrency control
-        async def process_with_semaphore(item):
+        async def process_with_semaphore(item: QueueItem) -> None:
             async with semaphore:
                 await self._process_item(item)
 
@@ -226,7 +228,7 @@ class Worker:
         # Process with concurrency control
         await asyncio.gather(*tasks, return_exceptions=True)
 
-    async def _process_item(self, item: QueueItem):
+    async def _process_item(self, item: QueueItem) -> None:
         """Process a single queue item.
 
         Args:
@@ -263,15 +265,19 @@ class Worker:
 
             # Mark as completed in both queue and registry (atomic)
             success = self.queue.update_status(
-                item.id, QueueStatus.COMPLETED, result=result,
-                expected_status=QueueStatus.PROCESSING
+                item.id,
+                QueueStatus.COMPLETED,
+                result=result,
+                expected_status=QueueStatus.PROCESSING,
             )
             if success:
                 self.ticket_registry.update_ticket_status(
                     item.id, "completed", ticket_id=ticket_id, result_data=result
                 )
             else:
-                logger.warning(f"Failed to update status for {item.id} - item may have been processed by another worker")
+                logger.warning(
+                    f"Failed to update status for {item.id} - item may have been processed by another worker"
+                )
 
             self.stats["items_processed"] += 1
             logger.info(f"Successfully processed {item.id}, ticket ID: {ticket_id}")
@@ -301,26 +307,35 @@ class Worker:
                         item.id, "queued", retry_count=new_retry_count
                     )
                 else:
-                    logger.warning(f"Failed to increment retry for {item.id} - item may have been processed by another worker")
+                    logger.warning(
+                        f"Failed to increment retry for {item.id} - item may have been processed by another worker"
+                    )
 
                 # Wait before retry
                 await asyncio.sleep(retry_delay)
             else:
                 # Max retries exceeded, mark as failed (atomic)
                 success = self.queue.update_status(
-                    item.id, QueueStatus.FAILED, error_message=str(e),
-                    expected_status=QueueStatus.PROCESSING
+                    item.id,
+                    QueueStatus.FAILED,
+                    error_message=str(e),
+                    expected_status=QueueStatus.PROCESSING,
                 )
                 if success:
                     self.ticket_registry.update_ticket_status(
-                        item.id, "failed", error_message=str(e), retry_count=item.retry_count
+                        item.id,
+                        "failed",
+                        error_message=str(e),
+                        retry_count=item.retry_count,
                     )
                 else:
-                    logger.warning(f"Failed to mark {item.id} as failed - item may have been processed by another worker")
+                    logger.warning(
+                        f"Failed to mark {item.id} as failed - item may have been processed by another worker"
+                    )
                 self.stats["items_failed"] += 1
                 logger.error(f"Max retries exceeded for {item.id}, marking as failed")
 
-    async def _check_rate_limit(self, adapter: str):
+    async def _check_rate_limit(self, adapter: str) -> None:
         """Check and enforce rate limits.
 
         Args:
@@ -344,7 +359,7 @@ class Worker:
 
         self.last_request_times[adapter] = datetime.now()
 
-    def _get_adapter(self, item: QueueItem):
+    def _get_adapter(self, item: QueueItem) -> Any:
         """Get adapter instance for item.
 
         Args:
@@ -360,19 +375,31 @@ class Worker:
 
         from ..cli.main import load_config
 
-        # Use item's project_dir if available, otherwise use current directory
-        project_path = Path(item.project_dir) if item.project_dir else None
-
-        # Load environment variables from project directory's .env.local if it exists
-        if project_path:
-            env_file = project_path / ".env.local"
-            if env_file.exists():
-                logger.debug(f"Loading environment from {env_file}")
-                load_dotenv(env_file)
-
-        config = load_config(project_dir=project_path)
-        adapters_config = config.get("adapters", {})
-        adapter_config = adapters_config.get(item.adapter, {})
+        # PRIORITY 1: Use adapter_config from queue item if available (explicit config)
+        if item.adapter_config:
+            logger.info("Worker using explicit adapter_config from queue item")
+            adapter_config = item.adapter_config
+            logger.info(f"Worker adapter config for {item.adapter}: {adapter_config}")
+        else:
+            # PRIORITY 2: Load from project config file
+            # Use item's project_dir if available, otherwise use current directory
+            project_path = Path(item.project_dir) if item.project_dir else None
+
+            # Load environment variables from project directory's .env.local if it exists
+            if project_path:
+                env_file = project_path / ".env.local"
+                if env_file.exists():
+                    logger.info(f"Worker loading environment from {env_file}")
+                    load_dotenv(env_file)
+
+            logger.info(f"Worker project_path: {project_path}")
+            logger.info(f"Worker current working directory: {os.getcwd()}")
+
+            config = load_config(project_dir=project_path)
+            logger.info(f"Worker loaded config: {config}")
+            adapters_config = config.get("adapters", {})
+            adapter_config = adapters_config.get(item.adapter, {})
+            logger.info(f"Worker adapter config for {item.adapter}: {adapter_config}")
 
         # Add environment variables for authentication
         if item.adapter == "linear":
@@ -387,9 +414,37 @@ class Worker:
             if not adapter_config.get("email"):
                 adapter_config["email"] = os.getenv("JIRA_ACCESS_USER")
 
-        return AdapterRegistry.get_adapter(item.adapter, adapter_config)
+        logger.info(f"Worker final adapter config: {adapter_config}")
+
+        # Add debugging for Linear adapter specifically
+        if item.adapter == "linear":
+            import os
+
+            linear_api_key = os.getenv("LINEAR_API_KEY", "Not set")
+            logger.info(
+                f"Worker LINEAR_API_KEY: {linear_api_key[:20] if linear_api_key != 'Not set' else 'Not set'}..."
+            )
+            logger.info(
+                f"Worker adapter_config api_key: {adapter_config.get('api_key', 'Not set')[:20] if adapter_config.get('api_key') else 'Not set'}..."
+            )
+
+        adapter = AdapterRegistry.get_adapter(item.adapter, adapter_config)
+        logger.info(
+            f"Worker created adapter: {type(adapter)} with team_id: {getattr(adapter, 'team_id_config', 'Not set')}"
+        )
+
+        # Add more debugging for Linear adapter
+        if item.adapter == "linear":
+            logger.info(
+                f"Worker Linear adapter api_key: {getattr(adapter, 'api_key', 'Not set')[:20] if getattr(adapter, 'api_key', None) else 'Not set'}..."
+            )
+            logger.info(
+                f"Worker Linear adapter team_key: {getattr(adapter, 'team_key', 'Not set')}"
+            )
+
+        return adapter
 
-    async def _execute_operation(self, adapter, item: QueueItem) -> dict[str, Any]:
+    async def _execute_operation(self, adapter: Any, item: QueueItem) -> dict[str, Any]:
         """Execute the queued operation.
 
         Args:
@@ -439,14 +494,13 @@ class Worker:
             result = await adapter.create_epic(
                 title=data["title"],
                 description=data.get("description"),
-                **{k: v for k, v in data.items()
-                   if k not in ["title", "description"]}
+                **{k: v for k, v in data.items() if k not in ["title", "description"]},
             )
             return {
                 "id": result.id if result else None,
                 "title": result.title if result else None,
                 "type": "epic",
-                "success": bool(result)
+                "success": bool(result),
             }
 
         elif operation == "create_issue":
@@ -454,15 +508,18 @@ class Worker:
                 title=data["title"],
                 description=data.get("description"),
                 epic_id=data.get("epic_id"),
-                **{k: v for k, v in data.items()
-                   if k not in ["title", "description", "epic_id"]}
+                **{
+                    k: v
+                    for k, v in data.items()
+                    if k not in ["title", "description", "epic_id"]
+                },
             )
             return {
                 "id": result.id if result else None,
                 "title": result.title if result else None,
                 "type": "issue",
                 "epic_id": data.get("epic_id"),
-                "success": bool(result)
+                "success": bool(result),
             }
 
         elif operation == "create_task":
@@ -470,15 +527,18 @@ class Worker:
                 title=data["title"],
                 parent_id=data["parent_id"],
                 description=data.get("description"),
-                **{k: v for k, v in data.items()
-                   if k not in ["title", "parent_id", "description"]}
+                **{
+                    k: v
+                    for k, v in data.items()
+                    if k not in ["title", "parent_id", "description"]
+                },
             )
             return {
                 "id": result.id if result else None,
                 "title": result.title if result else None,
                 "type": "task",
                 "parent_id": data["parent_id"],
-                "success": bool(result)
+                "success": bool(result),
             }
 
         else: