claude-mpm 4.1.26__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/diagnostics/__init__.py

@@ -13,6 +13,6 @@ DESIGN DECISIONS:
 
 from .diagnostic_runner import DiagnosticRunner
 from .doctor_reporter import DoctorReporter
-from .models import DiagnosticResult, DiagnosticStatus
+from .models import DiagnosticResult
 
-__all__ = ["DiagnosticResult", "DiagnosticRunner", "DiagnosticStatus", "DoctorReporter"]
+__all__ = ["DiagnosticResult", "DiagnosticRunner", "DoctorReporter"]

claude_mpm/services/diagnostics/checks/__init__.py

@@ -7,26 +7,28 @@ diagnostic components.
 
 from .agent_check import AgentCheck
 from .base_check import BaseDiagnosticCheck
-from .claude_desktop_check import ClaudeDesktopCheck
+from .claude_code_check import ClaudeCodeCheck
 from .common_issues_check import CommonIssuesCheck
 from .configuration_check import ConfigurationCheck
 from .filesystem_check import FilesystemCheck
 from .installation_check import InstallationCheck
 from .instructions_check import InstructionsCheck
 from .mcp_check import MCPCheck
+from .mcp_services_check import MCPServicesCheck
 from .monitor_check import MonitorCheck
 from .startup_log_check import StartupLogCheck
 
 __all__ = [
     "AgentCheck",
     "BaseDiagnosticCheck",
-    "ClaudeDesktopCheck",
+    "ClaudeCodeCheck",
     "CommonIssuesCheck",
     "ConfigurationCheck",
     "FilesystemCheck",
     "InstallationCheck",
     "InstructionsCheck",
     "MCPCheck",
+    "MCPServicesCheck",
     "MonitorCheck",
     "StartupLogCheck",
 ]

claude_mpm/services/diagnostics/checks/agent_check.py

@@ -6,7 +6,8 @@ WHY: Verify that agents are properly deployed, up-to-date, and functioning corre
 
 from pathlib import Path
 
-from ..models import DiagnosticResult, DiagnosticStatus
+from ....core.enums import OperationResult, ValidationSeverity
+from ..models import DiagnosticResult
 from .base_check import BaseDiagnosticCheck
 
 
@@ -64,29 +65,29 @@ class AgentCheck(BaseDiagnosticCheck):
             available_count = details["available_count"]
 
             if deployed_count == 0:
-                status = DiagnosticStatus.ERROR
+                status = ValidationSeverity.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
+                status = ValidationSeverity.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
+            elif any(r.status == ValidationSeverity.ERROR for r in sub_results):
+                status = ValidationSeverity.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
+            elif any(r.status == ValidationSeverity.WARNING for r in sub_results):
+                status = ValidationSeverity.WARNING
                 message = "Agents have minor issues"
                 fix_command = None
                 fix_description = None
             else:
-                status = DiagnosticStatus.OK
+                status = OperationResult.SUCCESS
                 message = f"All {deployed_count} agents properly deployed"
                 fix_command = None
                 fix_description = None
@@ -104,17 +105,16 @@ class AgentCheck(BaseDiagnosticCheck):
         except Exception as e:
             return DiagnosticResult(
                 category=self.category,
-                status=DiagnosticStatus.ERROR,
+                status=ValidationSeverity.ERROR,
                 message=f"Agent check failed: {e!s}",
                 details={"error": str(e)},
             )
 
     def _check_deployed_agents(self) -> DiagnosticResult:
         """Check deployed agents in both project and user directories."""
-        import os
 
         # Check project-level agents first (preferred in development)
-        project_agents_dir = Path(os.getcwd()) / ".claude" / "agents"
+        project_agents_dir = Path(Path.cwd()) / ".claude" / "agents"
         user_agents_dir = Path.home() / ".claude" / "agents"
 
         # Determine which directory to check
@@ -128,7 +128,7 @@ class AgentCheck(BaseDiagnosticCheck):
             # Neither exists, default to user directory for error message
             return DiagnosticResult(
                 category="Deployed Agents",
-                status=DiagnosticStatus.ERROR,
+                status=ValidationSeverity.ERROR,
                 message="No agents directory found (checked project and user)",
                 details={
                     "project_path": str(project_agents_dir),
@@ -145,7 +145,7 @@ class AgentCheck(BaseDiagnosticCheck):
         if not agent_files:
             return DiagnosticResult(
                 category="Deployed Agents",
-                status=DiagnosticStatus.ERROR,
+                status=ValidationSeverity.ERROR,
                 message=f"No agents deployed in {location} directory",
                 details={"path": str(agents_dir), "location": location, "count": 0},
                 fix_command="claude-mpm agents deploy",
@@ -160,7 +160,7 @@ class AgentCheck(BaseDiagnosticCheck):
         if missing_core:
             return DiagnosticResult(
                 category="Deployed Agents",
-                status=DiagnosticStatus.WARNING,
+                status=ValidationSeverity.WARNING,
                 message=f"Missing core agents in {location}: {', '.join(missing_core)}",
                 details={
                     "path": str(agents_dir),
@@ -175,7 +175,7 @@ class AgentCheck(BaseDiagnosticCheck):
 
         return DiagnosticResult(
             category="Deployed Agents",
-            status=DiagnosticStatus.OK,
+            status=OperationResult.SUCCESS,
             message=f"{len(agent_files)} agents deployed ({location} level)",
             details={
                 "path": str(agents_dir),
@@ -188,7 +188,6 @@ class AgentCheck(BaseDiagnosticCheck):
     def _check_agent_versions(self) -> DiagnosticResult:
         """Check if deployed agents are up-to-date."""
         try:
-            import os
 
             from ....services.agents.deployment.agent_version_manager import (
                 AgentVersionManager,
@@ -197,7 +196,7 @@ class AgentCheck(BaseDiagnosticCheck):
             version_manager = AgentVersionManager()
 
             # Check both project and user directories
-            project_agents_dir = Path(os.getcwd()) / ".claude" / "agents"
+            project_agents_dir = Path(Path.cwd()) / ".claude" / "agents"
             user_agents_dir = Path.home() / ".claude" / "agents"
 
             if project_agents_dir.exists():
@@ -207,7 +206,7 @@ class AgentCheck(BaseDiagnosticCheck):
             else:
                 return DiagnosticResult(
                     category="Agent Versions",
-                    status=DiagnosticStatus.SKIPPED,
+                    status=OperationResult.SKIPPED,
                     message="No agents to check",
                     details={},
                 )
@@ -226,7 +225,7 @@ class AgentCheck(BaseDiagnosticCheck):
             if outdated:
                 return DiagnosticResult(
                     category="Agent Versions",
-                    status=DiagnosticStatus.WARNING,
+                    status=ValidationSeverity.WARNING,
                     message=f"{len(outdated)} agent(s) outdated",
                     details={"outdated": outdated, "checked": checked},
                     fix_command="claude-mpm agents update",
@@ -236,14 +235,14 @@ class AgentCheck(BaseDiagnosticCheck):
             if checked == 0:
                 return DiagnosticResult(
                     category="Agent Versions",
-                    status=DiagnosticStatus.WARNING,
+                    status=ValidationSeverity.WARNING,
                     message="No agents to check",
                     details={"checked": 0},
                 )
 
             return DiagnosticResult(
                 category="Agent Versions",
-                status=DiagnosticStatus.OK,
+                status=OperationResult.SUCCESS,
                 message=f"All {checked} agents up-to-date",
                 details={"checked": checked},
             )
@@ -251,7 +250,7 @@ class AgentCheck(BaseDiagnosticCheck):
         except Exception as e:
             return DiagnosticResult(
                 category="Agent Versions",
-                status=DiagnosticStatus.WARNING,
+                status=ValidationSeverity.WARNING,
                 message=f"Could not check versions: {e!s}",
                 details={"error": str(e)},
             )
@@ -259,14 +258,13 @@ class AgentCheck(BaseDiagnosticCheck):
     def _validate_agents(self) -> DiagnosticResult:
         """Validate agent configurations."""
         try:
-            import os
 
             from ....services.agents.deployment.agent_validator import AgentValidator
 
             AgentValidator()
 
             # Check both project and user directories
-            project_agents_dir = Path(os.getcwd()) / ".claude" / "agents"
+            project_agents_dir = Path(Path.cwd()) / ".claude" / "agents"
             user_agents_dir = Path.home() / ".claude" / "agents"
 
             if project_agents_dir.exists():
@@ -276,7 +274,7 @@ class AgentCheck(BaseDiagnosticCheck):
             else:
                 return DiagnosticResult(
                     category="Agent Validation",
-                    status=DiagnosticStatus.SKIPPED,
+                    status=OperationResult.SKIPPED,
                     message="No agents to validate",
                     details={},
                 )
@@ -289,7 +287,7 @@ class AgentCheck(BaseDiagnosticCheck):
 
                 # Basic validation
                 try:
-                    with open(agent_file) as f:
+                    with agent_file.open() as f:
                         content = f.read()
 
                         # Check for required sections
@@ -304,14 +302,14 @@ class AgentCheck(BaseDiagnosticCheck):
             if invalid:
                 return DiagnosticResult(
                     category="Agent Validation",
-                    status=DiagnosticStatus.WARNING,
+                    status=ValidationSeverity.WARNING,
                     message=f"{len(invalid)} validation issue(s)",
                     details={"issues": invalid, "validated": validated},
                 )
 
             return DiagnosticResult(
                 category="Agent Validation",
-                status=DiagnosticStatus.OK,
+                status=OperationResult.SUCCESS,
                 message=f"All {validated} agents valid",
                 details={"validated": validated},
             )
@@ -319,7 +317,7 @@ class AgentCheck(BaseDiagnosticCheck):
         except Exception as e:
             return DiagnosticResult(
                 category="Agent Validation",
-                status=DiagnosticStatus.WARNING,
+                status=ValidationSeverity.WARNING,
                 message=f"Validation failed: {e!s}",
                 details={"error": str(e)},
             )
@@ -331,7 +329,7 @@ class AgentCheck(BaseDiagnosticCheck):
         issues = []
 
         # Check both project and user directories
-        project_agents_dir = Path(os.getcwd()) / ".claude" / "agents"
+        project_agents_dir = Path(Path.cwd()) / ".claude" / "agents"
         user_agents_dir = Path.home() / ".claude" / "agents"
 
         if project_agents_dir.exists():
@@ -361,14 +359,14 @@ class AgentCheck(BaseDiagnosticCheck):
         if issues:
             return DiagnosticResult(
                 category="Common Issues",
-                status=DiagnosticStatus.WARNING,
+                status=ValidationSeverity.WARNING,
                 message=f"{len(issues)} issue(s) found",
                 details={"issues": issues},
             )
 
         return DiagnosticResult(
             category="Common Issues",
-            status=DiagnosticStatus.OK,
+            status=OperationResult.SUCCESS,
             message="No common issues detected",
             details={},
         )

claude_mpm/services/diagnostics/checks/claude_code_check.py

@@ -0,0 +1,270 @@
+"""
+Check Claude Code (CLI) integration.
+
+WHY: Verify that Claude Code CLI is installed, properly configured,
+and integrated with claude-mpm.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+
+from ....core.enums import OperationResult, ValidationSeverity
+from ..models import DiagnosticResult
+from .base_check import BaseDiagnosticCheck
+
+
+class ClaudeCodeCheck(BaseDiagnosticCheck):
+    """Check Claude Code CLI installation and integration."""
+
+    @property
+    def name(self) -> str:
+        return "claude_code_check"
+
+    @property
+    def category(self) -> str:
+        return "Claude Code"
+
+    def run(self) -> DiagnosticResult:
+        """Run Claude Code CLI diagnostics."""
+        try:
+            sub_results = []
+            details = {}
+
+            # Check if Claude Code CLI is installed
+            install_result = self._check_installation()
+            sub_results.append(install_result)
+            details["installed"] = install_result.status == OperationResult.SUCCESS
+
+            if install_result.status == OperationResult.SUCCESS:
+                # 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 == OperationResult.SUCCESS
+
+            # Determine overall status
+            if any(r.status == ValidationSeverity.ERROR for r in sub_results):
+                status = ValidationSeverity.ERROR
+                message = "Claude Code CLI has critical issues"
+            elif any(r.status == ValidationSeverity.WARNING for r in sub_results):
+                status = ValidationSeverity.WARNING
+                message = "Claude Code CLI needs configuration"
+            else:
+                status = OperationResult.SUCCESS
+                message = "Claude Code CLI 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=ValidationSeverity.ERROR,
+                message=f"Claude Code CLI check failed: {e!s}",
+                details={"error": str(e)},
+            )
+
+    def _check_installation(self) -> DiagnosticResult:
+        """Check if Claude Code CLI is installed."""
+        # Check if claude command is available
+        try:
+            result = subprocess.run(
+                ["claude", "--version"],
+                capture_output=True,
+                timeout=5,
+                check=False,
+                text=True,
+            )
+            if result.returncode == 0:
+                return DiagnosticResult(
+                    category="Claude Code CLI Installation",
+                    status=OperationResult.SUCCESS,
+                    message="Claude Code CLI is installed and accessible",
+                    details={
+                        "installed": True,
+                        "path": "claude",
+                        "version_output": result.stdout.strip(),
+                    },
+                )
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+
+        # Check common installation paths
+        possible_paths = [
+            Path("/usr/local/bin/claude"),
+            Path.home() / ".local/bin/claude",
+            Path("/opt/homebrew/bin/claude"),
+            Path("/usr/bin/claude"),
+        ]
+
+        for path in possible_paths:
+            if path.exists() and path.is_file():
+                return DiagnosticResult(
+                    category="Claude Code CLI Installation",
+                    status=OperationResult.SUCCESS,
+                    message=f"Claude Code CLI found at {path}",
+                    details={"installed": True, "path": str(path)},
+                )
+
+        return DiagnosticResult(
+            category="Claude Code CLI Installation",
+            status=ValidationSeverity.ERROR,
+            message="Claude Code CLI not found",
+            details={"installed": False},
+            fix_description="Install Claude Code CLI from https://claude.ai/code",
+        )
+
+    def _check_version(self) -> DiagnosticResult:
+        """Check Claude Code CLI version compatibility."""
+        try:
+            result = subprocess.run(
+                ["claude", "--version"],
+                capture_output=True,
+                timeout=5,
+                check=True,
+                text=True,
+            )
+            version_output = result.stdout.strip()
+
+            # Extract version number (basic parsing)
+            version = "unknown"
+            if "version" in version_output.lower():
+                parts = version_output.split()
+                for i, part in enumerate(parts):
+                    if "version" in part.lower() and i + 1 < len(parts):
+                        version = parts[i + 1]
+                        break
+
+            # Check minimum version requirement (1.0.60+)
+            status = OperationResult.SUCCESS
+            message = f"Version: {version}"
+
+            return DiagnosticResult(
+                category="Claude Code CLI Version",
+                status=status,
+                message=message,
+                details={
+                    "version": version,
+                    "version_output": version_output,
+                },
+            )
+
+        except subprocess.SubprocessError as e:
+            return DiagnosticResult(
+                category="Claude Code CLI Version",
+                status=ValidationSeverity.WARNING,
+                message=f"Could not determine version: {e}",
+                details={"version": "unknown", "error": str(e)},
+            )
+
+    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=ValidationSeverity.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 style_path.open() as f:
+                content = f.read()
+                if "Claude MPM Output Style" in content:
+                    return DiagnosticResult(
+                        category="Output Style",
+                        status=OperationResult.SUCCESS,
+                        message="Output style deployed",
+                        details={"deployed": True, "path": str(style_path)},
+                    )
+                return DiagnosticResult(
+                    category="Output Style",
+                    status=ValidationSeverity.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=ValidationSeverity.WARNING,
+                message=f"Could not check output style: {e!s}",
+                details={"error": str(e)},
+            )
+
+    def _check_mcp_integration(self) -> DiagnosticResult:
+        """Check MCP server integration with Claude Code CLI."""
+        # Claude Code CLI uses ~/.claude.json for configuration
+        config_path = Path.home() / ".claude.json"
+
+        if not config_path.exists():
+            return DiagnosticResult(
+                category="MCP Integration",
+                status=ValidationSeverity.WARNING,
+                message="Claude Code CLI config not found",
+                details={"configured": False, "config_path": str(config_path)},
+                fix_command="claude-mpm mcp install",
+                fix_description="Install MCP server integration for Claude Code CLI",
+            )
+
+        try:
+            with config_path.open() as f:
+                config = json.load(f)
+
+                mcp_servers = config.get("mcpServers", {})
+                if "claude-mpm-gateway" in mcp_servers or "claude-mpm" in mcp_servers:
+                    return DiagnosticResult(
+                        category="MCP Integration",
+                        status=OperationResult.SUCCESS,
+                        message="MCP server configured",
+                        details={
+                            "configured": True,
+                            "server_count": len(mcp_servers),
+                            "config_path": str(config_path),
+                        },
+                    )
+                return DiagnosticResult(
+                    category="MCP Integration",
+                    status=ValidationSeverity.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 Code CLI",
+                )
+
+        except Exception as e:
+            return DiagnosticResult(
+                category="MCP Integration",
+                status=ValidationSeverity.WARNING,
+                message=f"Could not check MCP configuration: {e!s}",
+                details={"error": str(e)},
+            )