mcp-ticketer 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

mcp_ticketer/core/project_config.py

@@ -8,19 +8,20 @@ This module provides a comprehensive configuration system that supports:
 - Hybrid mode for multi-platform synchronization
 """
 
-import os
 import json
 import logging
-from typing import Dict, Any, Optional, List
-from pathlib import Path
-from dataclasses import dataclass, field, asdict
+import os
+from dataclasses import asdict, dataclass, field
 from enum import Enum
+from pathlib import Path
+from typing import Any, Optional
 
 logger = logging.getLogger(__name__)
 
 
 class AdapterType(str, Enum):
     """Supported adapter types."""
+
     AITRACKDOWN = "aitrackdown"
     LINEAR = "linear"
     JIRA = "jira"
@@ -29,14 +30,16 @@ class AdapterType(str, Enum):
 
 class SyncStrategy(str, Enum):
     """Hybrid mode synchronization strategies."""
+
     PRIMARY_SOURCE = "primary_source"  # One adapter is source of truth
-    BIDIRECTIONAL = "bidirectional"    # Two-way sync between adapters
-    MIRROR = "mirror"                  # Clone tickets across all adapters
+    BIDIRECTIONAL = "bidirectional"  # Two-way sync between adapters
+    MIRROR = "mirror"  # Clone tickets across all adapters
 
 
 @dataclass
 class AdapterConfig:
     """Base configuration for a single adapter instance."""
+
     adapter: str
     enabled: bool = True
 
@@ -66,9 +69,9 @@ class AdapterConfig:
     project_id: Optional[str] = None
 
     # Additional adapter-specific configuration
-    additional_config: Dict[str, Any] = field(default_factory=dict)
+    additional_config: dict[str, Any] = field(default_factory=dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary, filtering None values."""
         result = {}
         for key, value in asdict(self).items():
@@ -77,13 +80,25 @@ class AdapterConfig:
         return result
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'AdapterConfig':
+    def from_dict(cls, data: dict[str, Any]) -> "AdapterConfig":
         """Create from dictionary."""
         # Extract known fields
         known_fields = {
-            'adapter', 'enabled', 'api_key', 'token', 'team_id', 'team_key',
-            'workspace', 'server', 'email', 'api_token', 'project_key',
-            'owner', 'repo', 'base_path', 'project_id'
+            "adapter",
+            "enabled",
+            "api_key",
+            "token",
+            "team_id",
+            "team_key",
+            "workspace",
+            "server",
+            "email",
+            "api_token",
+            "project_key",
+            "owner",
+            "repo",
+            "base_path",
+            "project_id",
         }
 
         kwargs = {}
@@ -92,32 +107,33 @@ class AdapterConfig:
         for key, value in data.items():
             if key in known_fields:
                 kwargs[key] = value
-            elif key != 'additional_config':
+            elif key != "additional_config":
                 additional[key] = value
 
         # Merge explicit additional_config
-        if 'additional_config' in data:
-            additional.update(data['additional_config'])
+        if "additional_config" in data:
+            additional.update(data["additional_config"])
 
-        kwargs['additional_config'] = additional
+        kwargs["additional_config"] = additional
         return cls(**kwargs)
 
 
 @dataclass
 class ProjectConfig:
     """Configuration for a specific project."""
+
     adapter: str
     api_key: Optional[str] = None
     project_id: Optional[str] = None
     team_id: Optional[str] = None
-    additional_config: Dict[str, Any] = field(default_factory=dict)
+    additional_config: dict[str, Any] = field(default_factory=dict)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary."""
         return {k: v for k, v in asdict(self).items() if v is not None}
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'ProjectConfig':
+    def from_dict(cls, data: dict[str, Any]) -> "ProjectConfig":
         """Create from dictionary."""
         return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
 
@@ -125,51 +141,51 @@ class ProjectConfig:
 @dataclass
 class HybridConfig:
     """Configuration for hybrid mode (multi-adapter sync)."""
+
     enabled: bool = False
-    adapters: List[str] = field(default_factory=list)
+    adapters: list[str] = field(default_factory=list)
     primary_adapter: Optional[str] = None
     sync_strategy: SyncStrategy = SyncStrategy.PRIMARY_SOURCE
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary."""
         result = asdict(self)
-        result['sync_strategy'] = self.sync_strategy.value
+        result["sync_strategy"] = self.sync_strategy.value
         return result
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'HybridConfig':
+    def from_dict(cls, data: dict[str, Any]) -> "HybridConfig":
         """Create from dictionary."""
         data = data.copy()
-        if 'sync_strategy' in data:
-            data['sync_strategy'] = SyncStrategy(data['sync_strategy'])
+        if "sync_strategy" in data:
+            data["sync_strategy"] = SyncStrategy(data["sync_strategy"])
         return cls(**data)
 
 
 @dataclass
 class TicketerConfig:
     """Complete ticketer configuration with hierarchical resolution."""
+
     default_adapter: str = "aitrackdown"
-    project_configs: Dict[str, ProjectConfig] = field(default_factory=dict)
-    adapters: Dict[str, AdapterConfig] = field(default_factory=dict)
+    project_configs: dict[str, ProjectConfig] = field(default_factory=dict)
+    adapters: dict[str, AdapterConfig] = field(default_factory=dict)
     hybrid_mode: Optional[HybridConfig] = None
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "default_adapter": self.default_adapter,
             "project_configs": {
-                path: config.to_dict()
-                for path, config in self.project_configs.items()
+                path: config.to_dict() for path, config in self.project_configs.items()
             },
             "adapters": {
-                name: config.to_dict()
-                for name, config in self.adapters.items()
+                name: config.to_dict() for name, config in self.adapters.items()
             },
-            "hybrid_mode": self.hybrid_mode.to_dict() if self.hybrid_mode else None
+            "hybrid_mode": self.hybrid_mode.to_dict() if self.hybrid_mode else None,
         }
 
     @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'TicketerConfig':
+    def from_dict(cls, data: dict[str, Any]) -> "TicketerConfig":
         """Create from dictionary."""
         # Parse project configs
         project_configs = {}
@@ -192,7 +208,7 @@ class TicketerConfig:
             default_adapter=data.get("default_adapter", "aitrackdown"),
             project_configs=project_configs,
             adapters=adapters,
-            hybrid_mode=hybrid_mode
+            hybrid_mode=hybrid_mode,
         )
 
 
@@ -200,11 +216,12 @@ class ConfigValidator:
     """Validate adapter configurations."""
 
     @staticmethod
-    def validate_linear_config(config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate_linear_config(config: dict[str, Any]) -> tuple[bool, Optional[str]]:
         """Validate Linear adapter configuration.
 
         Returns:
             Tuple of (is_valid, error_message)
+
         """
         required = ["api_key"]
         for field in required:
@@ -213,16 +230,20 @@ class ConfigValidator:
 
         # Require either team_key or team_id (team_id is preferred)
         if not config.get("team_key") and not config.get("team_id"):
-            return False, "Linear config requires either team_key (short key like 'BTA') or team_id (UUID)"
+            return (
+                False,
+                "Linear config requires either team_key (short key like 'BTA') or team_id (UUID)",
+            )
 
         return True, None
 
     @staticmethod
-    def validate_github_config(config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate_github_config(config: dict[str, Any]) -> tuple[bool, Optional[str]]:
         """Validate GitHub adapter configuration.
 
         Returns:
             Tuple of (is_valid, error_message)
+
         """
         # token or api_key (aliases)
         has_token = config.get("token") or config.get("api_key")
@@ -246,11 +267,12 @@ class ConfigValidator:
         return True, None
 
     @staticmethod
-    def validate_jira_config(config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate_jira_config(config: dict[str, Any]) -> tuple[bool, Optional[str]]:
         """Validate JIRA adapter configuration.
 
         Returns:
             Tuple of (is_valid, error_message)
+
         """
         required = ["server", "email", "api_token"]
         for field in required:
@@ -265,18 +287,23 @@ class ConfigValidator:
         return True, None
 
     @staticmethod
-    def validate_aitrackdown_config(config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate_aitrackdown_config(
+        config: dict[str, Any],
+    ) -> tuple[bool, Optional[str]]:
         """Validate AITrackdown adapter configuration.
 
         Returns:
             Tuple of (is_valid, error_message)
+
         """
         # AITrackdown has minimal requirements
         # base_path is optional (defaults to .aitrackdown)
         return True, None
 
     @classmethod
-    def validate(cls, adapter_type: str, config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+    def validate(
+        cls, adapter_type: str, config: dict[str, Any]
+    ) -> tuple[bool, Optional[str]]:
         """Validate configuration for any adapter type.
 
         Args:
@@ -285,6 +312,7 @@ class ConfigValidator:
 
         Returns:
             Tuple of (is_valid, error_message)
+
         """
         validators = {
             AdapterType.LINEAR.value: cls.validate_linear_config,
@@ -303,47 +331,56 @@ class ConfigValidator:
 class ConfigResolver:
     """Resolve configuration from multiple sources with hierarchical precedence.
 
+    SECURITY: This class ONLY reads from project-local configurations
+    to prevent configuration leakage across projects. It will NEVER read
+    from user home directory or system-wide locations.
+
     Resolution order (highest to lowest priority):
     1. CLI overrides
     2. Environment variables
     3. Project-specific config (.mcp-ticketer/config.json)
     4. Auto-discovered .env files
-    5. Global config (~/.mcp-ticketer/config.json)
+    5. Default to aitrackdown adapter
     """
 
-    # Global config location
-    GLOBAL_CONFIG_PATH = Path.home() / ".mcp-ticketer" / "config.json"
-
-    # Project config location (relative to project root)
+    # Project config location (relative to project root) - PROJECT-LOCAL ONLY
     PROJECT_CONFIG_SUBPATH = ".mcp-ticketer" / Path("config.json")
 
-    def __init__(self, project_path: Optional[Path] = None, enable_env_discovery: bool = True):
+    def __init__(
+        self, project_path: Optional[Path] = None, enable_env_discovery: bool = True
+    ):
         """Initialize config resolver.
 
         Args:
             project_path: Path to project root (defaults to cwd)
             enable_env_discovery: Enable auto-discovery from .env files (default: True)
+
         """
         self.project_path = project_path or Path.cwd()
         self.enable_env_discovery = enable_env_discovery
-        self._global_config: Optional[TicketerConfig] = None
         self._project_config: Optional[TicketerConfig] = None
-        self._discovered_config: Optional['DiscoveryResult'] = None
+        self._discovered_config: Optional[DiscoveryResult] = None
 
     def load_global_config(self) -> TicketerConfig:
-        """Load global configuration from ~/.mcp-ticketer/config.json."""
-        if self.GLOBAL_CONFIG_PATH.exists():
-            try:
-                with open(self.GLOBAL_CONFIG_PATH, 'r') as f:
-                    data = json.load(f)
-                return TicketerConfig.from_dict(data)
-            except Exception as e:
-                logger.error(f"Failed to load global config: {e}")
+        """Load default configuration (global config loading removed for security).
 
-        # Return default config
-        return TicketerConfig()
+        DEPRECATED: Global config loading has been removed for security reasons.
+        This method now only returns default configuration.
+
+        Returns:
+            Default TicketerConfig with aitrackdown adapter
 
-    def load_project_config(self, project_path: Optional[Path] = None) -> Optional[TicketerConfig]:
+        """
+        logger.info("Global config loading disabled for security, using defaults")
+        # Return default config with aitrackdown adapter
+        default_config = TicketerConfig()
+        if not default_config.default_adapter:
+            default_config.default_adapter = "aitrackdown"
+        return default_config
+
+    def load_project_config(
+        self, project_path: Optional[Path] = None
+    ) -> Optional[TicketerConfig]:
         """Load project-specific configuration.
 
         Args:
@@ -351,13 +388,14 @@ class ConfigResolver:
 
         Returns:
             Project config if exists, None otherwise
+
         """
         proj_path = project_path or self.project_path
         config_path = proj_path / self.PROJECT_CONFIG_SUBPATH
 
         if config_path.exists():
             try:
-                with open(config_path, 'r') as f:
+                with open(config_path) as f:
                     data = json.load(f)
                 return TicketerConfig.from_dict(data)
             except Exception as e:
@@ -366,36 +404,46 @@ class ConfigResolver:
         return None
 
     def save_global_config(self, config: TicketerConfig) -> None:
-        """Save global configuration.
+        """Save configuration to project-local location (global config disabled).
+
+        DEPRECATED: Global config saving has been removed for security reasons.
+        This method now saves to project-local config instead.
 
         Args:
             config: Configuration to save
+
         """
-        self.GLOBAL_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.GLOBAL_CONFIG_PATH, 'w') as f:
-            json.dump(config.to_dict(), f, indent=2)
-        logger.info(f"Saved global config to {self.GLOBAL_CONFIG_PATH}")
+        logger.warning(
+            "save_global_config is deprecated and now saves to project-local config. "
+            "Use save_project_config instead."
+        )
+        # Save to project config instead
+        self.save_project_config(config)
 
-    def save_project_config(self, config: TicketerConfig, project_path: Optional[Path] = None) -> None:
+    def save_project_config(
+        self, config: TicketerConfig, project_path: Optional[Path] = None
+    ) -> None:
         """Save project-specific configuration.
 
         Args:
             config: Configuration to save
             project_path: Path to project root (defaults to self.project_path)
+
         """
         proj_path = project_path or self.project_path
         config_path = proj_path / self.PROJECT_CONFIG_SUBPATH
 
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(config_path, 'w') as f:
+        with open(config_path, "w") as f:
             json.dump(config.to_dict(), f, indent=2)
         logger.info(f"Saved project config to {config_path}")
 
-    def get_discovered_config(self) -> Optional['DiscoveryResult']:
+    def get_discovered_config(self) -> Optional["DiscoveryResult"]:
         """Get auto-discovered configuration from .env files.
 
         Returns:
             DiscoveryResult if env discovery is enabled, None otherwise
+
         """
         if not self.enable_env_discovery:
             return None
@@ -403,6 +451,7 @@ class ConfigResolver:
         if self._discovered_config is None:
             # Import here to avoid circular dependency
             from .env_discovery import discover_config
+
             self._discovered_config = discover_config(self.project_path)
 
         return self._discovered_config
@@ -410,8 +459,8 @@ class ConfigResolver:
     def resolve_adapter_config(
         self,
         adapter_name: Optional[str] = None,
-        cli_overrides: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
+        cli_overrides: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
         """Resolve adapter configuration with hierarchical precedence.
 
         Resolution order (highest to lowest priority):
@@ -427,6 +476,7 @@ class ConfigResolver:
 
         Returns:
             Resolved configuration dictionary
+
         """
         # Load configs
         global_config = self.load_global_config()
@@ -465,7 +515,8 @@ class ConfigResolver:
                 if discovered_adapter:
                     # Merge discovered config
                     discovered_dict = {
-                        k: v for k, v in discovered_adapter.config.items()
+                        k: v
+                        for k, v in discovered_adapter.config.items()
                         if k != "adapter"  # Don't override adapter type
                     }
                     resolved_config.update(discovered_dict)
@@ -478,12 +529,16 @@ class ConfigResolver:
             # Check if this project has specific adapter config
             project_path_str = str(self.project_path)
             if project_path_str in project_config.project_configs:
-                proj_adapter_config = project_config.project_configs[project_path_str].to_dict()
+                proj_adapter_config = project_config.project_configs[
+                    project_path_str
+                ].to_dict()
                 resolved_config.update(proj_adapter_config)
 
             # Also check if project has adapter-level overrides
             if target_adapter in project_config.adapters:
-                proj_global_adapter_config = project_config.adapters[target_adapter].to_dict()
+                proj_global_adapter_config = project_config.adapters[
+                    target_adapter
+                ].to_dict()
                 resolved_config.update(proj_global_adapter_config)
 
         # 4. Apply environment variable overrides (os.getenv - HIGHER PRIORITY)
@@ -496,7 +551,7 @@ class ConfigResolver:
 
         return resolved_config
 
-    def _get_env_overrides(self, adapter_type: str) -> Dict[str, Any]:
+    def _get_env_overrides(self, adapter_type: str) -> dict[str, Any]:
         """Get configuration overrides from environment variables.
 
         Args:
@@ -504,6 +559,7 @@ class ConfigResolver:
 
         Returns:
             Dictionary of overrides from environment
+
         """
         overrides = {}
 
@@ -554,9 +610,13 @@ class ConfigResolver:
 
         # Hybrid mode
         if os.getenv("MCP_TICKETER_HYBRID_MODE"):
-            overrides["hybrid_mode_enabled"] = os.getenv("MCP_TICKETER_HYBRID_MODE").lower() == "true"
+            overrides["hybrid_mode_enabled"] = (
+                os.getenv("MCP_TICKETER_HYBRID_MODE").lower() == "true"
+            )
         if os.getenv("MCP_TICKETER_HYBRID_ADAPTERS"):
-            overrides["hybrid_adapters"] = os.getenv("MCP_TICKETER_HYBRID_ADAPTERS").split(",")
+            overrides["hybrid_adapters"] = os.getenv(
+                "MCP_TICKETER_HYBRID_ADAPTERS"
+            ).split(",")
 
         return overrides
 
@@ -565,18 +625,22 @@ class ConfigResolver:
 
         Returns:
             HybridConfig if hybrid mode is enabled, None otherwise
+
         """
         # Check environment first
         if os.getenv("MCP_TICKETER_HYBRID_MODE", "").lower() == "true":
             adapters = os.getenv("MCP_TICKETER_HYBRID_ADAPTERS", "").split(",")
             return HybridConfig(
-                enabled=True,
-                adapters=[a.strip() for a in adapters if a.strip()]
+                enabled=True, adapters=[a.strip() for a in adapters if a.strip()]
             )
 
         # Check project config
         project_config = self.load_project_config()
-        if project_config and project_config.hybrid_mode and project_config.hybrid_mode.enabled:
+        if (
+            project_config
+            and project_config.hybrid_mode
+            and project_config.hybrid_mode.enabled
+        ):
             return project_config.hybrid_mode
 
         # Check global config
@@ -599,6 +663,7 @@ def get_config_resolver(project_path: Optional[Path] = None) -> ConfigResolver:
 
     Returns:
         ConfigResolver instance
+
     """
     global _default_resolver
     if _default_resolver is None or project_path is not None:

mcp_ticketer/core/registry.py

@@ -1,22 +1,24 @@
 """Adapter registry for dynamic adapter management."""
 
-from typing import Dict, Type, Any, Optional
+from typing import Any, Optional
+
 from .adapter import BaseAdapter
 
 
 class AdapterRegistry:
     """Registry for managing ticket system adapters."""
 
-    _adapters: Dict[str, Type[BaseAdapter]] = {}
-    _instances: Dict[str, BaseAdapter] = {}
+    _adapters: dict[str, type[BaseAdapter]] = {}
+    _instances: dict[str, BaseAdapter] = {}
 
     @classmethod
-    def register(cls, name: str, adapter_class: Type[BaseAdapter]) -> None:
+    def register(cls, name: str, adapter_class: type[BaseAdapter]) -> None:
         """Register an adapter class.
 
         Args:
             name: Unique name for the adapter
             adapter_class: Adapter class to register
+
         """
         if not issubclass(adapter_class, BaseAdapter):
             raise TypeError(f"{adapter_class} must be a subclass of BaseAdapter")
@@ -28,16 +30,14 @@ class AdapterRegistry:
 
         Args:
             name: Name of adapter to unregister
+
         """
         cls._adapters.pop(name, None)
         cls._instances.pop(name, None)
 
     @classmethod
     def get_adapter(
-        cls,
-        name: str,
-        config: Optional[Dict[str, Any]] = None,
-        force_new: bool = False
+        cls, name: str, config: Optional[dict[str, Any]] = None, force_new: bool = False
     ) -> BaseAdapter:
         """Get or create an adapter instance.
 
@@ -53,12 +53,12 @@ class AdapterRegistry:
 
         Raises:
             ValueError: If adapter not registered
+
         """
         if name not in cls._adapters:
             available = ", ".join(cls._adapters.keys())
             raise ValueError(
-                f"Adapter '{name}' not registered. "
-                f"Available adapters: {available}"
+                f"Adapter '{name}' not registered. " f"Available adapters: {available}"
             )
 
         # Return cached instance if exists and not forcing new
@@ -75,11 +75,12 @@ class AdapterRegistry:
         return instance
 
     @classmethod
-    def list_adapters(cls) -> Dict[str, Type[BaseAdapter]]:
+    def list_adapters(cls) -> dict[str, type[BaseAdapter]]:
         """List all registered adapters.
 
         Returns:
             Dictionary of adapter names to classes
+
         """
         return cls._adapters.copy()
 
@@ -92,6 +93,7 @@ class AdapterRegistry:
 
         Returns:
             True if registered
+
         """
         return name in cls._adapters
 
@@ -112,10 +114,7 @@ class AdapterRegistry:
         cls._instances.clear()
 
 
-def adapter_factory(
-    adapter_type: str,
-    config: Dict[str, Any]
-) -> BaseAdapter:
+def adapter_factory(adapter_type: str, config: dict[str, Any]) -> BaseAdapter:
     """Factory function for creating adapters.
 
     Args:
@@ -124,5 +123,6 @@ def adapter_factory(
 
     Returns:
         Configured adapter instance
+
     """
-    return AdapterRegistry.get_adapter(adapter_type, config)
+    return AdapterRegistry.get_adapter(adapter_type, config)

mcp_ticketer/mcp/__init__.py

@@ -2,4 +2,4 @@
 
 from .server import MCPTicketServer
 
-__all__ = ["MCPTicketServer"]
+__all__ = ["MCPTicketServer"]