mcp-ticketer 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

mcp_ticketer/core/project_config.py

@@ -0,0 +1,606 @@
+"""Project-level configuration management with hierarchical resolution.
+
+This module provides a comprehensive configuration system that supports:
+- Project-specific configurations (.mcp-ticketer/config.json in project root)
+- Global configurations (~/.mcp-ticketer/config.json)
+- Environment variable overrides
+- CLI flag overrides
+- 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
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class AdapterType(str, Enum):
+    """Supported adapter types."""
+    AITRACKDOWN = "aitrackdown"
+    LINEAR = "linear"
+    JIRA = "jira"
+    GITHUB = "github"
+
+
+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
+
+
+@dataclass
+class AdapterConfig:
+    """Base configuration for a single adapter instance."""
+    adapter: str
+    enabled: bool = True
+
+    # Common fields (not all adapters use all fields)
+    api_key: Optional[str] = None
+    token: Optional[str] = None
+
+    # Linear-specific
+    team_id: Optional[str] = None
+    team_key: Optional[str] = None
+    workspace: Optional[str] = None
+
+    # JIRA-specific
+    server: Optional[str] = None
+    email: Optional[str] = None
+    api_token: Optional[str] = None
+    project_key: Optional[str] = None
+
+    # GitHub-specific
+    owner: Optional[str] = None
+    repo: Optional[str] = None
+
+    # AITrackdown-specific
+    base_path: Optional[str] = None
+
+    # Project ID (can be used by any adapter for scoping)
+    project_id: Optional[str] = None
+
+    # Additional adapter-specific configuration
+    additional_config: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary, filtering None values."""
+        result = {}
+        for key, value in asdict(self).items():
+            if value is not None:
+                result[key] = value
+        return result
+
+    @classmethod
+    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'
+        }
+
+        kwargs = {}
+        additional = {}
+
+        for key, value in data.items():
+            if key in known_fields:
+                kwargs[key] = value
+            elif key != 'additional_config':
+                additional[key] = value
+
+        # Merge explicit additional_config
+        if 'additional_config' in data:
+            additional.update(data['additional_config'])
+
+        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)
+
+    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':
+        """Create from dictionary."""
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+
+@dataclass
+class HybridConfig:
+    """Configuration for hybrid mode (multi-adapter sync)."""
+    enabled: bool = False
+    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]:
+        """Convert to dictionary."""
+        result = asdict(self)
+        result['sync_strategy'] = self.sync_strategy.value
+        return result
+
+    @classmethod
+    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'])
+        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)
+    hybrid_mode: Optional[HybridConfig] = None
+
+    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()
+            },
+            "adapters": {
+                name: config.to_dict()
+                for name, config in self.adapters.items()
+            },
+            "hybrid_mode": self.hybrid_mode.to_dict() if self.hybrid_mode else None
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'TicketerConfig':
+        """Create from dictionary."""
+        # Parse project configs
+        project_configs = {}
+        if "project_configs" in data:
+            for path, config_data in data["project_configs"].items():
+                project_configs[path] = ProjectConfig.from_dict(config_data)
+
+        # Parse adapter configs
+        adapters = {}
+        if "adapters" in data:
+            for name, adapter_data in data["adapters"].items():
+                adapters[name] = AdapterConfig.from_dict(adapter_data)
+
+        # Parse hybrid config
+        hybrid_mode = None
+        if "hybrid_mode" in data and data["hybrid_mode"]:
+            hybrid_mode = HybridConfig.from_dict(data["hybrid_mode"])
+
+        return cls(
+            default_adapter=data.get("default_adapter", "aitrackdown"),
+            project_configs=project_configs,
+            adapters=adapters,
+            hybrid_mode=hybrid_mode
+        )
+
+
+class ConfigValidator:
+    """Validate adapter configurations."""
+
+    @staticmethod
+    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:
+            if field not in config or not config[field]:
+                return False, f"Linear config missing required field: {field}"
+
+        # Warn if team_id is missing but don't fail
+        if not config.get("team_id"):
+            logger.warning("Linear config missing team_id - may be required for some operations")
+
+        return True, None
+
+    @staticmethod
+    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")
+        if not has_token:
+            return False, "GitHub config missing required field: token or api_key"
+
+        # project_id can be "owner/repo" format
+        if config.get("project_id"):
+            if "/" in config["project_id"]:
+                parts = config["project_id"].split("/")
+                if len(parts) == 2:
+                    # Extract owner and repo from project_id
+                    return True, None
+
+        # Otherwise need explicit owner and repo
+        required = ["owner", "repo"]
+        for field in required:
+            if field not in config or not config[field]:
+                return False, f"GitHub config missing required field: {field}"
+
+        return True, None
+
+    @staticmethod
+    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:
+            if field not in config or not config[field]:
+                return False, f"JIRA config missing required field: {field}"
+
+        # Validate server URL format
+        server = config["server"]
+        if not server.startswith(("http://", "https://")):
+            return False, "JIRA server must be a valid URL (http:// or https://)"
+
+        return True, None
+
+    @staticmethod
+    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]]:
+        """Validate configuration for any adapter type.
+
+        Args:
+            adapter_type: Type of adapter
+            config: Configuration dictionary
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        validators = {
+            AdapterType.LINEAR.value: cls.validate_linear_config,
+            AdapterType.GITHUB.value: cls.validate_github_config,
+            AdapterType.JIRA.value: cls.validate_jira_config,
+            AdapterType.AITRACKDOWN.value: cls.validate_aitrackdown_config,
+        }
+
+        validator = validators.get(adapter_type)
+        if not validator:
+            return False, f"Unknown adapter type: {adapter_type}"
+
+        return validator(config)
+
+
+class ConfigResolver:
+    """Resolve configuration from multiple sources with hierarchical precedence.
+
+    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)
+    """
+
+    # Global config location
+    GLOBAL_CONFIG_PATH = Path.home() / ".mcp-ticketer" / "config.json"
+
+    # Project config location (relative to project root)
+    PROJECT_CONFIG_SUBPATH = ".mcp-ticketer" / Path("config.json")
+
+    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
+
+    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}")
+
+        # Return default config
+        return TicketerConfig()
+
+    def load_project_config(self, project_path: Optional[Path] = None) -> Optional[TicketerConfig]:
+        """Load project-specific configuration.
+
+        Args:
+            project_path: Path to project root (defaults to self.project_path)
+
+        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:
+                    data = json.load(f)
+                return TicketerConfig.from_dict(data)
+            except Exception as e:
+                logger.error(f"Failed to load project config from {config_path}: {e}")
+
+        return None
+
+    def save_global_config(self, config: TicketerConfig) -> None:
+        """Save global configuration.
+
+        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}")
+
+    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:
+            json.dump(config.to_dict(), f, indent=2)
+        logger.info(f"Saved project config to {config_path}")
+
+    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
+
+        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
+
+    def resolve_adapter_config(
+        self,
+        adapter_name: Optional[str] = None,
+        cli_overrides: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Resolve adapter configuration with hierarchical precedence.
+
+        Precedence (highest to lowest):
+        1. CLI overrides
+        2. Environment variables (os.getenv)
+        3. Project-specific config (.mcp-ticketer/config.json)
+        4. Auto-discovered .env files
+        5. Global config (~/.mcp-ticketer/config.json)
+
+        Args:
+            adapter_name: Name of adapter to configure (defaults to default_adapter)
+            cli_overrides: CLI flag overrides
+
+        Returns:
+            Resolved configuration dictionary
+        """
+        # Load configs
+        global_config = self.load_global_config()
+        project_config = self.load_project_config()
+
+        # Determine which adapter to use
+        if adapter_name:
+            target_adapter = adapter_name
+        elif project_config and project_config.default_adapter:
+            target_adapter = project_config.default_adapter
+        else:
+            # Try to infer from discovered config
+            discovered = self.get_discovered_config()
+            if discovered:
+                primary = discovered.get_primary_adapter()
+                if primary:
+                    target_adapter = primary.adapter_type
+                else:
+                    target_adapter = global_config.default_adapter
+            else:
+                target_adapter = global_config.default_adapter
+
+        # Start with empty config
+        resolved_config = {"adapter": target_adapter}
+
+        # 1. Apply global adapter config
+        if target_adapter in global_config.adapters:
+            global_adapter_config = global_config.adapters[target_adapter].to_dict()
+            resolved_config.update(global_adapter_config)
+
+        # 2. Apply auto-discovered .env config (if enabled)
+        if self.enable_env_discovery:
+            discovered = self.get_discovered_config()
+            if discovered:
+                discovered_adapter = discovered.get_adapter_by_type(target_adapter)
+                if discovered_adapter:
+                    # Merge discovered config
+                    discovered_dict = {
+                        k: v for k, v in discovered_adapter.config.items()
+                        if k != "adapter"  # Don't override adapter type
+                    }
+                    resolved_config.update(discovered_dict)
+                    logger.debug(
+                        f"Applied auto-discovered config from {discovered_adapter.found_in}"
+                    )
+
+        # 3. Apply project-specific config if exists
+        if project_config:
+            # 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()
+                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()
+                resolved_config.update(proj_global_adapter_config)
+
+        # 4. Apply environment variable overrides (os.getenv)
+        env_overrides = self._get_env_overrides(target_adapter)
+        resolved_config.update(env_overrides)
+
+        # 5. Apply CLI overrides
+        if cli_overrides:
+            resolved_config.update(cli_overrides)
+
+        return resolved_config
+
+    def _get_env_overrides(self, adapter_type: str) -> Dict[str, Any]:
+        """Get configuration overrides from environment variables.
+
+        Args:
+            adapter_type: Type of adapter
+
+        Returns:
+            Dictionary of overrides from environment
+        """
+        overrides = {}
+
+        # Override adapter type
+        if os.getenv("MCP_TICKETER_ADAPTER"):
+            overrides["adapter"] = os.getenv("MCP_TICKETER_ADAPTER")
+
+        # Common overrides
+        if os.getenv("MCP_TICKETER_API_KEY"):
+            overrides["api_key"] = os.getenv("MCP_TICKETER_API_KEY")
+
+        # Adapter-specific overrides
+        if adapter_type == AdapterType.LINEAR.value:
+            if os.getenv("MCP_TICKETER_LINEAR_API_KEY"):
+                overrides["api_key"] = os.getenv("MCP_TICKETER_LINEAR_API_KEY")
+            if os.getenv("MCP_TICKETER_LINEAR_TEAM_ID"):
+                overrides["team_id"] = os.getenv("MCP_TICKETER_LINEAR_TEAM_ID")
+            if os.getenv("LINEAR_API_KEY"):
+                overrides["api_key"] = os.getenv("LINEAR_API_KEY")
+
+        elif adapter_type == AdapterType.GITHUB.value:
+            if os.getenv("MCP_TICKETER_GITHUB_TOKEN"):
+                overrides["token"] = os.getenv("MCP_TICKETER_GITHUB_TOKEN")
+            if os.getenv("GITHUB_TOKEN"):
+                overrides["token"] = os.getenv("GITHUB_TOKEN")
+            if os.getenv("MCP_TICKETER_GITHUB_OWNER"):
+                overrides["owner"] = os.getenv("MCP_TICKETER_GITHUB_OWNER")
+            if os.getenv("MCP_TICKETER_GITHUB_REPO"):
+                overrides["repo"] = os.getenv("MCP_TICKETER_GITHUB_REPO")
+
+        elif adapter_type == AdapterType.JIRA.value:
+            if os.getenv("MCP_TICKETER_JIRA_SERVER"):
+                overrides["server"] = os.getenv("MCP_TICKETER_JIRA_SERVER")
+            if os.getenv("MCP_TICKETER_JIRA_EMAIL"):
+                overrides["email"] = os.getenv("MCP_TICKETER_JIRA_EMAIL")
+            if os.getenv("MCP_TICKETER_JIRA_TOKEN"):
+                overrides["api_token"] = os.getenv("MCP_TICKETER_JIRA_TOKEN")
+            if os.getenv("JIRA_SERVER"):
+                overrides["server"] = os.getenv("JIRA_SERVER")
+            if os.getenv("JIRA_EMAIL"):
+                overrides["email"] = os.getenv("JIRA_EMAIL")
+            if os.getenv("JIRA_API_TOKEN"):
+                overrides["api_token"] = os.getenv("JIRA_API_TOKEN")
+
+        elif adapter_type == AdapterType.AITRACKDOWN.value:
+            if os.getenv("MCP_TICKETER_AITRACKDOWN_BASE_PATH"):
+                overrides["base_path"] = os.getenv("MCP_TICKETER_AITRACKDOWN_BASE_PATH")
+
+        # Hybrid mode
+        if os.getenv("MCP_TICKETER_HYBRID_MODE"):
+            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(",")
+
+        return overrides
+
+    def get_hybrid_config(self) -> Optional[HybridConfig]:
+        """Get hybrid mode configuration if enabled.
+
+        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()]
+            )
+
+        # Check project config
+        project_config = self.load_project_config()
+        if project_config and project_config.hybrid_mode and project_config.hybrid_mode.enabled:
+            return project_config.hybrid_mode
+
+        # Check global config
+        global_config = self.load_global_config()
+        if global_config.hybrid_mode and global_config.hybrid_mode.enabled:
+            return global_config.hybrid_mode
+
+        return None
+
+
+# Singleton instance for global access
+_default_resolver: Optional[ConfigResolver] = None
+
+
+def get_config_resolver(project_path: Optional[Path] = None) -> ConfigResolver:
+    """Get the global config resolver instance.
+
+    Args:
+        project_path: Path to project root (defaults to cwd)
+
+    Returns:
+        ConfigResolver instance
+    """
+    global _default_resolver
+    if _default_resolver is None or project_path is not None:
+        _default_resolver = ConfigResolver(project_path)
+    return _default_resolver

mcp_ticketer/queue/queue.py

@@ -173,7 +173,10 @@ class Queue:
                     ''', (QueueStatus.PROCESSING.value, row[0]))
                     conn.commit()
 
-                    return QueueItem.from_row(row)
+                    # Create QueueItem from row and update status
+                    item = QueueItem.from_row(row)
+                    item.status = QueueStatus.PROCESSING
+                    return item
 
         return None
 

{mcp_ticketer-0.1.11.dist-info → mcp_ticketer-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-ticketer
-Version: 0.1.11
+Version: 0.1.13
 Summary: Universal ticket management interface for AI agents with MCP support
 Author-email: MCP Ticketer Team <support@mcp-ticketer.io>
 Maintainer-email: MCP Ticketer Team <support@mcp-ticketer.io>

{mcp_ticketer-0.1.11.dist-info → mcp_ticketer-0.1.13.dist-info}/RECORD

@@ -1,35 +1,41 @@
 mcp_ticketer/__init__.py,sha256=ayPQdFr6msypD06_G96a1H0bdFCT1m1wDtv8MZBpY4I,496
-mcp_ticketer/__version__.py,sha256=Ym9ng_TEiLSfqVAhPCtwjrIqiM8S9cAUurRI6mpYEyg,1115
+mcp_ticketer/__version__.py,sha256=_43DgubrWUqhaLrhYbn9KefWfUiLWjH_hMHmCrgw1Tc,1115
 mcp_ticketer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_ticketer/adapters/__init__.py,sha256=_QRLaX38EUsL-kMvJITY0lYHvrq_ip9Qw4Q1YLavJSo,283
-mcp_ticketer/adapters/aitrackdown.py,sha256=ICNimTtF6rPajuVoVEpmdw2TfjYjnWvao8prUwukNn0,15210
+mcp_ticketer/adapters/__init__.py,sha256=K_1egvhHb5F_7yFceUx2YzPGEoc7vX-q8dMVaS4K6gw,356
+mcp_ticketer/adapters/aitrackdown.py,sha256=gqS_N6VGLoG5itUu17ANG5SefaAITYoW-t2xL9SrY-Y,15372
 mcp_ticketer/adapters/github.py,sha256=onT8NhYaf9fIw2eCOTbZSkk7q4IoM7ZADRvRl9qrUz8,43850
+mcp_ticketer/adapters/hybrid.py,sha256=H9B-pfWmDKXO3GgzxB8undEcZTMzLz_1a6zWhj7xfR0,18556
 mcp_ticketer/adapters/jira.py,sha256=rd-8PseTsRyQNPjsrUJ8vJ8vfBpa6HWFBieOUyvw0Tg,28954
-mcp_ticketer/adapters/linear.py,sha256=neTxVy-QD23tTI7XKtnc5CBCpm3yVCULlgxG5oFSQI4,51752
+mcp_ticketer/adapters/linear.py,sha256=BUK40EF4yNVJV5ldJPFx7Ne4FXHYbrGCUAaFy2gWC9Y,65211
 mcp_ticketer/cache/__init__.py,sha256=MSi3GLXancfP2-edPC9TFAJk7r0j6H5-XmpMHnkGPbI,137
 mcp_ticketer/cache/memory.py,sha256=gTzv-xF7qGfiYVUjG7lnzo0ZcqgXQajMl4NAYUcaytg,5133
 mcp_ticketer/cli/__init__.py,sha256=YeljyLtv906TqkvRuEPhmKO-Uk0CberQ9I6kx1tx2UA,88
-mcp_ticketer/cli/main.py,sha256=adz3YXGnw7GY1h9jYgmIfYizf-z4ddhx2adFjncpZ3A,28294
+mcp_ticketer/cli/configure.py,sha256=etFutvc0QpaVDMOsZiiN7wKuaT98Od1Tj9W6lsEWw5A,16351
+mcp_ticketer/cli/discover.py,sha256=putWrGcctUH8K0fOMtr9MZA9VnWoXzbtoe7mXSkDxhg,13156
+mcp_ticketer/cli/main.py,sha256=3NAHRr5Q4nCExbyQ6YIiUxn1nyqi_e4TBgR8OuMhHqk,30461
+mcp_ticketer/cli/migrate_config.py,sha256=iZIstnlr9vkhiW_MlnSyJOkMi4KHQqrZ6Hz1ECD_VUk,6045
 mcp_ticketer/cli/queue_commands.py,sha256=f3pEHKZ43dBHEIoCBvdfvjfMB9_WJltps9ATwTzorY0,8160
 mcp_ticketer/cli/utils.py,sha256=NxsS91vKA8xZnDXKU2y0Gcyc4I_ctRyJj-wT7Xd1Q_Q,18589
-mcp_ticketer/core/__init__.py,sha256=NA-rDvwuAOZ9sUZVYJOWp8bR6mOBG8w_5lpWTT75JNI,318
-mcp_ticketer/core/adapter.py,sha256=Hh4G9Ri1afchfpRSX8z971roXf50kmyyDD98zbRxSEk,5442
+mcp_ticketer/core/__init__.py,sha256=qpCZveQMyqU2JvYG9MG_c6X35z_VoSmjWdXGcUZqqmA,348
+mcp_ticketer/core/adapter.py,sha256=6KfhceINHfDjs--RyA_rOLeM2phVD_D85S9D6s2lcuU,10075
 mcp_ticketer/core/config.py,sha256=9a2bksbcFr7KXeHSPY6KoSP5Pzt54utYPCmbM-1QKmk,13932
+mcp_ticketer/core/env_discovery.py,sha256=SPoyq_y5j-3gJG5gYNVjCIIrbdzimOdDbTYySmQWZOA,17536
 mcp_ticketer/core/http_client.py,sha256=RM9CEMNcuRb-FxhAijmM_FeBMgxgh1OII9HIPBdJue0,13855
 mcp_ticketer/core/mappers.py,sha256=8I4jcqDqoQEdWlteDMpVeVF3Wo0fDCkmFPRr8oNv8gA,16933
-mcp_ticketer/core/models.py,sha256=K-bLuU_DNNVgjHnVFzAIbSa0kJwT2I3Hj24sCklwIYo,4374
+mcp_ticketer/core/models.py,sha256=GhuTitY6t_QlqfEUvWT6Q2zvY7qAtx_SQyCMMn8iYkk,6473
+mcp_ticketer/core/project_config.py,sha256=UqJpxAunmCvR9R_ev9ZrsLvG4engQe1OFQBEmcRx9cs,22254
 mcp_ticketer/core/registry.py,sha256=fwje0fnjp0YKPZ0SrVWk82SMNLs7CD0JlHQmx7SigNo,3537
 mcp_ticketer/mcp/__init__.py,sha256=Bvzof9vBu6VwcXcIZK8RgKv6ycRV9tDlO-9TUmd8zqQ,122
 mcp_ticketer/mcp/server.py,sha256=TDuU8ChZC2QYSRo0uGHkVReblTf--hriOjxo-pSAF_Y,34068
 mcp_ticketer/queue/__init__.py,sha256=xHBoUwor8ZdO8bIHc7nP25EsAp5Si5Co4g_8ybb7fes,230
 mcp_ticketer/queue/__main__.py,sha256=kQd6iOCKbbFqpRdbIRavuI4_G7-oE898JE4a0yLEYPE,108
 mcp_ticketer/queue/manager.py,sha256=79AH9oUxdBXH3lmJ3kIlFf2GQkWHL6XB6u5JqVWPq60,7571
-mcp_ticketer/queue/queue.py,sha256=UgbIChWPiyI7BJNQ9DYA92D2jVMMtmVWBzotI5ML51A,11394
+mcp_ticketer/queue/queue.py,sha256=z4aivQCtsH5_OUr2OfXSfnFKzugTahNnwHw0LS3ZhZc,11549
 mcp_ticketer/queue/run_worker.py,sha256=HFoykfDpOoz8OUxWbQ2Fka_UlGrYwjPVZ-DEimGFH9o,802
 mcp_ticketer/queue/worker.py,sha256=cVjHR_kfnGKAkiUg0HuXCnbKeKNBBEuj0XZHgIuIn4k,14017
-mcp_ticketer-0.1.11.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
-mcp_ticketer-0.1.11.dist-info/METADATA,sha256=GjLKPEBTziutLdEpztLyQkGvxMCpiHArYsdSKltJwwA,11211
-mcp_ticketer-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_ticketer-0.1.11.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
-mcp_ticketer-0.1.11.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
-mcp_ticketer-0.1.11.dist-info/RECORD,,
+mcp_ticketer-0.1.13.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
+mcp_ticketer-0.1.13.dist-info/METADATA,sha256=29lPCGuZI3U_pdIoRYH3C5h4Xn3DaZo-AfKDXQX7IYs,11211
+mcp_ticketer-0.1.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_ticketer-0.1.13.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
+mcp_ticketer-0.1.13.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
+mcp_ticketer-0.1.13.dist-info/RECORD,,