claude-mpm 4.0.29__py3-none-any.whl → 4.0.30__py3-none-any.whl

claude_mpm/services/diagnostics/checks/agent_check.py

@@ -0,0 +1,319 @@
+"""
+Check agent deployment and health.
+
+WHY: Verify that agents are properly deployed, up-to-date, and functioning correctly.
+"""
+
+from pathlib import Path
+from typing import Dict, Any, List
+
+from ..models import DiagnosticResult, DiagnosticStatus
+from .base_check import BaseDiagnosticCheck
+
+
+class AgentCheck(BaseDiagnosticCheck):
+    """Check agent deployment and configuration."""
+    
+    @property
+    def name(self) -> str:
+        return "agent_check"
+    
+    @property
+    def category(self) -> str:
+        return "Agents"
+    
+    def run(self) -> DiagnosticResult:
+        """Run agent diagnostics."""
+        try:
+            from ....services.agents.deployment.agent_validator import AgentValidator
+            from ....services.agents.deployment.agent_discovery_service import AgentDiscoveryService
+            
+            sub_results = []
+            details = {}
+            
+            # Get available agents
+            discovery = AgentDiscoveryService()
+            available_agents = discovery.discover_available_agents()
+            details["available_count"] = len(available_agents)
+            details["available_agents"] = [a.name for a in available_agents]
+            
+            # Check deployed agents
+            deployed_result = self._check_deployed_agents()
+            sub_results.append(deployed_result)
+            details["deployed_count"] = deployed_result.details.get("count", 0)
+            
+            # Check agent versions
+            version_result = self._check_agent_versions()
+            sub_results.append(version_result)
+            details["outdated_agents"] = version_result.details.get("outdated", [])
+            
+            # Validate agent configurations
+            validation_result = self._validate_agents()
+            sub_results.append(validation_result)
+            
+            # Check for common agent issues
+            issues_result = self._check_common_issues()
+            sub_results.append(issues_result)
+            
+            # Determine overall status
+            deployed_count = details["deployed_count"]
+            available_count = details["available_count"]
+            
+            if deployed_count == 0:
+                status = DiagnosticStatus.ERROR
+                message = f"No agents deployed (0/{available_count} available)"
+                fix_command = "claude-mpm agents deploy"
+                fix_description = "Deploy all available agents"
+            elif deployed_count < available_count:
+                status = DiagnosticStatus.WARNING
+                message = f"{deployed_count}/{available_count} agents deployed"
+                fix_command = "claude-mpm agents deploy"
+                fix_description = f"Deploy remaining {available_count - deployed_count} agents"
+            elif any(r.status == DiagnosticStatus.ERROR for r in sub_results):
+                status = DiagnosticStatus.ERROR
+                message = "Agents have critical issues"
+                fix_command = None
+                fix_description = None
+            elif any(r.status == DiagnosticStatus.WARNING for r in sub_results):
+                status = DiagnosticStatus.WARNING
+                message = "Agents have minor issues"
+                fix_command = None
+                fix_description = None
+            else:
+                status = DiagnosticStatus.OK
+                message = f"All {deployed_count} agents properly deployed"
+                fix_command = None
+                fix_description = None
+            
+            return DiagnosticResult(
+                category=self.category,
+                status=status,
+                message=message,
+                details=details,
+                fix_command=fix_command,
+                fix_description=fix_description,
+                sub_results=sub_results if self.verbose else []
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category=self.category,
+                status=DiagnosticStatus.ERROR,
+                message=f"Agent check failed: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_deployed_agents(self) -> DiagnosticResult:
+        """Check deployed agents in user directory."""
+        agents_dir = Path.home() / ".claude" / "agents"
+        
+        if not agents_dir.exists():
+            return DiagnosticResult(
+                category="Deployed Agents",
+                status=DiagnosticStatus.ERROR,
+                message="Agents directory does not exist",
+                details={"path": str(agents_dir), "count": 0},
+                fix_command="claude-mpm agents deploy",
+                fix_description="Create agents directory and deploy agents"
+            )
+        
+        # Count deployed agent files
+        agent_files = list(agents_dir.glob("*.md"))
+        
+        if not agent_files:
+            return DiagnosticResult(
+                category="Deployed Agents",
+                status=DiagnosticStatus.ERROR,
+                message="No agents deployed",
+                details={"path": str(agents_dir), "count": 0},
+                fix_command="claude-mpm agents deploy",
+                fix_description="Deploy available agents"
+            )
+        
+        # Check for required core agents
+        core_agents = ["research.md", "engineer.md", "qa.md", "documentation.md"]
+        deployed_names = [f.name for f in agent_files]
+        missing_core = [a for a in core_agents if a not in deployed_names]
+        
+        if missing_core:
+            return DiagnosticResult(
+                category="Deployed Agents",
+                status=DiagnosticStatus.WARNING,
+                message=f"Missing core agents: {', '.join(missing_core)}",
+                details={
+                    "path": str(agents_dir),
+                    "count": len(agent_files),
+                    "deployed": deployed_names,
+                    "missing_core": missing_core
+                },
+                fix_command="claude-mpm agents deploy",
+                fix_description="Deploy missing core agents"
+            )
+        
+        return DiagnosticResult(
+            category="Deployed Agents",
+            status=DiagnosticStatus.OK,
+            message=f"{len(agent_files)} agents deployed",
+            details={
+                "path": str(agents_dir),
+                "count": len(agent_files),
+                "deployed": deployed_names
+            }
+        )
+    
+    def _check_agent_versions(self) -> DiagnosticResult:
+        """Check if deployed agents are up-to-date."""
+        try:
+            from ....services.agents.deployment.agent_version_manager import AgentVersionManager
+            
+            version_manager = AgentVersionManager()
+            agents_dir = Path.home() / ".claude" / "agents"
+            
+            if not agents_dir.exists():
+                return DiagnosticResult(
+                    category="Agent Versions",
+                    status=DiagnosticStatus.SKIPPED,
+                    message="No agents to check",
+                    details={}
+                )
+            
+            outdated = []
+            checked = 0
+            
+            for agent_file in agents_dir.glob("*.md"):
+                checked += 1
+                agent_name = agent_file.stem
+                
+                # Check if agent needs update (simplified check)
+                if version_manager.needs_update(agent_name):
+                    outdated.append(agent_name)
+            
+            if outdated:
+                return DiagnosticResult(
+                    category="Agent Versions",
+                    status=DiagnosticStatus.WARNING,
+                    message=f"{len(outdated)} agent(s) outdated",
+                    details={"outdated": outdated, "checked": checked},
+                    fix_command="claude-mpm agents update",
+                    fix_description="Update agents to latest versions"
+                )
+            
+            if checked == 0:
+                return DiagnosticResult(
+                    category="Agent Versions",
+                    status=DiagnosticStatus.WARNING,
+                    message="No agents to check",
+                    details={"checked": 0}
+                )
+            
+            return DiagnosticResult(
+                category="Agent Versions",
+                status=DiagnosticStatus.OK,
+                message=f"All {checked} agents up-to-date",
+                details={"checked": checked}
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category="Agent Versions",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check versions: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _validate_agents(self) -> DiagnosticResult:
+        """Validate agent configurations."""
+        try:
+            from ....services.agents.deployment.agent_validator import AgentValidator
+            
+            validator = AgentValidator()
+            agents_dir = Path.home() / ".claude" / "agents"
+            
+            if not agents_dir.exists():
+                return DiagnosticResult(
+                    category="Agent Validation",
+                    status=DiagnosticStatus.SKIPPED,
+                    message="No agents to validate",
+                    details={}
+                )
+            
+            invalid = []
+            validated = 0
+            
+            for agent_file in agents_dir.glob("*.md"):
+                validated += 1
+                
+                # Basic validation
+                try:
+                    with open(agent_file, 'r') as f:
+                        content = f.read()
+                        
+                        # Check for required sections
+                        if "## Core Identity" not in content:
+                            invalid.append(f"{agent_file.stem}: missing Core Identity")
+                        elif len(content) < 100:
+                            invalid.append(f"{agent_file.stem}: file too small")
+                        
+                except Exception as e:
+                    invalid.append(f"{agent_file.stem}: {str(e)}")
+            
+            if invalid:
+                return DiagnosticResult(
+                    category="Agent Validation",
+                    status=DiagnosticStatus.WARNING,
+                    message=f"{len(invalid)} validation issue(s)",
+                    details={"issues": invalid, "validated": validated}
+                )
+            
+            return DiagnosticResult(
+                category="Agent Validation",
+                status=DiagnosticStatus.OK,
+                message=f"All {validated} agents valid",
+                details={"validated": validated}
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category="Agent Validation",
+                status=DiagnosticStatus.WARNING,
+                message=f"Validation failed: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_common_issues(self) -> DiagnosticResult:
+        """Check for common agent-related issues."""
+        issues = []
+        
+        # Check for duplicate agents
+        agents_dir = Path.home() / ".claude" / "agents"
+        if agents_dir.exists():
+            agent_names = {}
+            for agent_file in agents_dir.glob("*.md"):
+                name = agent_file.stem.lower()
+                if name in agent_names:
+                    issues.append(f"Duplicate agent: {agent_file.stem}")
+                else:
+                    agent_names[name] = agent_file
+        
+        # Check permissions
+        if agents_dir.exists():
+            import os
+            if not os.access(agents_dir, os.R_OK):
+                issues.append("Agents directory not readable")
+            if not os.access(agents_dir, os.W_OK):
+                issues.append("Agents directory not writable")
+        
+        if issues:
+            return DiagnosticResult(
+                category="Common Issues",
+                status=DiagnosticStatus.WARNING,
+                message=f"{len(issues)} issue(s) found",
+                details={"issues": issues}
+            )
+        
+        return DiagnosticResult(
+            category="Common Issues",
+            status=DiagnosticStatus.OK,
+            message="No common issues detected",
+            details={}
+        )

claude_mpm/services/diagnostics/checks/base_check.py

@@ -0,0 +1,64 @@
+"""
+Base interface for diagnostic checks.
+
+WHY: Define a consistent interface for all diagnostic checks to ensure
+they can be easily added, tested, and executed by the diagnostic runner.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from ..models import DiagnosticResult
+
+
+class BaseDiagnosticCheck(ABC):
+    """Base class for all diagnostic checks.
+    
+    WHY: Ensures all checks follow the same pattern and can be
+    executed uniformly by the diagnostic runner.
+    """
+    
+    def __init__(self, verbose: bool = False):
+        """Initialize the check.
+        
+        Args:
+            verbose: Whether to include detailed information in results
+        """
+        self.verbose = verbose
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Get the name of this check."""
+        pass
+    
+    @property
+    @abstractmethod
+    def category(self) -> str:
+        """Get the category this check belongs to."""
+        pass
+    
+    @property
+    def description(self) -> str:
+        """Get a description of what this check does."""
+        return f"Checking {self.category.lower()} health"
+    
+    @abstractmethod
+    def run(self) -> DiagnosticResult:
+        """Run the diagnostic check.
+        
+        Returns:
+            DiagnosticResult with the check results
+        """
+        pass
+    
+    def should_run(self) -> bool:
+        """Determine if this check should run.
+        
+        WHY: Some checks may not be applicable in certain environments
+        or configurations. This allows checks to opt out gracefully.
+        
+        Returns:
+            True if the check should run, False to skip
+        """
+        return True

claude_mpm/services/diagnostics/checks/claude_desktop_check.py

@@ -0,0 +1,283 @@
+"""
+Check Claude Desktop integration.
+
+WHY: Verify that Claude Desktop is installed, properly configured,
+and integrated with claude-mpm.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from ..models import DiagnosticResult, DiagnosticStatus
+from .base_check import BaseDiagnosticCheck
+
+
+class ClaudeDesktopCheck(BaseDiagnosticCheck):
+    """Check Claude Desktop installation and integration."""
+    
+    @property
+    def name(self) -> str:
+        return "claude_desktop_check"
+    
+    @property
+    def category(self) -> str:
+        return "Claude Desktop"
+    
+    def run(self) -> DiagnosticResult:
+        """Run Claude Desktop diagnostics."""
+        try:
+            sub_results = []
+            details = {}
+            
+            # Check if Claude Desktop is installed
+            install_result = self._check_installation()
+            sub_results.append(install_result)
+            details["installed"] = install_result.status == DiagnosticStatus.OK
+            
+            if install_result.status == DiagnosticStatus.OK:
+                # Check version compatibility
+                version_result = self._check_version()
+                sub_results.append(version_result)
+                details["version"] = version_result.details.get("version")
+                
+                # Check output style deployment
+                style_result = self._check_output_style()
+                sub_results.append(style_result)
+                details["output_style"] = style_result.details.get("deployed")
+                
+                # Check MCP integration
+                mcp_result = self._check_mcp_integration()
+                sub_results.append(mcp_result)
+                details["mcp_configured"] = mcp_result.status == DiagnosticStatus.OK
+            
+            # Determine overall status
+            if any(r.status == DiagnosticStatus.ERROR for r in sub_results):
+                status = DiagnosticStatus.ERROR
+                message = "Claude Desktop has critical issues"
+            elif any(r.status == DiagnosticStatus.WARNING for r in sub_results):
+                status = DiagnosticStatus.WARNING
+                message = "Claude Desktop needs configuration"
+            else:
+                status = DiagnosticStatus.OK
+                message = "Claude Desktop properly configured"
+            
+            return DiagnosticResult(
+                category=self.category,
+                status=status,
+                message=message,
+                details=details,
+                sub_results=sub_results if self.verbose else []
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category=self.category,
+                status=DiagnosticStatus.ERROR,
+                message=f"Claude Desktop check failed: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_installation(self) -> DiagnosticResult:
+        """Check if Claude Desktop is installed."""
+        # Check common installation paths
+        mac_path = Path("/Applications/Claude.app")
+        linux_paths = [
+            Path.home() / ".local/share/applications/claude.desktop",
+            Path("/usr/share/applications/claude.desktop"),
+            Path("/opt/Claude")
+        ]
+        windows_paths = [
+            Path("C:/Program Files/Claude/Claude.exe"),
+            Path.home() / "AppData/Local/Claude/Claude.exe"
+        ]
+        
+        # Check for Claude process
+        try:
+            result = subprocess.run(
+                ["pgrep", "-f", "Claude"],
+                capture_output=True,
+                timeout=2
+            )
+            if result.returncode == 0:
+                return DiagnosticResult(
+                    category="Claude Desktop Installation",
+                    status=DiagnosticStatus.OK,
+                    message="Claude Desktop is running",
+                    details={"running": True}
+                )
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+        
+        # Check installation paths
+        if mac_path.exists():
+            return DiagnosticResult(
+                category="Claude Desktop Installation",
+                status=DiagnosticStatus.OK,
+                message="Claude Desktop installed (macOS)",
+                details={"path": str(mac_path), "platform": "macos"}
+            )
+        
+        for path in linux_paths:
+            if path.exists():
+                return DiagnosticResult(
+                    category="Claude Desktop Installation",
+                    status=DiagnosticStatus.OK,
+                    message="Claude Desktop installed (Linux)",
+                    details={"path": str(path), "platform": "linux"}
+                )
+        
+        for path in windows_paths:
+            if path.exists():
+                return DiagnosticResult(
+                    category="Claude Desktop Installation",
+                    status=DiagnosticStatus.OK,
+                    message="Claude Desktop installed (Windows)",
+                    details={"path": str(path), "platform": "windows"}
+                )
+        
+        return DiagnosticResult(
+            category="Claude Desktop Installation",
+            status=DiagnosticStatus.WARNING,
+            message="Claude Desktop not found",
+            details={"installed": False},
+            fix_description="Install Claude Desktop from https://claude.ai/download"
+        )
+    
+    def _check_version(self) -> DiagnosticResult:
+        """Check Claude Desktop version compatibility."""
+        # Try to get version from config file
+        config_paths = [
+            Path.home() / "Library/Application Support/Claude/config.json",  # macOS
+            Path.home() / ".config/Claude/config.json",  # Linux
+            Path.home() / "AppData/Roaming/Claude/config.json"  # Windows
+        ]
+        
+        for config_path in config_paths:
+            if config_path.exists():
+                try:
+                    with open(config_path, 'r') as f:
+                        config = json.load(f)
+                        version = config.get("version", "unknown")
+                        
+                        # Simple version check (would need real version comparison logic)
+                        return DiagnosticResult(
+                            category="Claude Desktop Version",
+                            status=DiagnosticStatus.OK,
+                            message=f"Version: {version}",
+                            details={"version": version, "config_path": str(config_path)}
+                        )
+                except Exception:
+                    pass
+        
+        return DiagnosticResult(
+            category="Claude Desktop Version",
+            status=DiagnosticStatus.WARNING,
+            message="Could not determine version",
+            details={"version": "unknown"}
+        )
+    
+    def _check_output_style(self) -> DiagnosticResult:
+        """Check if output style is deployed."""
+        style_path = Path.home() / ".claude/responses/OUTPUT_STYLE.md"
+        
+        if not style_path.exists():
+            return DiagnosticResult(
+                category="Output Style",
+                status=DiagnosticStatus.WARNING,
+                message="Output style not deployed",
+                details={"deployed": False, "path": str(style_path)},
+                fix_command="claude-mpm deploy-style",
+                fix_description="Deploy claude-mpm output style for better formatting"
+            )
+        
+        # Check if it's up to date
+        try:
+            with open(style_path, 'r') as f:
+                content = f.read()
+                if "Claude MPM Output Style" in content:
+                    return DiagnosticResult(
+                        category="Output Style",
+                        status=DiagnosticStatus.OK,
+                        message="Output style deployed",
+                        details={"deployed": True, "path": str(style_path)}
+                    )
+                else:
+                    return DiagnosticResult(
+                        category="Output Style",
+                        status=DiagnosticStatus.WARNING,
+                        message="Output style outdated",
+                        details={"deployed": True, "outdated": True, "path": str(style_path)},
+                        fix_command="claude-mpm deploy-style --force",
+                        fix_description="Update output style to latest version"
+                    )
+        except Exception as e:
+            return DiagnosticResult(
+                category="Output Style",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check output style: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_mcp_integration(self) -> DiagnosticResult:
+        """Check MCP server integration with Claude Desktop."""
+        config_path = Path.home() / ".config/claude/claude_desktop_config.json"
+        
+        if not config_path.exists():
+            # Try alternate paths
+            alt_paths = [
+                Path.home() / "Library/Application Support/Claude/claude_desktop_config.json",
+                Path.home() / "AppData/Roaming/Claude/claude_desktop_config.json"
+            ]
+            for alt_path in alt_paths:
+                if alt_path.exists():
+                    config_path = alt_path
+                    break
+            else:
+                return DiagnosticResult(
+                    category="MCP Integration",
+                    status=DiagnosticStatus.WARNING,
+                    message="Claude Desktop config not found",
+                    details={"configured": False},
+                    fix_command="claude-mpm mcp install",
+                    fix_description="Install MCP server integration"
+                )
+        
+        try:
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+                
+                mcp_servers = config.get("mcpServers", {})
+                if "claude-mpm-gateway" in mcp_servers:
+                    return DiagnosticResult(
+                        category="MCP Integration",
+                        status=DiagnosticStatus.OK,
+                        message="MCP server configured",
+                        details={
+                            "configured": True,
+                            "server_count": len(mcp_servers),
+                            "config_path": str(config_path)
+                        }
+                    )
+                else:
+                    return DiagnosticResult(
+                        category="MCP Integration",
+                        status=DiagnosticStatus.WARNING,
+                        message="MCP server not configured",
+                        details={
+                            "configured": False,
+                            "server_count": len(mcp_servers),
+                            "config_path": str(config_path)
+                        },
+                        fix_command="claude-mpm mcp install",
+                        fix_description="Configure MCP server for Claude Desktop"
+                    )
+                    
+        except Exception as e:
+            return DiagnosticResult(
+                category="MCP Integration",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check MCP configuration: {str(e)}",
+                details={"error": str(e)}
+            )