mcp-ticketer 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

mcp_ticketer/core/env_loader.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
-"""
-Unified Environment Loading System for MCP Ticketer.
+"""Unified Environment Loading System for MCP Ticketer.
 
 This module provides a resilient environment loading system that:
 1. Supports multiple naming conventions for each configuration key
@@ -9,11 +8,11 @@ This module provides a resilient environment loading system that:
 4. Provides fallback mechanisms for different key aliases
 """
 
-import os
 import logging
-from pathlib import Path
-from typing import Dict, Any, List, Optional, Union
+import os
 from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -21,6 +20,7 @@ logger = logging.getLogger(__name__)
 @dataclass
 class EnvKeyConfig:
     """Configuration for environment variable key aliases."""
+
     primary_key: str
     aliases: List[str]
     description: str
@@ -29,11 +29,10 @@ class EnvKeyConfig:
 
 
 class UnifiedEnvLoader:
-    """
-    Unified environment loader that handles multiple naming conventions
+    """Unified environment loader that handles multiple naming conventions
     and provides consistent environment loading across all contexts.
     """
-    
+
     # Define key aliases for all adapters
     KEY_MAPPINGS = {
         # Linear adapter keys
@@ -41,93 +40,97 @@ class UnifiedEnvLoader:
             primary_key="LINEAR_API_KEY",
             aliases=["LINEAR_TOKEN", "LINEAR_ACCESS_TOKEN", "LINEAR_AUTH_TOKEN"],
             description="Linear API key",
-            required=True
+            required=True,
         ),
         "linear_team_id": EnvKeyConfig(
             primary_key="LINEAR_TEAM_ID",
             aliases=["LINEAR_TEAM_UUID", "LINEAR_TEAM_IDENTIFIER"],
             description="Linear team ID (UUID)",
-            required=False
+            required=False,
         ),
         "linear_team_key": EnvKeyConfig(
             primary_key="LINEAR_TEAM_KEY",
             aliases=["LINEAR_TEAM_IDENTIFIER", "LINEAR_TEAM_NAME"],
             description="Linear team key (short name)",
-            required=False
+            required=False,
         ),
-        
         # JIRA adapter keys
         "jira_server": EnvKeyConfig(
             primary_key="JIRA_SERVER",
             aliases=["JIRA_URL", "JIRA_HOST", "JIRA_BASE_URL"],
             description="JIRA server URL",
-            required=True
+            required=True,
         ),
         "jira_email": EnvKeyConfig(
             primary_key="JIRA_EMAIL",
             aliases=["JIRA_USER", "JIRA_USERNAME", "JIRA_ACCESS_USER"],
             description="JIRA user email",
-            required=True
+            required=True,
         ),
         "jira_api_token": EnvKeyConfig(
             primary_key="JIRA_API_TOKEN",
-            aliases=["JIRA_TOKEN", "JIRA_ACCESS_TOKEN", "JIRA_AUTH_TOKEN", "JIRA_PASSWORD"],
+            aliases=[
+                "JIRA_TOKEN",
+                "JIRA_ACCESS_TOKEN",
+                "JIRA_AUTH_TOKEN",
+                "JIRA_PASSWORD",
+            ],
             description="JIRA API token",
-            required=True
+            required=True,
         ),
         "jira_project_key": EnvKeyConfig(
             primary_key="JIRA_PROJECT_KEY",
             aliases=["JIRA_PROJECT", "JIRA_PROJECT_ID"],
             description="JIRA project key",
-            required=False
+            required=False,
         ),
-        
         # GitHub adapter keys
         "github_token": EnvKeyConfig(
             primary_key="GITHUB_TOKEN",
             aliases=["GITHUB_ACCESS_TOKEN", "GITHUB_API_TOKEN", "GITHUB_AUTH_TOKEN"],
             description="GitHub access token",
-            required=True
+            required=True,
         ),
         "github_owner": EnvKeyConfig(
             primary_key="GITHUB_OWNER",
             aliases=["GITHUB_USER", "GITHUB_USERNAME", "GITHUB_ORG"],
             description="GitHub repository owner",
-            required=True
+            required=True,
         ),
         "github_repo": EnvKeyConfig(
             primary_key="GITHUB_REPO",
             aliases=["GITHUB_REPOSITORY", "GITHUB_REPO_NAME"],
             description="GitHub repository name",
-            required=True
+            required=True,
         ),
     }
-    
+
     def __init__(self, project_root: Optional[Path] = None):
         """Initialize the environment loader.
-        
+
         Args:
             project_root: Project root directory. If None, will auto-detect.
+
         """
         self.project_root = project_root or self._find_project_root()
         self._env_cache: Dict[str, str] = {}
         self._load_env_files()
-    
+
     def _find_project_root(self) -> Path:
         """Find the project root directory."""
         current = Path.cwd()
-        
+
         # Look for common project indicators
         indicators = [".mcp-ticketer", ".git", "pyproject.toml", "setup.py"]
-        
+
         while current != current.parent:
             if any((current / indicator).exists() for indicator in indicators):
                 return current
             current = current.parent
-        
+
         # Fallback to current directory
         return Path.cwd()
-    
+
     def _load_env_files(self):
         """Load environment variables from .env files."""
         env_files = [
@@ -135,142 +138,160 @@ class UnifiedEnvLoader:
             self.project_root / ".env",
             Path.home() / ".mcp-ticketer" / ".env",
         ]
-        
+
         for env_file in env_files:
             if env_file.exists():
                 logger.debug(f"Loading environment from: {env_file}")
                 self._load_env_file(env_file)
-    
+
     def _load_env_file(self, env_file: Path):
         """Load variables from a single .env file."""
         try:
-            with open(env_file, 'r') as f:
+            with open(env_file) as f:
                 for line_num, line in enumerate(f, 1):
                     line = line.strip()
-                    
+
                     # Skip empty lines and comments
-                    if not line or line.startswith('#'):
+                    if not line or line.startswith("#"):
                         continue
-                    
+
                     # Parse KEY=VALUE format
-                    if '=' in line:
-                        key, value = line.split('=', 1)
+                    if "=" in line:
+                        key, value = line.split("=", 1)
                         key = key.strip()
                         value = value.strip()
-                        
+
                         # Remove quotes if present
                         if value.startswith('"') and value.endswith('"'):
                             value = value[1:-1]
                         elif value.startswith("'") and value.endswith("'"):
                             value = value[1:-1]
-                        
+
                         # Only set if not already in environment
                         if key not in os.environ:
                             os.environ[key] = value
                             self._env_cache[key] = value
                             logger.debug(f"Loaded {key} from {env_file}")
-                        
+
         except Exception as e:
             logger.warning(f"Failed to load {env_file}: {e}")
-    
-    def get_value(self, config_key: str, config: Optional[Dict[str, Any]] = None) -> Optional[str]:
-        """
-        Get a configuration value using the key alias system.
-        
+
+    def get_value(
+        self, config_key: str, config: Optional[Dict[str, Any]] = None
+    ) -> Optional[str]:
+        """Get a configuration value using the key alias system.
+
         Args:
             config_key: The configuration key (e.g., 'linear_api_key')
             config: Optional configuration dictionary to check first
-            
+
         Returns:
             The value if found, None otherwise
+
         """
         if config_key not in self.KEY_MAPPINGS:
             logger.warning(f"Unknown configuration key: {config_key}")
             return None
-        
+
         key_config = self.KEY_MAPPINGS[config_key]
-        
+
         # 1. Check provided config dictionary first
         if config:
             # Check for the config key itself (without adapter prefix)
-            simple_key = config_key.split('_', 1)[1] if '_' in config_key else config_key
+            simple_key = (
+                config_key.split("_", 1)[1] if "_" in config_key else config_key
+            )
             if simple_key in config:
                 value = config[simple_key]
                 if value:
                     logger.debug(f"Found {config_key} in config as {simple_key}")
                     return str(value)
-        
+
         # 2. Check environment variables (primary key first, then aliases)
         all_keys = [key_config.primary_key] + key_config.aliases
-        
+
         for env_key in all_keys:
             value = os.getenv(env_key)
             if value:
                 logger.debug(f"Found {config_key} as {env_key}")
                 return value
-        
+
         # 3. Return default if available
         if key_config.default:
             logger.debug(f"Using default for {config_key}")
             return key_config.default
-        
+
         # 4. Log if required key is missing
         if key_config.required:
-            logger.warning(f"Required configuration key {config_key} not found. Tried: {all_keys}")
-        
+            logger.warning(
+                f"Required configuration key {config_key} not found. Tried: {all_keys}"
+            )
+
         return None
-    
-    def get_adapter_config(self, adapter_name: str, base_config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Get complete configuration for an adapter with environment variable resolution.
-        
+
+    def get_adapter_config(
+        self, adapter_name: str, base_config: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Get complete configuration for an adapter with environment variable resolution.
+
         Args:
             adapter_name: Name of the adapter ('linear', 'jira', 'github')
             base_config: Base configuration dictionary
-            
+
         Returns:
             Complete configuration with environment variables resolved
+
         """
         config = base_config.copy() if base_config else {}
-        
+
         # Get adapter-specific keys
-        adapter_keys = [key for key in self.KEY_MAPPINGS.keys() if key.startswith(f"{adapter_name}_")]
-        
+        adapter_keys = [
+            key
+            for key in self.KEY_MAPPINGS.keys()
+            if key.startswith(f"{adapter_name}_")
+        ]
+
         for config_key in adapter_keys:
             # Remove adapter prefix for the config key
-            simple_key = config_key.split('_', 1)[1]
-            
+            simple_key = config_key.split("_", 1)[1]
+
             # Only set if not already in config or if config value is empty
             if simple_key not in config or not config[simple_key]:
                 value = self.get_value(config_key, config)
                 if value:
                     config[simple_key] = value
-        
+
         return config
-    
-    def validate_adapter_config(self, adapter_name: str, config: Dict[str, Any]) -> List[str]:
-        """
-        Validate that all required configuration is present for an adapter.
-        
+
+    def validate_adapter_config(
+        self, adapter_name: str, config: Dict[str, Any]
+    ) -> List[str]:
+        """Validate that all required configuration is present for an adapter.
+
         Args:
             adapter_name: Name of the adapter
             config: Configuration dictionary
-            
+
         Returns:
             List of missing required keys (empty if all required keys are present)
+
         """
         missing_keys = []
-        adapter_keys = [key for key in self.KEY_MAPPINGS.keys() if key.startswith(f"{adapter_name}_")]
-        
+        adapter_keys = [
+            key
+            for key in self.KEY_MAPPINGS.keys()
+            if key.startswith(f"{adapter_name}_")
+        ]
+
         for config_key in adapter_keys:
             key_config = self.KEY_MAPPINGS[config_key]
             if key_config.required:
-                simple_key = config_key.split('_', 1)[1]
+                simple_key = config_key.split("_", 1)[1]
                 if simple_key not in config or not config[simple_key]:
                     missing_keys.append(f"{simple_key} ({key_config.description})")
-        
+
         return missing_keys
-    
+
     def get_debug_info(self) -> Dict[str, Any]:
         """Get debug information about environment loading."""
         return {
@@ -297,29 +318,31 @@ def get_env_loader() -> UnifiedEnvLoader:
     return _env_loader
 
 
-def load_adapter_config(adapter_name: str, base_config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """
-    Convenience function to load adapter configuration with environment variables.
-    
+def load_adapter_config(
+    adapter_name: str, base_config: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """Convenience function to load adapter configuration with environment variables.
+
     Args:
         adapter_name: Name of the adapter ('linear', 'jira', 'github')
         base_config: Base configuration dictionary
-        
+
     Returns:
         Complete configuration with environment variables resolved
+
     """
     return get_env_loader().get_adapter_config(adapter_name, base_config)
 
 
 def validate_adapter_config(adapter_name: str, config: Dict[str, Any]) -> List[str]:
-    """
-    Convenience function to validate adapter configuration.
-    
+    """Convenience function to validate adapter configuration.
+
     Args:
         adapter_name: Name of the adapter
         config: Configuration dictionary
-        
+
     Returns:
         List of missing required keys (empty if all required keys are present)
+
     """
     return get_env_loader().validate_adapter_config(adapter_name, config)

mcp_ticketer/core/exceptions.py

@@ -9,6 +9,7 @@ from .models import TicketState
 
 class MCPTicketerError(Exception):
     """Base exception for MCP Ticketer."""
+
     pass
 
 
@@ -19,14 +20,15 @@ class AdapterError(MCPTicketerError):
         self,
         message: str,
         adapter_name: str,
-        original_error: Optional[Exception] = None
+        original_error: Optional[Exception] = None,
     ):
         """Initialize adapter error.
-        
+
         Args:
             message: Error message
             adapter_name: Name of the adapter that raised the error
             original_error: Original exception that caused this error
+
         """
         super().__init__(message)
         self.adapter_name = adapter_name
@@ -42,6 +44,7 @@ class AdapterError(MCPTicketerError):
 
 class AuthenticationError(AdapterError):
     """Authentication failed with external service."""
+
     pass
 
 
@@ -53,15 +56,16 @@ class RateLimitError(AdapterError):
         message: str,
         adapter_name: str,
         retry_after: Optional[int] = None,
-        original_error: Optional[Exception] = None
+        original_error: Optional[Exception] = None,
     ):
         """Initialize rate limit error.
-        
+
         Args:
             message: Error message
             adapter_name: Name of the adapter
             retry_after: Seconds to wait before retrying
             original_error: Original exception
+
         """
         super().__init__(message, adapter_name, original_error)
         self.retry_after = retry_after
@@ -70,18 +74,14 @@ class RateLimitError(AdapterError):
 class ValidationError(MCPTicketerError):
     """Data validation error."""
 
-    def __init__(
-        self,
-        message: str,
-        field: Optional[str] = None,
-        value: Any = None
-    ):
+    def __init__(self, message: str, field: Optional[str] = None, value: Any = None):
         """Initialize validation error.
-        
+
         Args:
             message: Error message
             field: Field that failed validation
             value: Value that failed validation
+
         """
         super().__init__(message)
         self.field = field
@@ -99,29 +99,27 @@ class ValidationError(MCPTicketerError):
 
 class ConfigurationError(MCPTicketerError):
     """Configuration error."""
+
     pass
 
 
 class CacheError(MCPTicketerError):
     """Cache operation error."""
+
     pass
 
 
 class StateTransitionError(MCPTicketerError):
     """Invalid state transition."""
 
-    def __init__(
-        self,
-        message: str,
-        from_state: TicketState,
-        to_state: TicketState
-    ):
+    def __init__(self, message: str, from_state: TicketState, to_state: TicketState):
         """Initialize state transition error.
-        
+
         Args:
             message: Error message
             from_state: Current state
             to_state: Target state
+
         """
         super().__init__(message)
         self.from_state = from_state
@@ -134,19 +132,23 @@ class StateTransitionError(MCPTicketerError):
 
 class NetworkError(AdapterError):
     """Network-related error."""
+
     pass
 
 
 class TimeoutError(AdapterError):
     """Request timeout error."""
+
     pass
 
 
 class NotFoundError(AdapterError):
     """Resource not found error."""
+
     pass
 
 
 class PermissionError(AdapterError):
     """Permission denied error."""
+
     pass

mcp_ticketer/core/models.py

@@ -20,6 +20,7 @@ Example:
     ...     state=TicketState.IN_PROGRESS
     ... )
     >>> print(task.model_dump_json())
+
 """
 
 from datetime import datetime
@@ -42,6 +43,7 @@ class Priority(str, Enum):
         MEDIUM: Standard priority, default for most work
         HIGH: High priority, should be addressed soon
         CRITICAL: Critical priority, urgent work requiring immediate attention
+
     """
 
     LOW = "low"
@@ -66,6 +68,7 @@ class TicketType(str, Enum):
         ISSUE: Standard work items, the primary unit of work
         TASK: Sub-work items, smaller pieces of an issue
         SUBTASK: Alias for TASK for backward compatibility
+
     """
 
     EPIC = "epic"  # Strategic level (Projects in Linear, Milestones in GitHub)
@@ -101,6 +104,7 @@ class TicketState(str, Enum):
         WAITING: Work is paused waiting for external dependency
         BLOCKED: Work is blocked by an impediment
         CLOSED: Final state, work is closed/archived
+
     """
 
     OPEN = "open"
@@ -121,6 +125,7 @@ class TicketState(str, Enum):
 
         Note:
             CLOSED is a terminal state with no valid transitions
+
         """
         return {
             cls.OPEN: [cls.IN_PROGRESS, cls.WAITING, cls.BLOCKED, cls.CLOSED],
@@ -151,6 +156,7 @@ class TicketState(str, Enum):
             True
             >>> state.can_transition_to(TicketState.DONE)
             False
+
         """
         return target.value in self.valid_transitions().get(self, [])
 
@@ -183,6 +189,7 @@ class BaseTicket(BaseModel):
         ...     tags=["bug", "authentication"]
         ... )
         >>> ticket.state = TicketState.IN_PROGRESS
+
     """
 
     model_config = ConfigDict(use_enum_values=True)
@@ -228,6 +235,7 @@ class Epic(BaseTicket):
         ...     priority=Priority.HIGH
         ... )
         >>> epic.child_issues = ["ISSUE-123", "ISSUE-124"]
+
     """
 
     ticket_type: TicketType = Field(
@@ -245,6 +253,7 @@ class Epic(BaseTicket):
 
         Returns:
             Empty list (epics have no hierarchy constraints)
+
         """
         # Epics don't have parents in our hierarchy
         return []

mcp_ticketer/core/project_config.py

@@ -14,7 +14,7 @@ import os
 from dataclasses import asdict, dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional
 
 if TYPE_CHECKING:
     from .env_discovery import DiscoveryResult