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

claude_mpm/services/diagnostics/checks/filesystem_check.py

@@ -0,0 +1,233 @@
+"""
+Check filesystem permissions and disk space.
+
+WHY: Verify that claude-mpm has proper filesystem access and sufficient
+disk space for operation.
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Dict, Any
+
+from ..models import DiagnosticResult, DiagnosticStatus
+from .base_check import BaseDiagnosticCheck
+
+
+class FilesystemCheck(BaseDiagnosticCheck):
+    """Check filesystem health and permissions."""
+    
+    @property
+    def name(self) -> str:
+        return "filesystem_check"
+    
+    @property
+    def category(self) -> str:
+        return "File System"
+    
+    def run(self) -> DiagnosticResult:
+        """Run filesystem diagnostics."""
+        try:
+            sub_results = []
+            details = {}
+            
+            # Check critical directory permissions
+            perm_result = self._check_permissions()
+            sub_results.append(perm_result)
+            details["permissions"] = perm_result.details
+            
+            # Check disk space
+            space_result = self._check_disk_space()
+            sub_results.append(space_result)
+            details["disk_space"] = space_result.details
+            
+            # Check .claude directory structure
+            structure_result = self._check_directory_structure()
+            sub_results.append(structure_result)
+            details["structure"] = structure_result.details
+            
+            # Determine overall status
+            if any(r.status == DiagnosticStatus.ERROR for r in sub_results):
+                status = DiagnosticStatus.ERROR
+                message = "File system has critical issues"
+            elif any(r.status == DiagnosticStatus.WARNING for r in sub_results):
+                status = DiagnosticStatus.WARNING
+                message = "File system has minor issues"
+            else:
+                status = DiagnosticStatus.OK
+                message = "File system healthy"
+            
+            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"Filesystem check failed: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_permissions(self) -> DiagnosticResult:
+        """Check permissions for critical directories."""
+        critical_dirs = [
+            Path.home() / ".claude",
+            Path.home() / ".claude" / "agents",
+            Path.home() / ".claude" / "responses",
+            Path.cwd() / ".claude"
+        ]
+        
+        issues = []
+        checked = []
+        
+        for dir_path in critical_dirs:
+            if dir_path.exists():
+                checked.append(str(dir_path))
+                
+                # Check read permission
+                if not os.access(dir_path, os.R_OK):
+                    issues.append(f"{dir_path} not readable")
+                
+                # Check write permission
+                if not os.access(dir_path, os.W_OK):
+                    issues.append(f"{dir_path} not writable")
+                
+                # Check execute permission (needed to list directory)
+                if not os.access(dir_path, os.X_OK):
+                    issues.append(f"{dir_path} not accessible")
+        
+        if issues:
+            return DiagnosticResult(
+                category="Permissions",
+                status=DiagnosticStatus.ERROR,
+                message=f"{len(issues)} permission issue(s)",
+                details={"issues": issues, "checked": checked},
+                fix_command="chmod -R 755 ~/.claude",
+                fix_description="Fix directory permissions"
+            )
+        
+        if not checked:
+            return DiagnosticResult(
+                category="Permissions",
+                status=DiagnosticStatus.WARNING,
+                message="No claude directories found",
+                details={"checked": [], "missing": [str(d) for d in critical_dirs]}
+            )
+        
+        return DiagnosticResult(
+            category="Permissions",
+            status=DiagnosticStatus.OK,
+            message="All permissions valid",
+            details={"checked": checked}
+        )
+    
+    def _check_disk_space(self) -> DiagnosticResult:
+        """Check available disk space."""
+        try:
+            # Check home directory disk usage
+            home_path = Path.home()
+            stat = shutil.disk_usage(home_path)
+            
+            free_gb = stat.free / (1024 ** 3)
+            total_gb = stat.total / (1024 ** 3)
+            used_percent = (stat.used / stat.total) * 100
+            
+            details = {
+                "free_gb": round(free_gb, 2),
+                "total_gb": round(total_gb, 2),
+                "used_percent": round(used_percent, 1),
+                "path": str(home_path)
+            }
+            
+            # Check for low disk space
+            if free_gb < 0.1:  # Less than 100MB
+                return DiagnosticResult(
+                    category="Disk Space",
+                    status=DiagnosticStatus.ERROR,
+                    message=f"Critical: Only {free_gb:.2f}GB free",
+                    details=details,
+                    fix_description="Free up disk space immediately"
+                )
+            elif free_gb < 1:  # Less than 1GB
+                return DiagnosticResult(
+                    category="Disk Space",
+                    status=DiagnosticStatus.WARNING,
+                    message=f"Low disk space: {free_gb:.2f}GB free",
+                    details=details,
+                    fix_description="Consider freeing up disk space"
+                )
+            
+            return DiagnosticResult(
+                category="Disk Space",
+                status=DiagnosticStatus.OK,
+                message=f"{free_gb:.1f}GB available",
+                details=details
+            )
+            
+        except Exception as e:
+            return DiagnosticResult(
+                category="Disk Space",
+                status=DiagnosticStatus.WARNING,
+                message=f"Could not check disk space: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_directory_structure(self) -> DiagnosticResult:
+        """Check claude directory structure."""
+        base_dir = Path.home() / ".claude"
+        
+        expected_dirs = {
+            "agents": "Agent deployment directory",
+            "responses": "Response logging directory",
+            "memory": "Agent memory storage",
+            "logs": "Application logs"
+        }
+        
+        missing = []
+        present = []
+        
+        if not base_dir.exists():
+            return DiagnosticResult(
+                category="Directory Structure",
+                status=DiagnosticStatus.WARNING,
+                message="Base .claude directory missing",
+                details={"base_dir": str(base_dir), "exists": False},
+                fix_command="mkdir -p ~/.claude/{agents,responses,memory,logs}",
+                fix_description="Create claude directory structure"
+            )
+        
+        for dir_name, description in expected_dirs.items():
+            dir_path = base_dir / dir_name
+            if dir_path.exists():
+                present.append(dir_name)
+            else:
+                missing.append(dir_name)
+        
+        if missing:
+            return DiagnosticResult(
+                category="Directory Structure",
+                status=DiagnosticStatus.WARNING,
+                message=f"Missing {len(missing)} subdirectory(s)",
+                details={
+                    "base_dir": str(base_dir),
+                    "missing": missing,
+                    "present": present
+                },
+                fix_command=f"mkdir -p ~/.claude/{{{','.join(missing)}}}",
+                fix_description="Create missing directories"
+            )
+        
+        return DiagnosticResult(
+            category="Directory Structure",
+            status=DiagnosticStatus.OK,
+            message="Directory structure complete",
+            details={
+                "base_dir": str(base_dir),
+                "directories": present
+            }
+        )

claude_mpm/services/diagnostics/checks/installation_check.py

@@ -0,0 +1,255 @@
+"""
+Check claude-mpm installation health.
+
+WHY: Verify that claude-mpm is properly installed with correct Python version,
+dependencies, and installation method.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, Any
+
+from ..models import DiagnosticResult, DiagnosticStatus
+from .base_check import BaseDiagnosticCheck
+
+
+class InstallationCheck(BaseDiagnosticCheck):
+    """Check claude-mpm installation and dependencies."""
+    
+    @property
+    def name(self) -> str:
+        return "installation_check"
+    
+    @property
+    def category(self) -> str:
+        return "Installation"
+    
+    def run(self) -> DiagnosticResult:
+        """Run installation diagnostics."""
+        try:
+            details = {}
+            sub_results = []
+            
+            # Check Python version
+            python_result = self._check_python_version()
+            sub_results.append(python_result)
+            details["python_version"] = python_result.details.get("version")
+            
+            # Check claude-mpm version
+            version_result = self._check_claude_mpm_version()
+            sub_results.append(version_result)
+            details["claude_mpm_version"] = version_result.details.get("version")
+            details["build_number"] = version_result.details.get("build_number")
+            
+            # Check installation method
+            method_result = self._check_installation_method()
+            sub_results.append(method_result)
+            details["installation_method"] = method_result.details.get("method")
+            
+            # Check critical dependencies
+            deps_result = self._check_dependencies()
+            sub_results.append(deps_result)
+            details["dependencies"] = deps_result.details.get("status")
+            
+            # Determine overall status
+            if any(r.status == DiagnosticStatus.ERROR for r in sub_results):
+                status = DiagnosticStatus.ERROR
+                message = "Installation has critical issues"
+            elif any(r.status == DiagnosticStatus.WARNING for r in sub_results):
+                status = DiagnosticStatus.WARNING
+                message = "Installation has minor issues"
+            else:
+                status = DiagnosticStatus.OK
+                message = "Installation is healthy"
+            
+            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"Installation check failed: {str(e)}",
+                details={"error": str(e)}
+            )
+    
+    def _check_python_version(self) -> DiagnosticResult:
+        """Check Python version compatibility."""
+        version = sys.version
+        version_info = sys.version_info
+        
+        min_version = (3, 9)
+        recommended_version = (3, 11)
+        
+        if version_info < min_version:
+            return DiagnosticResult(
+                category="Python Version",
+                status=DiagnosticStatus.ERROR,
+                message=f"Python {version_info.major}.{version_info.minor} is below minimum required {min_version[0]}.{min_version[1]}",
+                details={"version": version},
+                fix_description="Upgrade Python to 3.9 or higher"
+            )
+        elif version_info < recommended_version:
+            return DiagnosticResult(
+                category="Python Version",
+                status=DiagnosticStatus.WARNING,
+                message=f"Python {version_info.major}.{version_info.minor} works but {recommended_version[0]}.{recommended_version[1]}+ is recommended",
+                details={"version": version}
+            )
+        else:
+            return DiagnosticResult(
+                category="Python Version",
+                status=DiagnosticStatus.OK,
+                message=f"Python {version_info.major}.{version_info.minor}.{version_info.micro}",
+                details={"version": version}
+            )
+    
+    def _check_claude_mpm_version(self) -> DiagnosticResult:
+        """Check claude-mpm version."""
+        try:
+            from ....services.version_service import VersionService
+            
+            service = VersionService()
+            version = service.get_version()
+            semantic_version = service.get_semantic_version()
+            build_number = service.get_build_number()
+            
+            return DiagnosticResult(
+                category="Claude MPM Version",
+                status=DiagnosticStatus.OK,
+                message=f"Version: {version}",
+                details={
+                    "version": semantic_version,
+                    "build_number": build_number,
+                    "display_version": version
+                }
+            )
+        except Exception as e:
+            return DiagnosticResult(
+                category="Claude MPM Version",
+                status=DiagnosticStatus.WARNING,
+                message="Could not determine version",
+                details={"error": str(e)}
+            )
+    
+    def _check_installation_method(self) -> DiagnosticResult:
+        """Detect how claude-mpm was installed."""
+        methods_found = []
+        
+        # Check for pipx
+        try:
+            result = subprocess.run(
+                ["pipx", "list"], 
+                capture_output=True, 
+                text=True,
+                timeout=5
+            )
+            if "claude-mpm" in result.stdout:
+                methods_found.append("pipx")
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+        
+        # Check for pip installation
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "show", "claude-mpm"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                methods_found.append("pip")
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+        
+        # Check for development installation
+        claude_mpm_path = Path(__file__).parent.parent.parent.parent.parent
+        if (claude_mpm_path / "pyproject.toml").exists():
+            if (claude_mpm_path / ".git").exists():
+                methods_found.append("development")
+        
+        if not methods_found:
+            return DiagnosticResult(
+                category="Installation Method",
+                status=DiagnosticStatus.WARNING,
+                message="Installation method unknown",
+                details={"method": "unknown"}
+            )
+        elif "pipx" in methods_found:
+            return DiagnosticResult(
+                category="Installation Method",
+                status=DiagnosticStatus.OK,
+                message="Installed via pipx (recommended)",
+                details={"method": "pipx", "all_methods": methods_found}
+            )
+        elif "development" in methods_found:
+            return DiagnosticResult(
+                category="Installation Method",
+                status=DiagnosticStatus.OK,
+                message="Development installation",
+                details={"method": "development", "all_methods": methods_found}
+            )
+        else:
+            return DiagnosticResult(
+                category="Installation Method",
+                status=DiagnosticStatus.OK,
+                message=f"Installed via {methods_found[0]}",
+                details={"method": methods_found[0], "all_methods": methods_found}
+            )
+    
+    def _check_dependencies(self) -> DiagnosticResult:
+        """Check critical dependencies."""
+        missing = []
+        warnings = []
+        
+        critical_packages = [
+            "aiohttp",
+            "click", 
+            "pyyaml",
+            "python-socketio",
+            "aiofiles"
+        ]
+        
+        for package in critical_packages:
+            try:
+                __import__(package.replace("-", "_"))
+            except ImportError:
+                missing.append(package)
+        
+        # Check optional but recommended packages
+        optional_packages = ["rich", "tabulate"]
+        for package in optional_packages:
+            try:
+                __import__(package)
+            except ImportError:
+                warnings.append(package)
+        
+        if missing:
+            return DiagnosticResult(
+                category="Dependencies",
+                status=DiagnosticStatus.ERROR,
+                message=f"Missing critical dependencies: {', '.join(missing)}",
+                details={"missing": missing, "optional_missing": warnings},
+                fix_command="pip install -e .",
+                fix_description="Reinstall claude-mpm with dependencies"
+            )
+        elif warnings:
+            return DiagnosticResult(
+                category="Dependencies",
+                status=DiagnosticStatus.WARNING,
+                message=f"Missing optional dependencies: {', '.join(warnings)}",
+                details={"optional_missing": warnings, "status": "partial"}
+            )
+        else:
+            return DiagnosticResult(
+                category="Dependencies",
+                status=DiagnosticStatus.OK,
+                message="All dependencies installed",
+                details={"status": "complete"}
+            )