mcp-ticketer 0.1.33__py3-none-any.whl → 0.1.36__py3-none-any.whl

mcp_ticketer/__version__.py

@@ -1,6 +1,6 @@
 """Version information for mcp-ticketer package."""
 
-__version__ = "0.1.33"
+__version__ = "0.1.36"
 __version_info__ = tuple(int(part) for part in __version__.split("."))
 
 # Package metadata

mcp_ticketer/cli/diagnostics.py

@@ -15,53 +15,11 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-def safe_import_config():
-    """Safely import configuration with fallback."""
-    try:
-        from ..core.config import get_config as real_get_config
-
-        # Test if the real config system works
-        try:
-            config = real_get_config()
-            # If we get here, the real config system is working
-            return real_get_config
-        except Exception:
-            # Real config system failed, use fallback
-            pass
-
-    except ImportError:
-        pass
-
-    # Create a minimal config fallback
-    class MockConfig:
-        def get_enabled_adapters(self):
-            # Try to detect adapters from environment even in fallback
-            import os
-            adapters = {}
-
-            # Check for environment variables
-            if os.getenv("LINEAR_API_KEY"):
-                adapters["linear"] = {"type": "linear", "enabled": True}
-            if os.getenv("GITHUB_TOKEN"):
-                adapters["github"] = {"type": "github", "enabled": True}
-            if os.getenv("JIRA_SERVER"):
-                adapters["jira"] = {"type": "jira", "enabled": True}
-
-            # Always include aitrackdown as fallback
-            if not adapters:
-                adapters["aitrackdown"] = {"type": "aitrackdown", "enabled": True}
-
-            return adapters
-
-        @property
-        def default_adapter(self):
-            adapters = self.get_enabled_adapters()
-            return list(adapters.keys())[0] if adapters else "aitrackdown"
-
-    def get_config():
-        return MockConfig()
-
-    return get_config
+def get_config():
+    """Get configuration using the real configuration system."""
+    from ..core.config import ConfigurationManager
+    config_manager = ConfigurationManager()
+    return config_manager.load_config()
 
 def safe_import_registry():
     """Safely import adapter registry with fallback."""
@@ -77,24 +35,27 @@ def safe_import_registry():
         return MockRegistry
 
 def safe_import_queue_manager():
-    """Safely import queue manager with fallback."""
+    """Safely import worker manager with fallback."""
     try:
-        from ..queue.manager import QueueManager as RealQueueManager
+        from ..queue.manager import WorkerManager as RealWorkerManager
 
-        # Test if the real queue manager works
+        # Test if the real worker manager works
         try:
-            qm = RealQueueManager()
+            wm = RealWorkerManager()
             # Test a basic operation
-            qm.get_worker_status()
-            return RealQueueManager
+            wm.get_status()
+            return RealWorkerManager
         except Exception:
-            # Real queue manager failed, use fallback
+            # Real worker manager failed, use fallback
             pass
 
     except ImportError:
         pass
 
-    class MockQueueManager:
+    class MockWorkerManager:
+        def get_status(self):
+            return {"running": False, "pid": None, "status": "fallback_mode"}
+
         def get_worker_status(self):
             return {"running": False, "pid": None, "status": "fallback_mode"}
 
@@ -104,12 +65,11 @@ def safe_import_queue_manager():
         def health_check(self):
             return {"status": "degraded", "score": 50, "details": "Running in fallback mode"}
 
-    return MockQueueManager
+    return MockWorkerManager
 
 # Initialize with safe imports
-get_config = safe_import_config()
 AdapterRegistry = safe_import_registry()
-QueueManager = safe_import_queue_manager()
+WorkerManager = safe_import_queue_manager()
 
 console = Console()
 logger = logging.getLogger(__name__)
@@ -126,29 +86,20 @@ class SystemDiagnostics:
 
         try:
             self.config = get_config()
-            # Check if this is a mock config
-            if hasattr(self.config, '__class__') and 'Mock' in self.config.__class__.__name__:
-                self.config_available = False
-                self.warnings.append("Configuration system using fallback mode")
-            else:
-                self.config_available = True
+            self.config_available = True
         except Exception as e:
             self.config = None
             self.config_available = False
-            console.print(f"⚠️  Could not load configuration: {e}")
+            console.print(f"❌ Could not load configuration: {e}")
+            raise e
 
         try:
-            self.queue_manager = QueueManager()
-            # Check if this is a mock queue manager
-            if hasattr(self.queue_manager, '__class__') and 'Mock' in self.queue_manager.__class__.__name__:
-                self.queue_available = False
-                self.warnings.append("Queue system using fallback mode")
-            else:
-                self.queue_available = True
+            self.worker_manager = WorkerManager()
+            self.queue_available = True
         except Exception as e:
-            self.queue_manager = None
+            self.worker_manager = None
             self.queue_available = False
-            console.print(f"⚠️  Could not initialize queue manager: {e}")
+            console.print(f"⚠️  Could not initialize worker manager: {e}")
 
     async def run_full_diagnosis(self) -> Dict[str, Any]:
         """Run complete system diagnosis and return detailed report."""
@@ -234,25 +185,27 @@ class SystemDiagnostics:
             return config_status
 
         try:
-            # Check adapter configurations
-            adapters = self.config.get_enabled_adapters()
-            config_status["adapters_configured"] = len(adapters)
-            config_status["default_adapter"] = self.config.default_adapter
-
-            if not adapters:
+            # Check adapter configurations using the same approach as working commands
+            from .utils import CommonPatterns
+            raw_config = CommonPatterns.load_config()
+            adapters_config = raw_config.get("adapters", {})
+            config_status["adapters_configured"] = len(adapters_config)
+            config_status["default_adapter"] = raw_config.get("default_adapter")
+
+            if not adapters_config:
                 issue = "No adapters configured"
                 config_status["issues"].append(issue)
                 config_status["status"] = "critical"
                 self.issues.append(issue)
                 console.print(f"❌ {issue}")
             else:
-                console.print(f"✅ {len(adapters)} adapter(s) configured")
+                console.print(f"✅ {len(adapters_config)} adapter(s) configured")
 
             # Check each adapter configuration
-            for name, adapter_config in adapters.items():
+            for name, adapter_config in adapters_config.items():
                 try:
-                    adapter_class = AdapterRegistry.get_adapter(adapter_config.type.value)
-                    adapter = adapter_class(adapter_config.dict())
+                    # Use the same adapter creation approach as working commands
+                    adapter = CommonPatterns.get_adapter(override_adapter=name)
                     
                     # Test adapter validation if available
                     if hasattr(adapter, 'validate_credentials'):
@@ -295,17 +248,15 @@ class SystemDiagnostics:
         }
 
         try:
-            adapters = self.config.get_enabled_adapters()
-            adapter_status["total_adapters"] = len(adapters)
-
-            for name, adapter_config in adapters.items():
-                # Handle both dict and object adapter configs
-                if isinstance(adapter_config, dict):
-                    adapter_type = adapter_config.get("type", "unknown")
-                    config_dict = adapter_config
-                else:
-                    adapter_type = adapter_config.type.value if hasattr(adapter_config, 'type') else "unknown"
-                    config_dict = adapter_config.dict() if hasattr(adapter_config, 'dict') else adapter_config
+            # Use the same configuration loading approach as working commands
+            from .utils import CommonPatterns
+            raw_config = CommonPatterns.load_config()
+            adapters_config = raw_config.get("adapters", {})
+            adapter_status["total_adapters"] = len(adapters_config)
+
+            for name, adapter_config in adapters_config.items():
+                adapter_type = adapter_config.get("type", name)
+                config_dict = adapter_config
 
                 details = {
                     "type": adapter_type,
@@ -315,18 +266,9 @@ class SystemDiagnostics:
                 }
 
                 try:
-                    # Import AdapterRegistry safely
-                    try:
-                        from ..core.registry import AdapterRegistry
-                    except ImportError:
-                        details["status"] = "failed"
-                        details["error"] = "AdapterRegistry not available"
-                        adapter_status["failed_adapters"] += 1
-                        adapter_status["adapter_details"][name] = details
-                        continue
-
-                    adapter_class = AdapterRegistry.get_adapter(adapter_type)
-                    adapter = adapter_class(config_dict)
+                    # Use the same adapter creation approach as working commands
+                    from .utils import CommonPatterns
+                    adapter = CommonPatterns.get_adapter(override_adapter=adapter_type)
                     
                     # Test basic adapter functionality
                     test_start = datetime.now()
@@ -392,7 +334,7 @@ class SystemDiagnostics:
 
             # Test 1: Check current worker status
             console.print("🔍 Checking current worker status...")
-            worker_status = self.queue_manager.get_worker_status()
+            worker_status = self.worker_manager.get_status()
             queue_status["worker_running"] = worker_status.get("running", False)
             queue_status["worker_pid"] = worker_status.get("pid")
 
@@ -416,7 +358,7 @@ class SystemDiagnostics:
 
             # Test 3: Get queue statistics
             console.print("🔍 Analyzing queue statistics...")
-            stats = self.queue_manager.get_queue_stats()
+            stats = self.worker_manager.queue.get_stats()
             queue_status["queue_stats"] = stats
 
             total_items = stats.get("total", 0)
@@ -479,11 +421,11 @@ class SystemDiagnostics:
         }
 
         try:
-            # Try to start worker using the queue manager
-            if hasattr(self.queue_manager, 'start_worker'):
-                result = await self.queue_manager.start_worker()
-                test_result["success"] = True
-                test_result["details"] = "Worker started successfully"
+            # Try to start worker using the worker manager
+            if hasattr(self.worker_manager, 'start'):
+                result = self.worker_manager.start()
+                test_result["success"] = result
+                test_result["details"] = "Worker started successfully" if result else "Worker failed to start"
             else:
                 # Try alternative method - use CLI command
                 import subprocess
@@ -518,6 +460,7 @@ class SystemDiagnostics:
         try:
             # Test creating a simple queue item (diagnostic test)
             from ..core.models import Task, Priority
+            from ..queue.queue import Queue
 
             test_task = Task(
                 title="[DIAGNOSTIC TEST] Queue functionality test",
@@ -525,13 +468,15 @@ class SystemDiagnostics:
                 priority=Priority.LOW
             )
 
-            # Try to queue the test task
-            if hasattr(self.queue_manager, 'queue_task'):
-                queue_id = await self.queue_manager.queue_task("create", test_task, "aitrackdown")
-                test_result["success"] = True
-                test_result["details"] = f"Test task queued successfully: {queue_id}"
-            else:
-                test_result["error"] = "Queue manager doesn't support task queuing"
+            # Try to queue the test task using the correct Queue.add() method
+            queue = Queue()
+            queue_id = queue.add(
+                ticket_data=test_task.model_dump(),
+                adapter="aitrackdown",
+                operation="create"
+            )
+            test_result["success"] = True
+            test_result["details"] = f"Test task queued successfully: {queue_id}"
 
         except Exception as e:
             test_result["error"] = str(e)

mcp_ticketer/cli/main.py

@@ -144,6 +144,83 @@ def load_config(project_dir: Optional[Path] = None) -> dict:
     return {"adapter": "aitrackdown", "config": {"base_path": ".aitrackdown"}}
 
 
+def _discover_from_env_files() -> Optional[str]:
+    """Discover adapter configuration from .env or .env.local files.
+
+    Returns:
+        Adapter name if discovered, None otherwise
+    """
+    import os
+    import logging
+    from pathlib import Path
+
+    logger = logging.getLogger(__name__)
+
+    # Check .env.local first, then .env
+    env_files = [".env.local", ".env"]
+
+    for env_file in env_files:
+        env_path = Path.cwd() / env_file
+        if env_path.exists():
+            try:
+                # Simple .env parsing (key=value format)
+                env_vars = {}
+                with open(env_path, 'r') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#') and '=' in line:
+                            key, value = line.split('=', 1)
+                            env_vars[key.strip()] = value.strip().strip('"\'')
+
+                # Check for adapter-specific variables
+                if env_vars.get("LINEAR_API_KEY"):
+                    logger.info(f"Discovered Linear configuration in {env_file}")
+                    return "linear"
+                elif env_vars.get("GITHUB_TOKEN"):
+                    logger.info(f"Discovered GitHub configuration in {env_file}")
+                    return "github"
+                elif env_vars.get("JIRA_SERVER"):
+                    logger.info(f"Discovered JIRA configuration in {env_file}")
+                    return "jira"
+
+            except Exception as e:
+                logger.warning(f"Could not read {env_file}: {e}")
+
+    return None
+
+
+def _save_adapter_to_config(adapter_name: str) -> None:
+    """Save adapter configuration to config file.
+
+    Args:
+        adapter_name: Name of the adapter to save as default
+    """
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    try:
+        config = load_config()
+        config["default_adapter"] = adapter_name
+
+        # Ensure adapters section exists
+        if "adapters" not in config:
+            config["adapters"] = {}
+
+        # Add basic adapter config if not exists
+        if adapter_name not in config["adapters"]:
+            if adapter_name == "aitrackdown":
+                config["adapters"][adapter_name] = {"base_path": ".aitrackdown"}
+            else:
+                config["adapters"][adapter_name] = {"type": adapter_name}
+
+        save_config(config)
+        logger.info(f"Saved {adapter_name} as default adapter")
+
+    except Exception as e:
+        logger.warning(f"Could not save adapter configuration: {e}")
+
+
 def save_config(config: dict) -> None:
     """Save configuration to project-local config file ONLY.
 
@@ -369,11 +446,19 @@ def init(
     if discovered and adapter_type != "aitrackdown":
         discovered_adapter = discovered.get_adapter_by_type(adapter_type)
         if discovered_adapter:
-            config["adapters"][adapter_type] = discovered_adapter.config
+            adapter_config = discovered_adapter.config.copy()
+            # Ensure the config has the correct 'type' field
+            adapter_config["type"] = adapter_type
+            # Remove 'adapter' field if present (legacy)
+            adapter_config.pop("adapter", None)
+            config["adapters"][adapter_type] = adapter_config
 
     # 4. Handle manual configuration for specific adapters
     if adapter_type == "aitrackdown":
-        config["adapters"]["aitrackdown"] = {"base_path": base_path or ".aitrackdown"}
+        config["adapters"]["aitrackdown"] = {
+            "type": "aitrackdown",
+            "base_path": base_path or ".aitrackdown"
+        }
 
     elif adapter_type == "linear":
         # If not auto-discovered, build from CLI params
@@ -395,6 +480,7 @@ def init(
                 )
 
             if linear_config:
+                linear_config["type"] = "linear"
                 config["adapters"]["linear"] = linear_config
 
     elif adapter_type == "jira":
@@ -926,11 +1012,25 @@ def create(
                 console.print(f"[yellow]  • {alert['message']}[/yellow]")
         console.print("[yellow]Proceeding with ticket creation...[/yellow]")
 
-    # Get the adapter name
-    config = load_config()
-    adapter_name = (
-        adapter.value if adapter else config.get("default_adapter", "aitrackdown")
-    )
+    # Get the adapter name with priority: 1) argument, 2) config, 3) .env files, 4) default
+    if adapter:
+        # Priority 1: Command-line argument - save to config for future use
+        adapter_name = adapter.value
+        _save_adapter_to_config(adapter_name)
+    else:
+        # Priority 2: Check existing config
+        config = load_config()
+        adapter_name = config.get("default_adapter")
+
+        if not adapter_name or adapter_name == "aitrackdown":
+            # Priority 3: Check .env files and save if found
+            env_adapter = _discover_from_env_files()
+            if env_adapter:
+                adapter_name = env_adapter
+                _save_adapter_to_config(adapter_name)
+            else:
+                # Priority 4: Default
+                adapter_name = "aitrackdown"
 
     # Create task data
     task_data = {

mcp_ticketer/cli/utils.py

@@ -31,7 +31,7 @@ class CommonPatterns:
 
     @staticmethod
     def load_config() -> dict:
-        """Load configuration from project-local config file ONLY.
+        """Load configuration from project-local config file with environment discovery fallback.
 
         SECURITY: This method ONLY reads from the current project directory
         to prevent configuration leakage across projects. It will NEVER read
@@ -39,7 +39,8 @@ class CommonPatterns:
 
         Resolution order:
         1. Project-specific config (.mcp-ticketer/config.json in cwd)
-        2. Default to aitrackdown adapter
+        2. Environment discovery (environment variables and .env files in cwd)
+        3. Default to aitrackdown adapter
 
         Returns:
             Configuration dictionary with adapter and config keys.
@@ -77,6 +78,39 @@ class CommonPatterns:
                     f"[yellow]Warning: Could not load project config: {e}[/yellow]"
                 )
 
+        # Try environment discovery as fallback
+        try:
+            from ..core.config import ConfigurationManager
+            config_manager = ConfigurationManager()
+            app_config = config_manager.load_config()
+
+            # Convert AppConfig to legacy dict format for CLI compatibility
+            enabled_adapters = app_config.get_enabled_adapters()
+            if enabled_adapters:
+                # Use the first enabled adapter as default
+                default_adapter = app_config.default_adapter or list(enabled_adapters.keys())[0]
+
+                # Convert to legacy format
+                legacy_config = {
+                    "default_adapter": default_adapter,
+                    "adapters": {}
+                }
+
+                # Convert adapter configs to dict format
+                for name, adapter_config in enabled_adapters.items():
+                    if hasattr(adapter_config, 'model_dump'):
+                        legacy_config["adapters"][name] = adapter_config.model_dump(exclude_none=False)
+                    elif hasattr(adapter_config, 'dict'):
+                        legacy_config["adapters"][name] = adapter_config.dict()
+                    else:
+                        legacy_config["adapters"][name] = adapter_config
+
+                logger.info(f"Loaded configuration from environment discovery: {list(enabled_adapters.keys())}")
+                return legacy_config
+
+        except Exception as e:
+            logger.warning(f"Environment discovery failed: {e}")
+
         # Default to aitrackdown with local base path
         logger.info("No project-local config found, defaulting to aitrackdown adapter")
         return {"adapter": "aitrackdown", "config": {"base_path": ".aitrackdown"}}

mcp_ticketer/core/config.py

@@ -118,9 +118,17 @@ class LinearConfig(BaseAdapterConfig):
     type: AdapterType = AdapterType.LINEAR
     api_key: Optional[str] = Field(None, env="LINEAR_API_KEY")
     workspace: Optional[str] = None
-    team_key: str
+    team_key: Optional[str] = None  # Short team key like "BTA"
+    team_id: Optional[str] = None   # UUID team identifier
     api_url: str = "https://api.linear.app/graphql"
 
+    @model_validator(mode="after")
+    def validate_team_identifier(self):
+        """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):
@@ -284,9 +292,11 @@ class ConfigurationManager:
             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 - try environment discovery
-            logger.info("No configuration file found, attempting environment discovery")
-            config_data = self._discover_from_environment()
+            # 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:
@@ -294,13 +304,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(
@@ -335,10 +353,10 @@ class ConfigurationManager:
     def _discover_from_environment(self) -> dict[str, Any]:
         """Discover configuration from environment variables."""
         try:
-            from .env_discovery import EnvironmentDiscovery
+            from .env_discovery import EnvDiscovery
 
-            discovery = EnvironmentDiscovery()
-            discovered = discovery.discover_all()
+            discovery = EnvDiscovery()
+            discovered = discovery.discover()
 
             if not discovered.adapters:
                 logger.info("No adapters discovered from environment variables")
@@ -362,36 +380,24 @@ class ConfigurationManager:
 
             for adapter in discovered.adapters:
                 adapter_config = {
-                    "type": adapter.type.value,
+                    "type": adapter.adapter_type,
                     "enabled": True
                 }
 
-                # Add adapter-specific configuration
-                if adapter.type.value == "linear":
-                    adapter_config.update({
-                        "api_key": adapter.credentials.get("api_key"),
-                        "team_id": adapter.credentials.get("team_id"),
-                        "project_id": adapter.credentials.get("project_id")
-                    })
-                elif adapter.type.value == "github":
-                    adapter_config.update({
-                        "token": adapter.credentials.get("token"),
-                        "repo": adapter.credentials.get("repo"),
-                        "owner": adapter.credentials.get("owner")
-                    })
-                elif adapter.type.value == "jira":
-                    adapter_config.update({
-                        "server": adapter.credentials.get("server"),
-                        "email": adapter.credentials.get("email"),
-                        "api_token": adapter.credentials.get("api_token"),
-                        "project_key": adapter.credentials.get("project_key")
-                    })
-
-                config_data["adapters"][adapter.name] = adapter_config
+                # 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.name
+                    config_data["default_adapter"] = adapter.adapter_type
 
             logger.info(f"Discovered {len(config_data['adapters'])} adapter(s) from environment")
             return config_data

mcp_ticketer/core/env_discovery.py

@@ -30,8 +30,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 = [
@@ -210,7 +212,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,7 +227,15 @@ 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():
@@ -282,13 +296,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)

{mcp_ticketer-0.1.33.dist-info → mcp_ticketer-0.1.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-ticketer
-Version: 0.1.33
+Version: 0.1.36
 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>
@@ -38,6 +38,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic>=2.0
 Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Requires-Dist: tomli-w>=1.0.0

{mcp_ticketer-0.1.33.dist-info → mcp_ticketer-0.1.36.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mcp_ticketer/__init__.py,sha256=Xx4WaprO5PXhVPbYi1L6tBmwmJMkYS-lMyG4ieN6QP0,717
-mcp_ticketer/__version__.py,sha256=YbtZf8fo9cJTUcdyWdoua2cQU5TJHm7vQ3mwfSr7-mI,1118
+mcp_ticketer/__version__.py,sha256=MUs8plklj0TdV4_KwKETYDo6huvcxKAeEORU6FUFWJ0,1118
 mcp_ticketer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_ticketer/adapters/__init__.py,sha256=B5DFllWn23hkhmrLykNO5uMMSdcFuuPHXyLw_jyFzuE,358
 mcp_ticketer/adapters/aitrackdown.py,sha256=stlbge8K6w-EyQkw_vEQNSXQgCOWN5tOlQUgGWZQNMQ,17936
@@ -13,19 +13,19 @@ mcp_ticketer/cli/__init__.py,sha256=l9Q8iKmfGkTu0cssHBVqNZTsL4eAtFzOB25AED_0G6g,
 mcp_ticketer/cli/auggie_configure.py,sha256=MXKzLtqe3K_UTQ2GacHAWbvf_B0779KL325smiAKE0Q,8212
 mcp_ticketer/cli/codex_configure.py,sha256=xDppHouT6_-cYXswyAggoPX5bSlRXMvCoM_x9PQ-42A,9086
 mcp_ticketer/cli/configure.py,sha256=BsA_pSHQMQS0t1bJO_wMM8LWsd5sWJDASjEPRHvwC18,16198
-mcp_ticketer/cli/diagnostics.py,sha256=FaxlcaHAj3eep_h8Bzv8ktPCeZ5r7SgJG25QOqK3gm4,31095
+mcp_ticketer/cli/diagnostics.py,sha256=AC7cMQHVWdHfrYH2Y1tkhmRezM2-mID5E_Dhfil7F3U,28923
 mcp_ticketer/cli/discover.py,sha256=AF_qlQc1Oo0UkWayoF5pmRChS5J3fJjH6f2YZzd_k8w,13188
 mcp_ticketer/cli/gemini_configure.py,sha256=ZNSA1lBW-itVToza-JxW95Po7daVXKiZAh7lp6pmXMU,9343
-mcp_ticketer/cli/main.py,sha256=TxhCdmEi97rrDkCd0nT4KYRtZSboTfPSrw7SL607goA,54970
+mcp_ticketer/cli/main.py,sha256=pxx3bKMkZdCUF6Cirk_U-cDMsBGKXCcr6WhL9tqLsKw,58555
 mcp_ticketer/cli/mcp_configure.py,sha256=RzV50UjXgOmvMp-9S0zS39psuvjffVByaMrqrUaAGAM,9594
 mcp_ticketer/cli/migrate_config.py,sha256=MYsr_C5ZxsGg0P13etWTWNrJ_lc6ElRCkzfQADYr3DM,5956
 mcp_ticketer/cli/queue_commands.py,sha256=mm-3H6jmkUGJDyU_E46o9iRpek8tvFCm77F19OtHiZI,7884
 mcp_ticketer/cli/simple_health.py,sha256=FIMHbrSNHpNJHXx7wtH8HzQXmPlcF9HQE9ngxTbxhMM,8035
-mcp_ticketer/cli/utils.py,sha256=2ptUrp2ELZsox0kSxAI5DFrHonOU999qh4MxbLv6VBQ,21155
+mcp_ticketer/cli/utils.py,sha256=RRoUMJbw0isyzlRhZwPcbmYQXl1PGYDx9dy1zRctljA,22789
 mcp_ticketer/core/__init__.py,sha256=eXovsaJymQRP2AwOBuOy6mFtI3I68D7gGenZ5V-IMqo,349
 mcp_ticketer/core/adapter.py,sha256=q64LxOInIno7EIbmuxItf8KEsd-g9grCs__Z4uwZHto,10273
-mcp_ticketer/core/config.py,sha256=A3K2JXn65qwpI80_J05oA-6DRjcONi6ZqemU02O4L8U,19120
-mcp_ticketer/core/env_discovery.py,sha256=wKp2Pi5vQMGOTrM1690IBv_eoABly-pD8ah7n1zSWDc,17710
+mcp_ticketer/core/config.py,sha256=hvn8RoN2BSmYzESKqCvcpKleX0PrGiHVQ5v35nX12Mc,19241
+mcp_ticketer/core/env_discovery.py,sha256=It62C97UBt96CgVbZCql5NQtONmCHMkX3c8W2kEl-Qk,18716
 mcp_ticketer/core/http_client.py,sha256=s5ikMiwEJ8TJjNn73wu3gv3OdAtyBEpAqPnSroRMW2k,13971
 mcp_ticketer/core/mappers.py,sha256=1aG1jFsHTCwmGRVgOlXW-VOSTGzc86gv7qjDfiR1ups,17462
 mcp_ticketer/core/models.py,sha256=DRuJoYbjp9fcPV9GwQfhVcNUB0XmwQB3vuqW8hQWZ_k,6491
@@ -41,9 +41,9 @@ mcp_ticketer/queue/queue.py,sha256=jSAkYNEIbNH1cbYuF8s6eFuZmXqn8WHXx3mbfMU2Ud8,1
 mcp_ticketer/queue/run_worker.py,sha256=_IBezjvhbJJ7gn0evTBIMbSPjvfFZwxEdT-1DLo_bRk,799
 mcp_ticketer/queue/ticket_registry.py,sha256=k8FYg2cFYsI4POb94-o-fTrIVr-ttfi60r0O5YhJYck,15321
 mcp_ticketer/queue/worker.py,sha256=TLXXXTAQT1k9Oiw2WjSd8bzT3rr8TQ8NLt9JBovGQEA,18679
-mcp_ticketer-0.1.33.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
-mcp_ticketer-0.1.33.dist-info/METADATA,sha256=gla674ca9CyqLOSch1ZYZMN_7l-6wnymrS0ODYrhkR4,13191
-mcp_ticketer-0.1.33.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_ticketer-0.1.33.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
-mcp_ticketer-0.1.33.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
-mcp_ticketer-0.1.33.dist-info/RECORD,,
+mcp_ticketer-0.1.36.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
+mcp_ticketer-0.1.36.dist-info/METADATA,sha256=d0EDTsEDPLyod1rHUZPowpmH_aWoJUPM7KrNuBs_O4w,13220
+mcp_ticketer-0.1.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_ticketer-0.1.36.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
+mcp_ticketer-0.1.36.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
+mcp_ticketer-0.1.36.dist-info/RECORD,,