mcp-ticketer 0.1.30__py3-none-any.whl → 1.2.11__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
 
 import yaml
 from pydantic import BaseModel, Field, field_validator, model_validator
@@ -27,27 +27,28 @@ 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:
@@ -56,7 +57,8 @@ class GitHubConfig(BaseAdapterConfig):
 
     @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:
@@ -65,7 +67,8 @@ class GitHubConfig(BaseAdapterConfig):
 
     @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:
@@ -77,16 +80,17 @@ 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:
@@ -95,7 +99,8 @@ class JiraConfig(BaseAdapterConfig):
 
     @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:
@@ -104,7 +109,8 @@ class JiraConfig(BaseAdapterConfig):
 
     @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:
@@ -116,14 +122,23 @@ 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: str
+    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) -> "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")
+        return self
+
     @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:
@@ -142,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
@@ -154,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
 
@@ -163,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
 
@@ -188,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)
 
@@ -203,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":
@@ -212,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
@@ -258,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:
@@ -283,6 +298,12 @@ class ConfigurationManager:
             # Load from first available config file
             config_data = self._load_config_file(self._config_file_paths[0])
             logger.info(f"Loaded configuration from: {self._config_file_paths[0]}")
+        else:
+            # No config file found - use empty config
+            config_data = {"adapters": {}, "default_adapter": None}
+
+        # Use saved configuration only - no automatic discovery
+        # Discovery should be done explicitly via 'mcp-ticketer init' or 'mcp-ticketer discover'
 
         # Parse adapter configurations
         if "adapters" in config_data:
@@ -290,13 +311,21 @@ class ConfigurationManager:
             for name, adapter_config in config_data["adapters"].items():
                 adapter_type = adapter_config.get("type", "").lower()
 
+                # If no type specified, try to infer from adapter name
+                if not adapter_type:
+                    adapter_type = name.lower()
+
                 if adapter_type == "github":
+                    adapter_config["type"] = "github"
                     parsed_adapters[name] = GitHubConfig(**adapter_config)
                 elif adapter_type == "jira":
+                    adapter_config["type"] = "jira"
                     parsed_adapters[name] = JiraConfig(**adapter_config)
                 elif adapter_type == "linear":
+                    adapter_config["type"] = "linear"
                     parsed_adapters[name] = LinearConfig(**adapter_config)
                 elif adapter_type == "aitrackdown":
+                    adapter_config["type"] = "aitrackdown"
                     parsed_adapters[name] = AITrackdownConfig(**adapter_config)
                 else:
                     logger.warning(
@@ -328,13 +357,94 @@ class ConfigurationManager:
             logger.error(f"Error loading config file {config_path}: {e}")
             return {}
 
+    def _discover_from_environment(self) -> dict[str, Any]:
+        """Discover configuration from environment variables."""
+        try:
+            from .env_discovery import EnvDiscovery
+
+            discovery = EnvDiscovery()
+            discovered = discovery.discover()
+
+            if not discovered.adapters:
+                logger.info("No adapters discovered from environment variables")
+                # Return minimal config with aitrackdown as fallback
+                return {
+                    "adapters": {
+                        "aitrackdown": {
+                            "type": "aitrackdown",
+                            "enabled": True,
+                            "base_path": str(
+                                Path.home() / ".mcp-ticketer" / ".aitrackdown"
+                            ),
+                        }
+                    },
+                    "default_adapter": "aitrackdown",
+                }
+
+            # Convert discovered adapters to config format
+            config_data: dict[str, Any] = {"adapters": {}, "default_adapter": None}
+
+            for adapter in discovered.adapters:
+                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"]
+
+                # Use adapter type as the key name
+                adapter_name = adapter.adapter_type
+                config_data["adapters"][adapter_name] = adapter_config
+
+                # Set first discovered adapter as default
+                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"
+            )
+            return config_data
+
+        except ImportError:
+            logger.warning(
+                "Environment discovery not available, using aitrackdown fallback"
+            )
+            return {
+                "adapters": {
+                    "aitrackdown": {
+                        "type": "aitrackdown",
+                        "enabled": True,
+                        "base_path": str(
+                            Path.home() / ".mcp-ticketer" / ".aitrackdown"
+                        ),
+                    }
+                },
+                "default_adapter": "aitrackdown",
+            }
+        except Exception as e:
+            logger.error(f"Environment discovery failed: {e}")
+            return {
+                "adapters": {
+                    "aitrackdown": {
+                        "type": "aitrackdown",
+                        "enabled": True,
+                        "base_path": str(
+                            Path.home() / ".mcp-ticketer" / ".aitrackdown"
+                        ),
+                    }
+                },
+                "default_adapter": "aitrackdown",
+            }
+
     def get_config(self) -> AppConfig:
         """Get the current configuration."""
         if self._config is None:
             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)
@@ -354,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()
@@ -389,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": {
@@ -436,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__)
@@ -30,8 +32,10 @@ LINEAR_KEY_PATTERNS = [
 
 LINEAR_TEAM_PATTERNS = [
     "LINEAR_TEAM_ID",
+    "LINEAR_TEAM_KEY",  # Added support for team key (e.g., "BTA")
     "LINEAR_TEAM",
     "MCP_TICKETER_LINEAR_TEAM_ID",
+    "MCP_TICKETER_LINEAR_TEAM_KEY",
 ]
 
 LINEAR_PROJECT_PATTERNS = [
@@ -123,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
@@ -134,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:
@@ -153,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.
@@ -210,7 +227,11 @@ class EnvDiscovery:
         return result
 
     def _load_env_files(self, result: DiscoveryResult) -> dict[str, str]:
-        """Load environment variables from files.
+        """Load environment variables from files and actual environment.
+
+        Priority order (highest to lowest):
+        1. .env files (highest priority)
+        2. Environment variables (lowest priority)
 
         Args:
             result: DiscoveryResult to update with found files
@@ -221,12 +242,36 @@ class EnvDiscovery:
         """
         merged_env: dict[str, str] = {}
 
-        # Load files in reverse order (lowest priority first)
+        # 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:
+            result.env_files_found.append("environment")
+            logger.debug(f"Loaded {len(actual_env)} variables from environment")
+
+        # Load files in reverse order (higher priority than environment)
         for env_file in reversed(self.ENV_FILE_ORDER):
             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)
@@ -240,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:
@@ -258,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:
@@ -282,13 +327,19 @@ class EnvDiscovery:
         missing_fields: list[str] = []
         confidence = 0.6  # Has API key
 
-        # Extract team ID (recommended but not required)
-        team_id = self._find_key_value(env_vars, LINEAR_TEAM_PATTERNS)
-        if team_id:
-            config["team_id"] = team_id
+        # Extract team identifier (either team_id or team_key is required)
+        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:
+                # Looks like a UUID (team_id)
+                config["team_id"] = team_identifier
+            else:
+                # Looks like a short key (team_key)
+                config["team_key"] = team_identifier
             confidence += 0.3
         else:
-            missing_fields.append("team_id (recommended)")
+            missing_fields.append("team_id or team_key (required)")
 
         # Extract project ID (optional)
         project_id = self._find_key_value(env_vars, LINEAR_PROJECT_PATTERNS)
@@ -306,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:
@@ -365,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:
@@ -421,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:
@@ -434,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,
         }
@@ -448,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,
@@ -573,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)