mcp-ticketer 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

mcp_ticketer/__version__.py

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

mcp_ticketer/cli/diagnostics.py

@@ -0,0 +1,579 @@
+"""Comprehensive diagnostics and self-diagnosis functionality for MCP Ticketer."""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import typer
+from rich.console import Console
+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
+        return get_config
+    except ImportError:
+        # Create a minimal config fallback
+        class MockConfig:
+            def get_enabled_adapters(self):
+                return {}
+
+            @property
+            def default_adapter(self):
+                return "aitrackdown"
+
+        def get_config():
+            return MockConfig()
+
+        return get_config
+
+def safe_import_registry():
+    """Safely import adapter registry with fallback."""
+    try:
+        from ..core.registry import AdapterRegistry
+        return AdapterRegistry
+    except ImportError:
+        class MockRegistry:
+            @staticmethod
+            def get_adapter(adapter_type):
+                raise ImportError(f"Adapter {adapter_type} not available")
+
+        return MockRegistry
+
+def safe_import_queue_manager():
+    """Safely import queue manager with fallback."""
+    try:
+        from ..queue.manager import QueueManager
+        return QueueManager
+    except ImportError:
+        class MockQueueManager:
+            def get_worker_status(self):
+                return {"running": False, "pid": None}
+
+            def get_queue_stats(self):
+                return {"total": 0, "failed": 0}
+
+        return MockQueueManager
+
+# Initialize with safe imports
+get_config = safe_import_config()
+AdapterRegistry = safe_import_registry()
+QueueManager = safe_import_queue_manager()
+
+console = Console()
+logger = logging.getLogger(__name__)
+
+
+class SystemDiagnostics:
+    """Comprehensive system diagnostics and health reporting."""
+
+    def __init__(self):
+        # Initialize lists first
+        self.issues = []
+        self.warnings = []
+        self.successes = []
+
+        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
+        except Exception as e:
+            self.config = None
+            self.config_available = False
+            console.print(f"⚠️  Could not load configuration: {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
+        except Exception as e:
+            self.queue_manager = None
+            self.queue_available = False
+            console.print(f"⚠️  Could not initialize queue manager: {e}")
+
+    async def run_full_diagnosis(self) -> Dict[str, Any]:
+        """Run complete system diagnosis and return detailed report."""
+        console.print("\n🔍 [bold blue]MCP Ticketer System Diagnosis[/bold blue]")
+        console.print("=" * 60)
+
+        report = {
+            "timestamp": datetime.now().isoformat(),
+            "version": self._get_version(),
+            "system_info": self._get_system_info(),
+            "configuration": await self._diagnose_configuration(),
+            "adapters": await self._diagnose_adapters(),
+            "queue_system": await self._diagnose_queue_system(),
+            "recent_logs": await self._analyze_recent_logs(),
+            "performance": await self._analyze_performance(),
+            "recommendations": self._generate_recommendations(),
+        }
+
+        self._display_diagnosis_summary(report)
+        return report
+
+    def _get_version(self) -> str:
+        """Get current version information."""
+        try:
+            from ..__version__ import __version__
+            return __version__
+        except ImportError:
+            return "unknown"
+
+    def _get_system_info(self) -> Dict[str, Any]:
+        """Gather system information."""
+        return {
+            "python_version": sys.version,
+            "platform": sys.platform,
+            "working_directory": str(Path.cwd()),
+            "config_path": str(self.config.config_file) if hasattr(self.config, 'config_file') else "unknown",
+        }
+
+    async def _diagnose_configuration(self) -> Dict[str, Any]:
+        """Diagnose configuration issues."""
+        console.print("\n📋 [yellow]Configuration Analysis[/yellow]")
+
+        config_status = {
+            "status": "healthy",
+            "adapters_configured": 0,
+            "default_adapter": None,
+            "issues": [],
+        }
+
+        if not self.config:
+            issue = "Configuration system not available"
+            config_status["issues"].append(issue)
+            config_status["status"] = "critical"
+            self.issues.append(issue)
+            console.print(f"❌ {issue}")
+            return config_status
+
+        if not self.config_available:
+            warning = "Configuration system in fallback mode - limited functionality"
+            config_status["issues"].append(warning)
+            config_status["status"] = "degraded"
+            self.warnings.append(warning)
+            console.print(f"⚠️  {warning}")
+
+            # Try to detect adapters from environment variables
+            import os
+            env_adapters = []
+            if os.getenv("LINEAR_API_KEY"):
+                env_adapters.append("linear")
+            if os.getenv("GITHUB_TOKEN"):
+                env_adapters.append("github")
+            if os.getenv("JIRA_SERVER"):
+                env_adapters.append("jira")
+
+            config_status["adapters_configured"] = len(env_adapters)
+            config_status["default_adapter"] = "aitrackdown"
+
+            if env_adapters:
+                console.print(f"ℹ️  Detected {len(env_adapters)} adapter(s) from environment: {', '.join(env_adapters)}")
+            else:
+                console.print("ℹ️  No adapter environment variables detected, using aitrackdown")
+
+            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:
+                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")
+
+            # Check each adapter configuration
+            for name, adapter_config in adapters.items():
+                try:
+                    adapter_class = AdapterRegistry.get_adapter(adapter_config.type.value)
+                    adapter = adapter_class(adapter_config.dict())
+                    
+                    # Test adapter validation if available
+                    if hasattr(adapter, 'validate_credentials'):
+                        is_valid, error = adapter.validate_credentials()
+                        if is_valid:
+                            console.print(f"✅ {name}: credentials valid")
+                            self.successes.append(f"{name} adapter configured correctly")
+                        else:
+                            issue = f"{name}: credential validation failed - {error}"
+                            config_status["issues"].append(issue)
+                            self.warnings.append(issue)
+                            console.print(f"⚠️  {issue}")
+                    else:
+                        console.print(f"ℹ️  {name}: no credential validation available")
+
+                except Exception as e:
+                    issue = f"{name}: configuration error - {str(e)}"
+                    config_status["issues"].append(issue)
+                    self.issues.append(issue)
+                    console.print(f"❌ {issue}")
+
+        except Exception as e:
+            issue = f"Configuration loading failed: {str(e)}"
+            config_status["issues"].append(issue)
+            config_status["status"] = "critical"
+            self.issues.append(issue)
+            console.print(f"❌ {issue}")
+
+        return config_status
+
+    async def _diagnose_adapters(self) -> Dict[str, Any]:
+        """Diagnose adapter functionality."""
+        console.print("\n🔌 [yellow]Adapter Diagnosis[/yellow]")
+        
+        adapter_status = {
+            "total_adapters": 0,
+            "healthy_adapters": 0,
+            "failed_adapters": 0,
+            "adapter_details": {},
+        }
+
+        try:
+            adapters = self.config.get_enabled_adapters()
+            adapter_status["total_adapters"] = len(adapters)
+
+            for name, adapter_config in adapters.items():
+                details = {
+                    "type": adapter_config.type.value,
+                    "status": "unknown",
+                    "last_test": None,
+                    "error": None,
+                }
+
+                try:
+                    adapter_class = AdapterRegistry.get_adapter(adapter_config.type.value)
+                    adapter = adapter_class(adapter_config.dict())
+                    
+                    # Test basic adapter functionality
+                    test_start = datetime.now()
+                    
+                    # Try to list tickets (non-destructive test)
+                    try:
+                        await adapter.list(limit=1)
+                        details["status"] = "healthy"
+                        details["last_test"] = test_start.isoformat()
+                        adapter_status["healthy_adapters"] += 1
+                        console.print(f"✅ {name}: operational")
+                    except Exception as e:
+                        details["status"] = "failed"
+                        details["error"] = str(e)
+                        adapter_status["failed_adapters"] += 1
+                        issue = f"{name}: functionality test failed - {str(e)}"
+                        self.issues.append(issue)
+                        console.print(f"❌ {issue}")
+
+                except Exception as e:
+                    details["status"] = "failed"
+                    details["error"] = str(e)
+                    adapter_status["failed_adapters"] += 1
+                    issue = f"{name}: initialization failed - {str(e)}"
+                    self.issues.append(issue)
+                    console.print(f"❌ {issue}")
+
+                adapter_status["adapter_details"][name] = details
+
+        except Exception as e:
+            issue = f"Adapter diagnosis failed: {str(e)}"
+            self.issues.append(issue)
+            console.print(f"❌ {issue}")
+
+        return adapter_status
+
+    async def _diagnose_queue_system(self) -> Dict[str, Any]:
+        """Diagnose queue system health."""
+        console.print("\n⚡ [yellow]Queue System Diagnosis[/yellow]")
+        
+        queue_status = {
+            "worker_running": False,
+            "worker_pid": None,
+            "queue_stats": {},
+            "recent_failures": [],
+            "failure_rate": 0.0,
+            "health_score": 0,
+        }
+
+        try:
+            if not self.queue_available:
+                warning = "Queue system in fallback mode - limited functionality"
+                self.warnings.append(warning)
+                console.print(f"⚠️  {warning}")
+                queue_status["worker_running"] = False
+                queue_status["worker_pid"] = None
+                queue_status["health_score"] = 50  # Degraded but not critical
+                return queue_status
+
+            # Check worker status
+            worker_status = self.queue_manager.get_worker_status()
+            queue_status["worker_running"] = worker_status.get("running", False)
+            queue_status["worker_pid"] = worker_status.get("pid")
+
+            if queue_status["worker_running"]:
+                console.print(f"✅ Queue worker running (PID: {queue_status['worker_pid']})")
+                self.successes.append("Queue worker is running")
+            else:
+                issue = "Queue worker not running"
+                self.issues.append(issue)
+                console.print(f"❌ {issue}")
+
+            # Get queue statistics
+            stats = self.queue_manager.get_queue_stats()
+            queue_status["queue_stats"] = stats
+            
+            total_items = stats.get("total", 0)
+            failed_items = stats.get("failed", 0)
+            
+            if total_items > 0:
+                failure_rate = (failed_items / total_items) * 100
+                queue_status["failure_rate"] = failure_rate
+                
+                if failure_rate > 50:
+                    issue = f"High failure rate: {failure_rate:.1f}% ({failed_items}/{total_items})"
+                    self.issues.append(issue)
+                    console.print(f"❌ {issue}")
+                elif failure_rate > 20:
+                    warning = f"Elevated failure rate: {failure_rate:.1f}% ({failed_items}/{total_items})"
+                    self.warnings.append(warning)
+                    console.print(f"⚠️  {warning}")
+                else:
+                    console.print(f"✅ Queue failure rate: {failure_rate:.1f}% ({failed_items}/{total_items})")
+
+            # Calculate health score
+            health_score = 100
+            if not queue_status["worker_running"]:
+                health_score -= 50
+            health_score -= min(queue_status["failure_rate"], 50)
+            queue_status["health_score"] = max(0, health_score)
+
+            console.print(f"📊 Queue health score: {queue_status['health_score']}/100")
+
+        except Exception as e:
+            issue = f"Queue system diagnosis failed: {str(e)}"
+            self.issues.append(issue)
+            console.print(f"❌ {issue}")
+
+        return queue_status
+
+    async def _analyze_recent_logs(self) -> Dict[str, Any]:
+        """Analyze recent log entries for issues."""
+        console.print("\n📝 [yellow]Recent Log Analysis[/yellow]")
+        
+        log_analysis = {
+            "log_files_found": [],
+            "recent_errors": [],
+            "recent_warnings": [],
+            "patterns": {},
+        }
+
+        try:
+            # Look for common log locations
+            log_paths = [
+                Path.home() / ".mcp-ticketer" / "logs",
+                Path.cwd() / ".mcp-ticketer" / "logs",
+                Path("/var/log/mcp-ticketer"),
+            ]
+
+            for log_path in log_paths:
+                if log_path.exists():
+                    log_analysis["log_files_found"].append(str(log_path))
+                    await self._analyze_log_directory(log_path, log_analysis)
+
+            if not log_analysis["log_files_found"]:
+                console.print("ℹ️  No log files found in standard locations")
+            else:
+                console.print(f"✅ Found logs in {len(log_analysis['log_files_found'])} location(s)")
+
+        except Exception as e:
+            issue = f"Log analysis failed: {str(e)}"
+            self.issues.append(issue)
+            console.print(f"❌ {issue}")
+
+        return log_analysis
+
+    async def _analyze_log_directory(self, log_path: Path, log_analysis: Dict[str, Any]):
+        """Analyze logs in a specific directory."""
+        try:
+            for log_file in log_path.glob("*.log"):
+                if log_file.stat().st_mtime > (datetime.now() - timedelta(hours=24)).timestamp():
+                    await self._parse_log_file(log_file, log_analysis)
+        except Exception as e:
+            self.warnings.append(f"Could not analyze logs in {log_path}: {str(e)}")
+
+    async def _parse_log_file(self, log_file: Path, log_analysis: Dict[str, Any]):
+        """Parse individual log file for issues."""
+        try:
+            with open(log_file, 'r') as f:
+                lines = f.readlines()[-100:]  # Last 100 lines
+                
+            for line in lines:
+                if "ERROR" in line:
+                    log_analysis["recent_errors"].append(line.strip())
+                elif "WARNING" in line:
+                    log_analysis["recent_warnings"].append(line.strip())
+
+        except Exception as e:
+            self.warnings.append(f"Could not parse {log_file}: {str(e)}")
+
+    async def _analyze_performance(self) -> Dict[str, Any]:
+        """Analyze system performance metrics."""
+        console.print("\n⚡ [yellow]Performance Analysis[/yellow]")
+        
+        performance = {
+            "response_times": {},
+            "throughput": {},
+            "resource_usage": {},
+        }
+
+        try:
+            # Test basic operations performance
+            start_time = datetime.now()
+            
+            # Test configuration loading
+            config_start = datetime.now()
+            _ = get_config()
+            config_time = (datetime.now() - config_start).total_seconds()
+            performance["response_times"]["config_load"] = config_time
+            
+            if config_time > 1.0:
+                self.warnings.append(f"Slow configuration loading: {config_time:.2f}s")
+            
+            console.print(f"📊 Configuration load time: {config_time:.3f}s")
+
+        except Exception as e:
+            issue = f"Performance analysis failed: {str(e)}"
+            self.issues.append(issue)
+            console.print(f"❌ {issue}")
+
+        return performance
+
+    def _generate_recommendations(self) -> List[str]:
+        """Generate actionable recommendations based on diagnosis."""
+        recommendations = []
+
+        if self.issues:
+            recommendations.append("🚨 Critical issues detected - immediate attention required")
+            
+            if any("Queue worker not running" in issue for issue in self.issues):
+                recommendations.append("• Restart queue worker: mcp-ticketer queue worker restart")
+                
+            if any("failure rate" in issue.lower() for issue in self.issues):
+                recommendations.append("• Check queue system logs for error patterns")
+                recommendations.append("• Consider clearing failed queue items: mcp-ticketer queue clear --failed")
+                
+            if any("No adapters configured" in issue for issue in self.issues):
+                recommendations.append("• Configure at least one adapter: mcp-ticketer init-aitrackdown")
+
+        if self.warnings:
+            recommendations.append("⚠️  Warnings detected - monitoring recommended")
+
+        if not self.issues and not self.warnings:
+            recommendations.append("✅ System appears healthy - no immediate action required")
+
+        return recommendations
+
+    def _display_diagnosis_summary(self, report: Dict[str, Any]):
+        """Display a comprehensive diagnosis summary."""
+        console.print("\n" + "=" * 60)
+        console.print("📋 [bold green]DIAGNOSIS SUMMARY[/bold green]")
+        console.print("=" * 60)
+
+        # Overall health status
+        if self.issues:
+            status_color = "red"
+            status_text = "CRITICAL"
+            status_icon = "🚨"
+        elif self.warnings:
+            status_color = "yellow"
+            status_text = "WARNING"
+            status_icon = "⚠️"
+        else:
+            status_color = "green"
+            status_text = "HEALTHY"
+            status_icon = "✅"
+
+        console.print(f"\n{status_icon} [bold {status_color}]System Status: {status_text}[/bold {status_color}]")
+
+        # Statistics
+        stats_table = Table(show_header=True, header_style="bold blue")
+        stats_table.add_column("Component")
+        stats_table.add_column("Status")
+        stats_table.add_column("Details")
+
+        # Add component statuses
+        config_status = "✅ OK" if not any("configuration" in issue.lower() for issue in self.issues) else "❌ FAILED"
+        stats_table.add_row("Configuration", config_status, f"{report['configuration']['adapters_configured']} adapters")
+
+        queue_health = report['queue_system']['health_score']
+        queue_status = "✅ OK" if queue_health > 80 else "⚠️  DEGRADED" if queue_health > 50 else "❌ FAILED"
+        stats_table.add_row("Queue System", queue_status, f"{queue_health}/100 health score")
+
+        adapter_stats = report['adapters']
+        adapter_status = "✅ OK" if adapter_stats['failed_adapters'] == 0 else "❌ FAILED"
+        stats_table.add_row("Adapters", adapter_status, f"{adapter_stats['healthy_adapters']}/{adapter_stats['total_adapters']} healthy")
+
+        console.print(stats_table)
+
+        # Issues and recommendations
+        if self.issues:
+            console.print(f"\n🚨 [bold red]Critical Issues ({len(self.issues)}):[/bold red]")
+            for issue in self.issues:
+                console.print(f"  • {issue}")
+
+        if self.warnings:
+            console.print(f"\n⚠️  [bold yellow]Warnings ({len(self.warnings)}):[/bold yellow]")
+            for warning in self.warnings:
+                console.print(f"  • {warning}")
+
+        if report['recommendations']:
+            console.print(f"\n💡 [bold blue]Recommendations:[/bold blue]")
+            for rec in report['recommendations']:
+                console.print(f"  {rec}")
+
+        console.print(f"\n📊 [bold]Summary:[/bold] {len(self.successes)} successes, {len(self.warnings)} warnings, {len(self.issues)} critical issues")
+
+
+async def run_diagnostics(
+    output_file: Optional[str] = None,
+    json_output: bool = False,
+) -> None:
+    """Run comprehensive system diagnostics."""
+    diagnostics = SystemDiagnostics()
+    report = await diagnostics.run_full_diagnosis()
+
+    if output_file:
+        with open(output_file, 'w') as f:
+            json.dump(report, f, indent=2)
+        console.print(f"\n📄 Full report saved to: {output_file}")
+
+    if json_output:
+        console.print("\n" + json.dumps(report, indent=2))
+
+    # Return exit code based on issues
+    if diagnostics.issues:
+        raise typer.Exit(1)  # Critical issues found
+    elif diagnostics.warnings:
+        raise typer.Exit(2)  # Warnings found
+    else:
+        raise typer.Exit(0)  # All good

mcp_ticketer/cli/main.py

@@ -22,6 +22,7 @@ from ..queue.ticket_registry import TicketRegistry
 # Import adapters module to trigger registration
 import mcp_ticketer.adapters  # noqa: F401
 from .configure import configure_wizard, set_adapter_config, show_current_config
+from .diagnostics import run_diagnostics
 from .discover import app as discover_app
 from .migrate_config import migrate_config_command
 from .queue_commands import app as queue_app
@@ -1260,6 +1261,48 @@ app.add_typer(queue_app, name="queue")
 # Add discover command to main app
 app.add_typer(discover_app, name="discover")
 
+# Add diagnostics command
+@app.command()
+def diagnose(
+    output_file: Optional[str] = typer.Option(None, "--output", "-o", help="Save full report to file"),
+    json_output: bool = typer.Option(False, "--json", help="Output report in JSON format"),
+    simple: bool = typer.Option(False, "--simple", help="Use simple diagnostics (no heavy dependencies)"),
+) -> None:
+    """Run comprehensive system diagnostics and health check."""
+    if simple:
+        from .simple_health import simple_diagnose
+        report = simple_diagnose()
+        if output_file:
+            import json
+            with open(output_file, 'w') as f:
+                json.dump(report, f, indent=2)
+            console.print(f"\n📄 Report saved to: {output_file}")
+        if json_output:
+            import json
+            console.print("\n" + json.dumps(report, indent=2))
+        if report["issues"]:
+            raise typer.Exit(1)
+    else:
+        try:
+            asyncio.run(run_diagnostics(output_file=output_file, json_output=json_output))
+        except Exception as e:
+            console.print(f"⚠️  Full diagnostics failed: {e}")
+            console.print("🔄 Falling back to simple diagnostics...")
+            from .simple_health import simple_diagnose
+            report = simple_diagnose()
+            if report["issues"]:
+                raise typer.Exit(1)
+
+
+@app.command()
+def health() -> None:
+    """Quick health check - shows system status summary."""
+    from .simple_health import simple_health_check
+
+    result = simple_health_check()
+    if result != 0:
+        raise typer.Exit(result)
+
 # Create MCP configuration command group
 mcp_app = typer.Typer(
     name="mcp",

mcp_ticketer/cli/simple_health.py

@@ -0,0 +1,219 @@
+"""Simple health check that doesn't require full configuration system."""
+
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Any
+
+from rich.console import Console
+
+console = Console()
+
+
+def simple_health_check() -> int:
+    """Perform a simple health check without heavy dependencies."""
+    console.print("\n🏥 [bold blue]MCP Ticketer Quick Health Check[/bold blue]")
+    console.print("=" * 50)
+    
+    issues = 0
+    
+    # Check Python version
+    python_version = sys.version_info
+    if python_version >= (3, 9):
+        console.print(f"✅ Python: {python_version.major}.{python_version.minor}.{python_version.micro}")
+    else:
+        console.print(f"❌ Python: {python_version.major}.{python_version.minor}.{python_version.micro} (requires 3.9+)")
+        issues += 1
+    
+    # Check for basic configuration files
+    config_files = [
+        ".mcp-ticketer.yaml",
+        ".mcp-ticketer.yml", 
+        "mcp-ticketer.yaml",
+        "mcp-ticketer.yml",
+        ".aitrackdown",
+    ]
+    
+    config_found = False
+    for config_file in config_files:
+        if Path(config_file).exists():
+            console.print(f"✅ Configuration: Found {config_file}")
+            config_found = True
+            break
+    
+    if not config_found:
+        console.print("⚠️  Configuration: No config files found (will use defaults)")
+    
+    # Check for aitrackdown directory (default adapter)
+    aitrackdown_path = Path(".aitrackdown")
+    if aitrackdown_path.exists():
+        console.print(f"✅ Aitrackdown: Directory exists at {aitrackdown_path}")
+        
+        # Check for tickets
+        tickets_dir = aitrackdown_path / "tickets"
+        if tickets_dir.exists():
+            ticket_count = len(list(tickets_dir.glob("*.json")))
+            console.print(f"ℹ️  Aitrackdown: {ticket_count} tickets found")
+        else:
+            console.print("ℹ️  Aitrackdown: No tickets directory (will be created)")
+    else:
+        console.print("ℹ️  Aitrackdown: Directory will be created on first use")
+    
+    # Check environment variables
+    env_vars = [
+        "LINEAR_API_KEY",
+        "LINEAR_TEAM_ID", 
+        "GITHUB_TOKEN",
+        "GITHUB_REPO",
+        "JIRA_SERVER",
+        "JIRA_EMAIL",
+        "JIRA_API_TOKEN",
+    ]
+    
+    env_found = []
+    for var in env_vars:
+        if os.getenv(var):
+            env_found.append(var)
+    
+    if env_found:
+        console.print(f"✅ Environment: {len(env_found)} adapter variables configured")
+        for var in env_found:
+            console.print(f"  • {var}")
+    else:
+        console.print("ℹ️  Environment: No adapter variables found (using defaults)")
+    
+    # Check if we can import core modules
+    try:
+        import mcp_ticketer
+        console.print(f"✅ Installation: mcp-ticketer {mcp_ticketer.__version__} installed")
+    except Exception as e:
+        console.print(f"❌ Installation: Import failed - {e}")
+        issues += 1
+    
+    # Try to check queue system (simplified)
+    try:
+        from ..queue.manager import QueueManager
+        queue_manager = QueueManager()
+        worker_status = queue_manager.get_worker_status()
+        
+        if worker_status.get("running", False):
+            console.print(f"✅ Queue Worker: Running (PID: {worker_status.get('pid')})")
+        else:
+            console.print("⚠️  Queue Worker: Not running (start with: mcp-ticketer queue worker start)")
+            
+        # Get basic stats
+        stats = queue_manager.get_queue_stats()
+        total = stats.get("total", 0)
+        failed = stats.get("failed", 0)
+        
+        if total > 0:
+            failure_rate = (failed / total) * 100
+            if failure_rate > 50:
+                console.print(f"❌ Queue Health: High failure rate {failure_rate:.1f}% ({failed}/{total})")
+                issues += 1
+            elif failure_rate > 20:
+                console.print(f"⚠️  Queue Health: Elevated failure rate {failure_rate:.1f}% ({failed}/{total})")
+            else:
+                console.print(f"✅ Queue Health: {failure_rate:.1f}% failure rate ({failed}/{total})")
+        else:
+            console.print("ℹ️  Queue Health: No items processed yet")
+            
+    except Exception as e:
+        console.print(f"⚠️  Queue System: Could not check status - {e}")
+    
+    # Summary
+    console.print()
+    if issues == 0:
+        console.print("🎉 [bold green]System appears healthy![/bold green]")
+        console.print("💡 For detailed diagnosis, run: mcp-ticketer diagnose")
+        return 0
+    else:
+        console.print(f"⚠️  [bold yellow]{issues} issue(s) detected[/bold yellow]")
+        console.print("💡 For detailed diagnosis, run: mcp-ticketer diagnose")
+        return 1
+
+
+def simple_diagnose() -> Dict[str, Any]:
+    """Simple diagnosis that works without full config system."""
+    console.print("\n🔍 [bold blue]MCP Ticketer Simple Diagnosis[/bold blue]")
+    console.print("=" * 60)
+    
+    report = {
+        "timestamp": "2025-10-24",  # Static for now
+        "version": "0.1.28",
+        "python_version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        "working_directory": str(Path.cwd()),
+        "issues": [],
+        "warnings": [],
+        "recommendations": [],
+    }
+    
+    # Basic checks
+    console.print("\n📋 [yellow]Basic System Check[/yellow]")
+    
+    # Python version
+    if sys.version_info < (3, 9):
+        issue = f"Python {sys.version_info.major}.{sys.version_info.minor} is too old (requires 3.9+)"
+        report["issues"].append(issue)
+        console.print(f"❌ {issue}")
+    else:
+        console.print(f"✅ Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}")
+    
+    # Installation check
+    try:
+        import mcp_ticketer
+        console.print(f"✅ mcp-ticketer {mcp_ticketer.__version__} installed")
+    except Exception as e:
+        issue = f"Installation check failed: {e}"
+        report["issues"].append(issue)
+        console.print(f"❌ {issue}")
+    
+    # Configuration check
+    console.print("\n📋 [yellow]Configuration Check[/yellow]")
+    config_files = [".mcp-ticketer.yaml", ".mcp-ticketer.yml", "mcp-ticketer.yaml", "mcp-ticketer.yml"]
+    config_found = any(Path(f).exists() for f in config_files)
+    
+    if config_found:
+        console.print("✅ Configuration files found")
+    else:
+        console.print("ℹ️  No configuration files (using defaults)")
+    
+    # Environment variables
+    env_vars = ["LINEAR_API_KEY", "GITHUB_TOKEN", "JIRA_SERVER"]
+    env_count = sum(1 for var in env_vars if os.getenv(var))
+    
+    if env_count > 0:
+        console.print(f"✅ {env_count} adapter environment variables configured")
+    else:
+        console.print("ℹ️  No adapter environment variables (using aitrackdown)")
+    
+    # Recommendations
+    if not report["issues"]:
+        report["recommendations"].append("✅ System appears healthy")
+    else:
+        report["recommendations"].append("🚨 Critical issues detected - see above")
+    
+    if not config_found and env_count == 0:
+        report["recommendations"].append("💡 Consider running: mcp-ticketer init-aitrackdown")
+    
+    # Display summary
+    console.print("\n" + "=" * 60)
+    console.print("📋 [bold green]DIAGNOSIS SUMMARY[/bold green]")
+    console.print("=" * 60)
+    
+    if report["issues"]:
+        console.print(f"\n🚨 [bold red]Issues ({len(report['issues'])}):[/bold red]")
+        for issue in report["issues"]:
+            console.print(f"  • {issue}")
+    
+    if report["warnings"]:
+        console.print(f"\n⚠️  [bold yellow]Warnings ({len(report['warnings'])}):[/bold yellow]")
+        for warning in report["warnings"]:
+            console.print(f"  • {warning}")
+    
+    if report["recommendations"]:
+        console.print(f"\n💡 [bold blue]Recommendations:[/bold blue]")
+        for rec in report["recommendations"]:
+            console.print(f"  {rec}")
+    
+    return report

mcp_ticketer/mcp/server.py

@@ -1460,6 +1460,29 @@ class MCPTicketServer:
                         "required": ["queue_id"],
                     },
                 },
+                # System diagnostics tools
+                {
+                    "name": "system_health",
+                    "description": "Quick system health check - shows configuration, queue worker, and failure rates",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {},
+                    },
+                },
+                {
+                    "name": "system_diagnose",
+                    "description": "Comprehensive system diagnostics - detailed analysis of all components",
+                    "inputSchema": {
+                        "type": "object",
+                        "properties": {
+                            "include_logs": {
+                                "type": "boolean",
+                                "default": False,
+                                "description": "Include recent log analysis in diagnosis",
+                            },
+                        },
+                    },
+                },
             ]
         }
 
@@ -1514,6 +1537,11 @@ class MCPTicketServer:
                 result = await self._handle_search(arguments)
             elif tool_name == "ticket_status":
                 result = await self._handle_queue_status(arguments)
+            # System diagnostics
+            elif tool_name == "system_health":
+                result = await self._handle_system_health(arguments)
+            elif tool_name == "system_diagnose":
+                result = await self._handle_system_diagnose(arguments)
             # PR integration
             elif tool_name == "ticket_create_pr":
                 result = await self._handle_create_pr(arguments)
@@ -1674,5 +1702,194 @@ async def main():
     await server.run()
 
 
+# Add diagnostic handler methods to MCPTicketServer class
+async def _handle_system_health(self, arguments: dict[str, Any]) -> dict[str, Any]:
+    """Handle system health check."""
+    from ..cli.diagnostics import SystemDiagnostics
+
+    try:
+        diagnostics = SystemDiagnostics()
+
+        # Quick health checks
+        health_status = {
+            "overall_status": "healthy",
+            "components": {},
+            "issues": [],
+            "warnings": [],
+        }
+
+        # Check configuration
+        try:
+            from ..core.config import get_config
+            config = get_config()
+            adapters = config.get_enabled_adapters()
+            if adapters:
+                health_status["components"]["configuration"] = {
+                    "status": "healthy",
+                    "adapters_count": len(adapters),
+                }
+            else:
+                health_status["components"]["configuration"] = {
+                    "status": "failed",
+                    "error": "No adapters configured",
+                }
+                health_status["issues"].append("No adapters configured")
+                health_status["overall_status"] = "critical"
+        except Exception as e:
+            health_status["components"]["configuration"] = {
+                "status": "failed",
+                "error": str(e),
+            }
+            health_status["issues"].append(f"Configuration error: {str(e)}")
+            health_status["overall_status"] = "critical"
+
+        # Check queue system
+        try:
+            from ..queue.manager import QueueManager
+            queue_manager = QueueManager()
+            worker_status = queue_manager.get_worker_status()
+            stats = queue_manager.get_queue_stats()
+
+            total = stats.get("total", 0)
+            failed = stats.get("failed", 0)
+            failure_rate = (failed / total * 100) if total > 0 else 0
+
+            queue_health = {
+                "status": "healthy",
+                "worker_running": worker_status.get("running", False),
+                "worker_pid": worker_status.get("pid"),
+                "failure_rate": failure_rate,
+                "total_processed": total,
+                "failed_items": failed,
+            }
+
+            if not worker_status.get("running", False):
+                queue_health["status"] = "failed"
+                health_status["issues"].append("Queue worker not running")
+                health_status["overall_status"] = "critical"
+            elif failure_rate > 50:
+                queue_health["status"] = "degraded"
+                health_status["issues"].append(f"High queue failure rate: {failure_rate:.1f}%")
+                health_status["overall_status"] = "critical"
+            elif failure_rate > 20:
+                queue_health["status"] = "warning"
+                health_status["warnings"].append(f"Elevated queue failure rate: {failure_rate:.1f}%")
+                if health_status["overall_status"] == "healthy":
+                    health_status["overall_status"] = "warning"
+
+            health_status["components"]["queue_system"] = queue_health
+
+        except Exception as e:
+            health_status["components"]["queue_system"] = {
+                "status": "failed",
+                "error": str(e),
+            }
+            health_status["issues"].append(f"Queue system error: {str(e)}")
+            health_status["overall_status"] = "critical"
+
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": f"System Health Status: {health_status['overall_status'].upper()}\n\n" +
+                           f"Configuration: {health_status['components'].get('configuration', {}).get('status', 'unknown')}\n" +
+                           f"Queue System: {health_status['components'].get('queue_system', {}).get('status', 'unknown')}\n\n" +
+                           f"Issues: {len(health_status['issues'])}\n" +
+                           f"Warnings: {len(health_status['warnings'])}\n\n" +
+                           (f"Critical Issues:\n" + "\n".join(f"• {issue}" for issue in health_status['issues']) + "\n\n" if health_status['issues'] else "") +
+                           (f"Warnings:\n" + "\n".join(f"• {warning}" for warning in health_status['warnings']) + "\n\n" if health_status['warnings'] else "") +
+                           "For detailed diagnosis, use system_diagnose tool.",
+                }
+            ],
+            "isError": health_status["overall_status"] == "critical",
+        }
+
+    except Exception as e:
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": f"Health check failed: {str(e)}",
+                }
+            ],
+            "isError": True,
+        }
+
+
+async def _handle_system_diagnose(self, arguments: dict[str, Any]) -> dict[str, Any]:
+    """Handle comprehensive system diagnosis."""
+    from ..cli.diagnostics import SystemDiagnostics
+
+    try:
+        diagnostics = SystemDiagnostics()
+        report = await diagnostics.run_full_diagnosis()
+
+        # Format report for MCP response
+        summary = f"""System Diagnosis Report
+Generated: {report['timestamp']}
+Version: {report['version']}
+
+OVERALL STATUS: {
+    'CRITICAL' if diagnostics.issues else
+    'WARNING' if diagnostics.warnings else
+    'HEALTHY'
+}
+
+COMPONENT STATUS:
+• Configuration: {len(report['configuration']['issues'])} issues
+• Adapters: {report['adapters']['failed_adapters']}/{report['adapters']['total_adapters']} failed
+• Queue System: {report['queue_system']['health_score']}/100 health score
+
+STATISTICS:
+• Successes: {len(diagnostics.successes)}
+• Warnings: {len(diagnostics.warnings)}
+• Critical Issues: {len(diagnostics.issues)}
+
+"""
+
+        if diagnostics.issues:
+            summary += "CRITICAL ISSUES:\n"
+            for issue in diagnostics.issues:
+                summary += f"• {issue}\n"
+            summary += "\n"
+
+        if diagnostics.warnings:
+            summary += "WARNINGS:\n"
+            for warning in diagnostics.warnings:
+                summary += f"• {warning}\n"
+            summary += "\n"
+
+        if report['recommendations']:
+            summary += "RECOMMENDATIONS:\n"
+            for rec in report['recommendations']:
+                summary += f"{rec}\n"
+
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": summary,
+                }
+            ],
+            "isError": bool(diagnostics.issues),
+        }
+
+    except Exception as e:
+        return {
+            "content": [
+                {
+                    "type": "text",
+                    "text": f"System diagnosis failed: {str(e)}",
+                }
+            ],
+            "isError": True,
+        }
+
+
+# Monkey patch the methods onto the class
+MCPTicketServer._handle_system_health = _handle_system_health
+MCPTicketServer._handle_system_diagnose = _handle_system_diagnose
+
+
 if __name__ == "__main__":
     asyncio.run(main())

{mcp_ticketer-0.1.28.dist-info → mcp_ticketer-0.1.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-ticketer
-Version: 0.1.28
+Version: 0.1.30
 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.28.dist-info → mcp_ticketer-0.1.30.dist-info}/RECORD

@@ -1,5 +1,5 @@
 mcp_ticketer/__init__.py,sha256=Xx4WaprO5PXhVPbYi1L6tBmwmJMkYS-lMyG4ieN6QP0,717
-mcp_ticketer/__version__.py,sha256=w-yViL73x_vy42OtylKLgKgQWyIAAbOKsrNKa-cIlJg,1118
+mcp_ticketer/__version__.py,sha256=y7yURZVuwtSStGlJ4RI4JrAK3qRSBtOqe64wfkDPASY,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,12 +13,14 @@ 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=edTmM0OEDNiMYTvQ56HK304EUNUBtYejMaKmpJTpomY,22821
 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=hXPQyeQ9dv5Ry1XxSJZqmanw2KTgN912eXd1dkwd_os,53326
+mcp_ticketer/cli/main.py,sha256=TxhCdmEi97rrDkCd0nT4KYRtZSboTfPSrw7SL607goA,54970
 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/core/__init__.py,sha256=eXovsaJymQRP2AwOBuOy6mFtI3I68D7gGenZ5V-IMqo,349
 mcp_ticketer/core/adapter.py,sha256=q64LxOInIno7EIbmuxItf8KEsd-g9grCs__Z4uwZHto,10273
@@ -30,7 +32,7 @@ mcp_ticketer/core/models.py,sha256=DRuJoYbjp9fcPV9GwQfhVcNUB0XmwQB3vuqW8hQWZ_k,6
 mcp_ticketer/core/project_config.py,sha256=yYxlgxjcEPeOwx-b-SXFpe0k9pW9xzBRAK72PsItG-o,23346
 mcp_ticketer/core/registry.py,sha256=ShYLDPE62KFJpB0kj_zFyQzRxSH3LkQEEuo1jaakb1k,3483
 mcp_ticketer/mcp/__init__.py,sha256=Y05eTzsPk0wH8yKNIM-ekpGjgSDO0bQr0EME-vOP4GE,123
-mcp_ticketer/mcp/server.py,sha256=PpENqLi9qdhxT1KTYrjkekT1LWP2mfTZY-PF6la1hs4,68078
+mcp_ticketer/mcp/server.py,sha256=HApPT2dICSNXNzedtJa0EM9-f74OPBgZYhcKFVdvNSU,76379
 mcp_ticketer/queue/__init__.py,sha256=1YIaCpZpFqPcqvDEQXiEvDLiw94DXRdCJkBaVIFQrms,231
 mcp_ticketer/queue/__main__.py,sha256=gc_tE9NUdK07OJfTZuD4t6KeBD_vxFQIhknGTQUG_jk,109
 mcp_ticketer/queue/health_monitor.py,sha256=aQrlBzfbLWu8-fV2b5CuHs4oqyTqGGcntKIHM3r-dDI,11844
@@ -39,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.28.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
-mcp_ticketer-0.1.28.dist-info/METADATA,sha256=fJ7LnYE7qITkq4JVxoYUmNZavf9K48EhBPVshcAUOQs,13191
-mcp_ticketer-0.1.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mcp_ticketer-0.1.28.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
-mcp_ticketer-0.1.28.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
-mcp_ticketer-0.1.28.dist-info/RECORD,,
+mcp_ticketer-0.1.30.dist-info/licenses/LICENSE,sha256=KOVrunjtILSzY-2N8Lqa3-Q8dMaZIG4LrlLTr9UqL08,1073
+mcp_ticketer-0.1.30.dist-info/METADATA,sha256=11bfR6cQYqZexr0tCmf4Tvw-vE0A5A1oQmsrK4kqFMM,13191
+mcp_ticketer-0.1.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mcp_ticketer-0.1.30.dist-info/entry_points.txt,sha256=o1IxVhnHnBNG7FZzbFq-Whcs1Djbofs0qMjiUYBLx2s,60
+mcp_ticketer-0.1.30.dist-info/top_level.txt,sha256=WnAG4SOT1Vm9tIwl70AbGG_nA217YyV3aWFhxLH2rxw,13
+mcp_ticketer-0.1.30.dist-info/RECORD,,