mcp-ticketer 0.2.0__py3-none-any.whl → 2.2.9__py3-none-any.whl

mcp_ticketer/core/config.py

@@ -6,7 +6,7 @@ import os
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any, Optional, cast
 
 import yaml
 from pydantic import BaseModel, Field, field_validator, model_validator
@@ -27,103 +27,109 @@ class BaseAdapterConfig(BaseModel):
     """Base configuration for all adapters."""
 
     type: AdapterType
-    name: Optional[str] = None
+    name: str | None = None
     enabled: bool = True
     timeout: float = 30.0
     max_retries: int = 3
-    rate_limit: Optional[dict[str, Any]] = None
+    rate_limit: dict[str, Any] | None = None
 
 
 class GitHubConfig(BaseAdapterConfig):
     """GitHub adapter configuration."""
 
     type: AdapterType = AdapterType.GITHUB
-    token: Optional[str] = Field(None, env="GITHUB_TOKEN")
-    owner: Optional[str] = Field(None, env="GITHUB_OWNER")
-    repo: Optional[str] = Field(None, env="GITHUB_REPO")
+    token: str | None = Field(default=None)
+    owner: str | None = Field(default=None)
+    repo: str | None = Field(default=None)
     api_url: str = "https://api.github.com"
     use_projects_v2: bool = False
-    custom_priority_scheme: Optional[dict[str, list[str]]] = None
+    custom_priority_scheme: dict[str, list[str]] | None = None
 
     @field_validator("token", mode="before")
     @classmethod
-    def validate_token(cls, v):
+    def validate_token(cls, v: Any) -> str:
+        """Validate GitHub token from config or environment."""
         if not v:
             v = os.getenv("GITHUB_TOKEN")
         if not v:
             raise ValueError("GitHub token is required")
-        return v
+        return cast(str, v)
 
     @field_validator("owner", mode="before")
     @classmethod
-    def validate_owner(cls, v):
+    def validate_owner(cls, v: Any) -> str:
+        """Validate GitHub repository owner from config or environment."""
         if not v:
             v = os.getenv("GITHUB_OWNER")
         if not v:
             raise ValueError("GitHub owner is required")
-        return v
+        return cast(str, v)
 
     @field_validator("repo", mode="before")
     @classmethod
-    def validate_repo(cls, v):
+    def validate_repo(cls, v: Any) -> str:
+        """Validate GitHub repository name from config or environment."""
         if not v:
             v = os.getenv("GITHUB_REPO")
         if not v:
             raise ValueError("GitHub repo is required")
-        return v
+        return cast(str, v)
 
 
 class JiraConfig(BaseAdapterConfig):
     """JIRA adapter configuration."""
 
     type: AdapterType = AdapterType.JIRA
-    server: Optional[str] = Field(None, env="JIRA_SERVER")
-    email: Optional[str] = Field(None, env="JIRA_EMAIL")
-    api_token: Optional[str] = Field(None, env="JIRA_API_TOKEN")
-    project_key: Optional[str] = Field(None, env="JIRA_PROJECT_KEY")
+    server: str | None = Field(default=None)
+    email: str | None = Field(default=None)
+    api_token: str | None = Field(default=None)
+    project_key: str | None = Field(default=None)
     cloud: bool = True
     verify_ssl: bool = True
 
     @field_validator("server", mode="before")
     @classmethod
-    def validate_server(cls, v):
+    def validate_server(cls, v: Any) -> str:
+        """Validate JIRA server URL from config or environment."""
         if not v:
             v = os.getenv("JIRA_SERVER")
         if not v:
             raise ValueError("JIRA server URL is required")
-        return v.rstrip("/")
+        return cast(str, v).rstrip("/")
 
     @field_validator("email", mode="before")
     @classmethod
-    def validate_email(cls, v):
+    def validate_email(cls, v: Any) -> str:
+        """Validate JIRA user email from config or environment."""
         if not v:
             v = os.getenv("JIRA_EMAIL")
         if not v:
             raise ValueError("JIRA email is required")
-        return v
+        return cast(str, v)
 
     @field_validator("api_token", mode="before")
     @classmethod
-    def validate_api_token(cls, v):
+    def validate_api_token(cls, v: Any) -> str:
+        """Validate JIRA API token from config or environment."""
         if not v:
             v = os.getenv("JIRA_API_TOKEN")
         if not v:
             raise ValueError("JIRA API token is required")
-        return v
+        return cast(str, v)
 
 
 class LinearConfig(BaseAdapterConfig):
     """Linear adapter configuration."""
 
     type: AdapterType = AdapterType.LINEAR
-    api_key: Optional[str] = Field(None, env="LINEAR_API_KEY")
-    workspace: Optional[str] = None
-    team_key: Optional[str] = None  # Short team key like "BTA"
-    team_id: Optional[str] = None   # UUID team identifier
+    api_key: str | None = Field(default=None)
+    workspace: str | None = None
+    team_key: str | None = None  # Short team key like "BTA"
+    team_id: str | None = None  # UUID team identifier
     api_url: str = "https://api.linear.app/graphql"
 
     @model_validator(mode="after")
-    def validate_team_identifier(self):
+    def validate_team_identifier(self) -> "LinearConfig":
         """Ensure either team_key or team_id is provided."""
         if not self.team_key and not self.team_id:
             raise ValueError("Either team_key or team_id is required")
@@ -131,12 +137,13 @@ class LinearConfig(BaseAdapterConfig):
 
     @field_validator("api_key", mode="before")
     @classmethod
-    def validate_api_key(cls, v):
+    def validate_api_key(cls, v: Any) -> str:
+        """Validate Linear API key from config or environment."""
         if not v:
             v = os.getenv("LINEAR_API_KEY")
         if not v:
             raise ValueError("Linear API key is required")
-        return v
+        return cast(str, v)
 
 
 class AITrackdownConfig(BaseAdapterConfig):
@@ -150,7 +157,7 @@ class QueueConfig(BaseModel):
     """Queue configuration."""
 
     provider: str = "sqlite"
-    connection_string: Optional[str] = None
+    connection_string: str | None = None
     batch_size: int = 10
     max_concurrent: int = 5
     retry_attempts: int = 3
@@ -162,7 +169,7 @@ class LoggingConfig(BaseModel):
 
     level: str = "INFO"
     format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    file: Optional[str] = None
+    file: str | None = None
     max_size: str = "10MB"
     backup_count: int = 5
 
@@ -171,15 +178,15 @@ class AppConfig(BaseModel):
     """Main application configuration."""
 
     adapters: dict[
-        str, Union[GitHubConfig, JiraConfig, LinearConfig, AITrackdownConfig]
+        str, GitHubConfig | JiraConfig | LinearConfig | AITrackdownConfig
     ] = {}
     queue: QueueConfig = QueueConfig()
     logging: LoggingConfig = LoggingConfig()
     cache_ttl: int = 300  # Cache TTL in seconds
-    default_adapter: Optional[str] = None
+    default_adapter: str | None = None
 
     @model_validator(mode="after")
-    def validate_adapters(self):
+    def validate_adapters(self) -> "AppConfig":
         """Validate adapter configurations."""
         adapters = self.adapters
 
@@ -196,7 +203,7 @@ class AppConfig(BaseModel):
 
         return self
 
-    def get_adapter_config(self, adapter_name: str) -> Optional[BaseAdapterConfig]:
+    def get_adapter_config(self, adapter_name: str) -> BaseAdapterConfig | None:
         """Get configuration for a specific adapter."""
         return self.adapters.get(adapter_name)
 
@@ -211,7 +218,7 @@ class ConfigurationManager:
     """Centralized configuration management with caching and validation."""
 
     _instance: Optional["ConfigurationManager"] = None
-    _config: Optional[AppConfig] = None
+    _config: AppConfig | None = None
     _config_file_paths: list[Path] = []
 
     def __new__(cls) -> "ConfigurationManager":
@@ -220,7 +227,7 @@ class ConfigurationManager:
             cls._instance = super().__new__(cls)
         return cls._instance
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize configuration manager."""
         if not hasattr(self, "_initialized"):
             self._initialized = True
@@ -266,7 +273,7 @@ class ConfigurationManager:
             logger.debug("No project-local config files found, will use defaults")
 
     @lru_cache(maxsize=1)
-    def load_config(self, config_file: Optional[Union[str, Path]] = None) -> AppConfig:
+    def load_config(self, config_file: str | Path | None = None) -> AppConfig:
         """Load and validate configuration from file and environment.
 
         Args:
@@ -336,16 +343,16 @@ class ConfigurationManager:
         try:
             with open(config_path, encoding="utf-8") as file:
                 if config_path.suffix.lower() in [".yaml", ".yml"]:
-                    return yaml.safe_load(file) or {}
+                    return cast(dict[str, Any], yaml.safe_load(file) or {})
                 elif config_path.suffix.lower() == ".json":
-                    return json.load(file)
+                    return cast(dict[str, Any], json.load(file))
                 else:
                     # Try YAML first, then JSON
                     content = file.read()
                     try:
-                        return yaml.safe_load(content) or {}
+                        return cast(dict[str, Any], yaml.safe_load(content) or {})
                     except yaml.YAMLError:
-                        return json.loads(content)
+                        return cast(dict[str, Any], json.loads(content))
         except Exception as e:
             logger.error(f"Error loading config file {config_path}: {e}")
             return {}
@@ -366,30 +373,26 @@ class ConfigurationManager:
                         "aitrackdown": {
                             "type": "aitrackdown",
                             "enabled": True,
-                            "base_path": str(Path.home() / ".mcp-ticketer" / ".aitrackdown")
+                            "base_path": str(
+                                Path.home() / ".mcp-ticketer" / ".aitrackdown"
+                            ),
                         }
                     },
-                    "default_adapter": "aitrackdown"
+                    "default_adapter": "aitrackdown",
                 }
 
             # Convert discovered adapters to config format
-            config_data = {
-                "adapters": {},
-                "default_adapter": None
-            }
+            config_data: dict[str, Any] = {"adapters": {}, "default_adapter": None}
 
             for adapter in discovered.adapters:
-                adapter_config = {
-                    "type": adapter.adapter_type,
-                    "enabled": True
-                }
+                adapter_config = {"type": adapter.adapter_type, "enabled": True}
 
                 # Add adapter-specific configuration from discovered config
                 adapter_config.update(adapter.config)
 
                 # Ensure type is set correctly (remove 'adapter' key if present)
-                if 'adapter' in adapter_config:
-                    del adapter_config['adapter']
+                if "adapter" in adapter_config:
+                    del adapter_config["adapter"]
 
                 # Use adapter type as the key name
                 adapter_name = adapter.adapter_type
@@ -399,20 +402,26 @@ class ConfigurationManager:
                 if config_data["default_adapter"] is None:
                     config_data["default_adapter"] = adapter.adapter_type
 
-            logger.info(f"Discovered {len(config_data['adapters'])} adapter(s) from environment")
+            logger.info(
+                f"Discovered {len(config_data['adapters'])} adapter(s) from environment"
+            )
             return config_data
 
         except ImportError:
-            logger.warning("Environment discovery not available, using aitrackdown fallback")
+            logger.warning(
+                "Environment discovery not available, using aitrackdown fallback"
+            )
             return {
                 "adapters": {
                     "aitrackdown": {
                         "type": "aitrackdown",
                         "enabled": True,
-                        "base_path": str(Path.home() / ".mcp-ticketer" / ".aitrackdown")
+                        "base_path": str(
+                            Path.home() / ".mcp-ticketer" / ".aitrackdown"
+                        ),
                     }
                 },
-                "default_adapter": "aitrackdown"
+                "default_adapter": "aitrackdown",
             }
         except Exception as e:
             logger.error(f"Environment discovery failed: {e}")
@@ -421,10 +430,12 @@ class ConfigurationManager:
                     "aitrackdown": {
                         "type": "aitrackdown",
                         "enabled": True,
-                        "base_path": str(Path.home() / ".mcp-ticketer" / ".aitrackdown")
+                        "base_path": str(
+                            Path.home() / ".mcp-ticketer" / ".aitrackdown"
+                        ),
                     }
                 },
-                "default_adapter": "aitrackdown"
+                "default_adapter": "aitrackdown",
             }
 
     def get_config(self) -> AppConfig:
@@ -433,7 +444,7 @@ class ConfigurationManager:
             return self.load_config()
         return self._config
 
-    def get_adapter_config(self, adapter_name: str) -> Optional[BaseAdapterConfig]:
+    def get_adapter_config(self, adapter_name: str) -> BaseAdapterConfig | None:
         """Get configuration for a specific adapter."""
         config = self.get_config()
         return config.get_adapter_config(adapter_name)
@@ -453,9 +464,7 @@ class ConfigurationManager:
         config = self.get_config()
         return config.logging
 
-    def reload_config(
-        self, config_file: Optional[Union[str, Path]] = None
-    ) -> AppConfig:
+    def reload_config(self, config_file: str | Path | None = None) -> AppConfig:
         """Reload configuration from file."""
         # Clear cache
         self.load_config.cache_clear()
@@ -488,7 +497,7 @@ class ConfigurationManager:
         self._config_cache[key] = value
         return value
 
-    def create_sample_config(self, output_path: Union[str, Path]) -> None:
+    def create_sample_config(self, output_path: str | Path) -> None:
         """Create a sample configuration file."""
         sample_config = {
             "adapters": {
@@ -535,11 +544,11 @@ def get_config() -> AppConfig:
     return config_manager.get_config()
 
 
-def get_adapter_config(adapter_name: str) -> Optional[BaseAdapterConfig]:
+def get_adapter_config(adapter_name: str) -> BaseAdapterConfig | None:
     """Get configuration for a specific adapter."""
     return config_manager.get_adapter_config(adapter_name)
 
 
-def reload_config(config_file: Optional[Union[str, Path]] = None) -> AppConfig:
+def reload_config(config_file: str | Path | None = None) -> AppConfig:
     """Reload the global configuration."""
     return config_manager.reload_config(config_file)

mcp_ticketer/core/env_discovery.py

@@ -6,15 +6,17 @@ environment files, including:
 - Support for multiple naming conventions
 - Project information extraction
 - Security validation
+- 1Password CLI integration for secret references
 """
 
 import logging
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from dotenv import dotenv_values
 
+from .onepassword_secrets import OnePasswordConfig, OnePasswordSecretsLoader
 from .project_config import AdapterType
 
 logger = logging.getLogger(__name__)
@@ -125,7 +127,7 @@ class DiscoveryResult:
     warnings: list[str] = field(default_factory=list)
     env_files_found: list[str] = field(default_factory=list)
 
-    def get_primary_adapter(self) -> Optional[DiscoveredAdapter]:
+    def get_primary_adapter(self) -> DiscoveredAdapter | None:
         """Get the adapter with highest confidence and completeness."""
         if not self.adapters:
             return None
@@ -136,7 +138,7 @@ class DiscoveryResult:
         )
         return sorted_adapters[0]
 
-    def get_adapter_by_type(self, adapter_type: str) -> Optional[DiscoveredAdapter]:
+    def get_adapter_by_type(self, adapter_type: str) -> DiscoveredAdapter | None:
         """Get discovered adapter by type."""
         for adapter in self.adapters:
             if adapter.adapter_type == adapter_type:
@@ -155,14 +157,27 @@ class EnvDiscovery:
         ".env.development",
     ]
 
-    def __init__(self, project_path: Optional[Path] = None):
+    def __init__(
+        self,
+        project_path: Path | None = None,
+        enable_1password: bool = True,
+        onepassword_config: OnePasswordConfig | None = None,
+    ):
         """Initialize discovery.
 
         Args:
             project_path: Path to project root (defaults to cwd)
+            enable_1password: Enable 1Password CLI integration for secret resolution
+            onepassword_config: Configuration for 1Password integration
 
         """
         self.project_path = project_path or Path.cwd()
+        self.enable_1password = enable_1password
+        self.op_loader = (
+            OnePasswordSecretsLoader(onepassword_config or OnePasswordConfig())
+            if enable_1password
+            else None
+        )
 
     def discover(self) -> DiscoveryResult:
         """Discover adapter configurations from environment files.
@@ -229,6 +244,7 @@ class EnvDiscovery:
 
         # First, load from actual environment variables (lowest priority)
         import os
+
         actual_env = {k: v for k, v in os.environ.items() if v}
         merged_env.update(actual_env)
         if actual_env:
@@ -240,7 +256,22 @@ class EnvDiscovery:
             file_path = self.project_path / env_file
             if file_path.exists():
                 try:
-                    env_vars = dotenv_values(file_path)
+                    # Check if file contains 1Password references and use op loader if available
+                    if self.op_loader and self.enable_1password:
+                        content = file_path.read_text(encoding="utf-8")
+                        if "op://" in content:
+                            logger.info(
+                                f"Detected 1Password references in {env_file}, "
+                                "attempting to resolve..."
+                            )
+                            env_vars = self.op_loader.load_secrets_from_env_file(
+                                file_path
+                            )
+                        else:
+                            env_vars = dotenv_values(file_path)
+                    else:
+                        env_vars = dotenv_values(file_path)
+
                     # Filter out None values
                     env_vars = {k: v for k, v in env_vars.items() if v is not None}
                     merged_env.update(env_vars)
@@ -254,7 +285,7 @@ class EnvDiscovery:
 
     def _find_key_value(
         self, env_vars: dict[str, str], patterns: list[str]
-    ) -> Optional[str]:
+    ) -> str | None:
         """Find first matching key value from patterns.
 
         Args:
@@ -272,7 +303,7 @@ class EnvDiscovery:
 
     def _detect_linear(
         self, env_vars: dict[str, str], found_in: str
-    ) -> Optional[DiscoveredAdapter]:
+    ) -> DiscoveredAdapter | None:
         """Detect Linear adapter configuration.
 
         Args:
@@ -300,7 +331,7 @@ class EnvDiscovery:
         team_identifier = self._find_key_value(env_vars, LINEAR_TEAM_PATTERNS)
         if team_identifier:
             # Determine if it's a team_id (UUID format) or team_key (short string)
-            if len(team_identifier) > 20 and '-' in team_identifier:
+            if len(team_identifier) > 20 and "-" in team_identifier:
                 # Looks like a UUID (team_id)
                 config["team_id"] = team_identifier
             else:
@@ -326,7 +357,7 @@ class EnvDiscovery:
 
     def _detect_github(
         self, env_vars: dict[str, str], found_in: str
-    ) -> Optional[DiscoveredAdapter]:
+    ) -> DiscoveredAdapter | None:
         """Detect GitHub adapter configuration.
 
         Args:
@@ -385,7 +416,7 @@ class EnvDiscovery:
 
     def _detect_jira(
         self, env_vars: dict[str, str], found_in: str
-    ) -> Optional[DiscoveredAdapter]:
+    ) -> DiscoveredAdapter | None:
         """Detect JIRA adapter configuration.
 
         Args:
@@ -441,7 +472,7 @@ class EnvDiscovery:
 
     def _detect_aitrackdown(
         self, env_vars: dict[str, str], found_in: str
-    ) -> Optional[DiscoveredAdapter]:
+    ) -> DiscoveredAdapter | None:
         """Detect AITrackdown adapter configuration.
 
         Args:
@@ -454,11 +485,32 @@ class EnvDiscovery:
         """
         base_path = self._find_key_value(env_vars, AITRACKDOWN_PATH_PATTERNS)
 
-        # Also check if .aitrackdown directory exists
+        # Check for explicit MCP_TICKETER_ADAPTER setting
+        explicit_adapter = env_vars.get("MCP_TICKETER_ADAPTER")
+        if explicit_adapter and explicit_adapter != "aitrackdown":
+            # If another adapter is explicitly set, don't detect aitrackdown
+            return None
+
+        # Check if .aitrackdown directory exists
         aitrackdown_dir = self.project_path / ".aitrackdown"
+
+        # Only detect aitrackdown if:
+        # 1. There's an explicit base_path setting, OR
+        # 2. There's a .aitrackdown directory AND no other adapter variables are present
+        has_other_adapter_vars = (
+            any(key.startswith("LINEAR_") for key in env_vars)
+            or any(key.startswith("GITHUB_") for key in env_vars)
+            or any(key.startswith("JIRA_") for key in env_vars)
+        )
+
         if not base_path and not aitrackdown_dir.exists():
             return None
 
+        if not base_path and has_other_adapter_vars:
+            # Don't detect aitrackdown if other adapter variables are present
+            # unless explicitly configured
+            return None
+
         config: dict[str, Any] = {
             "adapter": AdapterType.AITRACKDOWN.value,
         }
@@ -468,8 +520,15 @@ class EnvDiscovery:
         else:
             config["base_path"] = ".aitrackdown"
 
-        # AITrackdown has no required external credentials
-        confidence = 1.0 if aitrackdown_dir.exists() else 0.7
+        # Lower confidence when other adapter variables are present
+        if has_other_adapter_vars:
+            confidence = 0.3  # Low confidence when other adapters are configured
+        elif base_path:
+            confidence = 1.0  # High confidence when explicitly configured
+        elif aitrackdown_dir.exists():
+            confidence = 0.8  # Medium confidence when directory exists
+        else:
+            confidence = 0.5  # Low confidence as fallback
 
         return DiscoveredAdapter(
             adapter_type=AdapterType.AITRACKDOWN.value,
@@ -593,8 +652,8 @@ class EnvDiscovery:
         return warnings
 
 
-def discover_config(project_path: Optional[Path] = None) -> DiscoveryResult:
-    """Convenience function to discover configuration.
+def discover_config(project_path: Path | None = None) -> DiscoveryResult:
+    """Discover configuration from environment files.
 
     Args:
         project_path: Path to project root (defaults to cwd)