claude-mpm 4.1.0__py3-none-any.whl → 4.1.2__py3-none-any.whl

claude_mpm/services/diagnostics/checks/configuration_check.py

@@ -7,7 +7,7 @@ and properly structured.
 
 import os
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Any, Dict
 
 import yaml
 
@@ -17,40 +17,40 @@ from .base_check import BaseDiagnosticCheck
 
 class ConfigurationCheck(BaseDiagnosticCheck):
     """Check configuration files and settings."""
-    
+
     @property
     def name(self) -> str:
         return "configuration_check"
-    
+
     @property
     def category(self) -> str:
         return "Configuration"
-    
+
     def run(self) -> DiagnosticResult:
         """Run configuration diagnostics."""
         try:
             sub_results = []
             details = {}
-            
+
             # Check user configuration
             user_result = self._check_user_config()
             sub_results.append(user_result)
             details["user_config"] = user_result.details
-            
+
             # Check project configuration
             project_result = self._check_project_config()
             sub_results.append(project_result)
             details["project_config"] = project_result.details
-            
+
             # Check environment variables
             env_result = self._check_environment_variables()
             sub_results.append(env_result)
             details["environment"] = env_result.details
-            
+
             # Check configuration permissions
             perm_result = self._check_config_permissions()
             sub_results.append(perm_result)
-            
+
             # Determine overall status
             if any(r.status == DiagnosticStatus.ERROR for r in sub_results):
                 status = DiagnosticStatus.ERROR
@@ -61,48 +61,48 @@ class ConfigurationCheck(BaseDiagnosticCheck):
             else:
                 status = DiagnosticStatus.OK
                 message = "Configuration is valid"
-            
+
             return DiagnosticResult(
                 category=self.category,
                 status=status,
                 message=message,
                 details=details,
-                sub_results=sub_results if self.verbose else []
+                sub_results=sub_results if self.verbose else [],
             )
-            
+
         except Exception as e:
             return DiagnosticResult(
                 category=self.category,
                 status=DiagnosticStatus.ERROR,
-                message=f"Configuration check failed: {str(e)}",
-                details={"error": str(e)}
+                message=f"Configuration check failed: {e!s}",
+                details={"error": str(e)},
             )
-    
+
     def _check_user_config(self) -> DiagnosticResult:
         """Check user-level configuration."""
         config_path = Path.home() / ".claude" / "claude-mpm.yaml"
-        
+
         if not config_path.exists():
             return DiagnosticResult(
                 category="User Config",
                 status=DiagnosticStatus.OK,
                 message="No user configuration (using defaults)",
-                details={"path": str(config_path), "exists": False}
+                details={"path": str(config_path), "exists": False},
             )
-        
+
         try:
-            with open(config_path, 'r') as f:
+            with open(config_path) as f:
                 config = yaml.safe_load(f)
-            
+
             issues = self._validate_config_structure(config)
             if issues:
                 return DiagnosticResult(
                     category="User Config",
                     status=DiagnosticStatus.WARNING,
                     message=f"User config has issues: {', '.join(issues)}",
-                    details={"path": str(config_path), "issues": issues}
+                    details={"path": str(config_path), "issues": issues},
                 )
-            
+
             return DiagnosticResult(
                 category="User Config",
                 status=DiagnosticStatus.OK,
@@ -110,51 +110,51 @@ class ConfigurationCheck(BaseDiagnosticCheck):
                 details={
                     "path": str(config_path),
                     "size": config_path.stat().st_size,
-                    "exists": True
-                }
+                    "exists": True,
+                },
             )
-            
+
         except yaml.YAMLError as e:
             return DiagnosticResult(
                 category="User Config",
                 status=DiagnosticStatus.ERROR,
                 message="User config has invalid YAML",
                 details={"path": str(config_path), "error": str(e)},
-                fix_description="Fix YAML syntax errors in the configuration file"
+                fix_description="Fix YAML syntax errors in the configuration file",
             )
         except Exception as e:
             return DiagnosticResult(
                 category="User Config",
                 status=DiagnosticStatus.WARNING,
-                message=f"Could not read user config: {str(e)}",
-                details={"path": str(config_path), "error": str(e)}
+                message=f"Could not read user config: {e!s}",
+                details={"path": str(config_path), "error": str(e)},
             )
-    
+
     def _check_project_config(self) -> DiagnosticResult:
         """Check project-level configuration."""
         config_path = Path.cwd() / ".claude" / "claude-mpm.yaml"
-        
+
         if not config_path.exists():
             return DiagnosticResult(
                 category="Project Config",
                 status=DiagnosticStatus.OK,
                 message="No project configuration (using defaults)",
-                details={"path": str(config_path), "exists": False}
+                details={"path": str(config_path), "exists": False},
             )
-        
+
         try:
-            with open(config_path, 'r') as f:
+            with open(config_path) as f:
                 config = yaml.safe_load(f)
-            
+
             issues = self._validate_config_structure(config)
             if issues:
                 return DiagnosticResult(
                     category="Project Config",
                     status=DiagnosticStatus.WARNING,
                     message=f"Project config has issues: {', '.join(issues)}",
-                    details={"path": str(config_path), "issues": issues}
+                    details={"path": str(config_path), "issues": issues},
                 )
-            
+
             # Check for deprecated keys
             deprecated = self._check_deprecated_keys(config)
             if deprecated:
@@ -162,13 +162,10 @@ class ConfigurationCheck(BaseDiagnosticCheck):
                     category="Project Config",
                     status=DiagnosticStatus.WARNING,
                     message=f"Using deprecated config keys: {', '.join(deprecated)}",
-                    details={
-                        "path": str(config_path),
-                        "deprecated_keys": deprecated
-                    },
-                    fix_description="Remove deprecated configuration keys"
+                    details={"path": str(config_path), "deprecated_keys": deprecated},
+                    fix_description="Remove deprecated configuration keys",
                 )
-            
+
             return DiagnosticResult(
                 category="Project Config",
                 status=DiagnosticStatus.OK,
@@ -176,26 +173,26 @@ class ConfigurationCheck(BaseDiagnosticCheck):
                 details={
                     "path": str(config_path),
                     "size": config_path.stat().st_size,
-                    "exists": True
-                }
+                    "exists": True,
+                },
             )
-            
+
         except yaml.YAMLError as e:
             return DiagnosticResult(
                 category="Project Config",
                 status=DiagnosticStatus.ERROR,
                 message="Project config has invalid YAML",
                 details={"path": str(config_path), "error": str(e)},
-                fix_description="Fix YAML syntax errors in the configuration file"
+                fix_description="Fix YAML syntax errors in the configuration file",
             )
         except Exception as e:
             return DiagnosticResult(
                 category="Project Config",
                 status=DiagnosticStatus.WARNING,
-                message=f"Could not read project config: {str(e)}",
-                details={"path": str(config_path), "error": str(e)}
+                message=f"Could not read project config: {e!s}",
+                details={"path": str(config_path), "error": str(e)},
             )
-    
+
     def _check_environment_variables(self) -> DiagnosticResult:
         """Check relevant environment variables."""
         env_vars = {
@@ -204,53 +201,55 @@ class ConfigurationCheck(BaseDiagnosticCheck):
             "CLAUDE_MPM_PROJECT_DIR": os.environ.get("CLAUDE_MPM_PROJECT_DIR"),
             "PYTHONPATH": os.environ.get("PYTHONPATH"),
         }
-        
+
         set_vars = {k: v for k, v in env_vars.items() if v is not None}
-        
+
         if not set_vars:
             return DiagnosticResult(
                 category="Environment Variables",
                 status=DiagnosticStatus.OK,
                 message="No claude-mpm environment variables set",
-                details={"variables": {}}
+                details={"variables": {}},
             )
-        
+
         return DiagnosticResult(
             category="Environment Variables",
             status=DiagnosticStatus.OK,
             message=f"{len(set_vars)} environment variable(s) configured",
-            details={"variables": set_vars}
+            details={"variables": set_vars},
         )
-    
+
     def _check_config_permissions(self) -> DiagnosticResult:
         """Check configuration file permissions."""
         issues = []
         paths_checked = []
-        
+
         for config_path in [
             Path.home() / ".claude" / "claude-mpm.yaml",
-            Path.cwd() / ".claude" / "claude-mpm.yaml"
+            Path.cwd() / ".claude" / "claude-mpm.yaml",
         ]:
             if config_path.exists():
                 paths_checked.append(str(config_path))
-                
+
                 # Check readability
                 if not os.access(config_path, os.R_OK):
                     issues.append(f"{config_path.name} is not readable")
-                
+
                 # Check if world-writable (security concern)
                 stat_info = config_path.stat()
                 if stat_info.st_mode & 0o002:
-                    issues.append(f"{config_path.name} is world-writable (security risk)")
-        
+                    issues.append(
+                        f"{config_path.name} is world-writable (security risk)"
+                    )
+
         if not paths_checked:
             return DiagnosticResult(
                 category="Config Permissions",
                 status=DiagnosticStatus.OK,
                 message="No configuration files to check",
-                details={"paths_checked": []}
+                details={"paths_checked": []},
             )
-        
+
         if issues:
             return DiagnosticResult(
                 category="Config Permissions",
@@ -258,43 +257,49 @@ class ConfigurationCheck(BaseDiagnosticCheck):
                 message=f"Permission issues: {', '.join(issues)}",
                 details={"issues": issues, "paths_checked": paths_checked},
                 fix_command="chmod 644 ~/.claude/claude-mpm.yaml",
-                fix_description="Fix file permissions for configuration files"
+                fix_description="Fix file permissions for configuration files",
             )
-        
+
         return DiagnosticResult(
             category="Config Permissions",
             status=DiagnosticStatus.OK,
             message="Configuration file permissions are correct",
-            details={"paths_checked": paths_checked}
+            details={"paths_checked": paths_checked},
         )
-    
+
     def _validate_config_structure(self, config: Dict[str, Any]) -> list:
         """Validate configuration structure and return issues."""
         issues = []
-        
+
         if not isinstance(config, dict):
             issues.append("Configuration is not a dictionary")
             return issues
-        
+
         # Check for invalid top-level keys
         valid_keys = {
-            "response_logging", "agent_deployment", "memory_management",
-            "monitoring", "mcp", "hooks", "paths", "debug"
+            "response_logging",
+            "agent_deployment",
+            "memory_management",
+            "monitoring",
+            "mcp",
+            "hooks",
+            "paths",
+            "debug",
         }
-        
+
         invalid_keys = set(config.keys()) - valid_keys
         if invalid_keys:
             issues.append(f"Unknown keys: {', '.join(invalid_keys)}")
-        
+
         return issues
-    
+
     def _check_deprecated_keys(self, config: Dict[str, Any]) -> list:
         """Check for deprecated configuration keys."""
         deprecated_keys = ["legacy_mode", "old_agent_format", "deprecated_logging"]
         found_deprecated = []
-        
+
         for key in deprecated_keys:
             if key in config:
                 found_deprecated.append(key)
-        
-        return found_deprecated
+
+        return found_deprecated

claude_mpm/services/diagnostics/checks/filesystem_check.py

@@ -8,7 +8,6 @@ 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
@@ -16,36 +15,36 @@ 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
@@ -56,94 +55,97 @@ class FilesystemCheck(BaseDiagnosticCheck):
             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 []
+                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)}
+                message=f"Filesystem check failed: {e!s}",
+                details={"error": str(e)},
             )
-    
+
     def _check_permissions(self) -> DiagnosticResult:
         """Check permissions for critical directories."""
+        # Focus on project-level directories as per v4.0.32+ architecture
+        project_claude_dir = Path.cwd() / ".claude"
         critical_dirs = [
-            Path.home() / ".claude",
-            Path.home() / ".claude" / "agents",
-            Path.home() / ".claude" / "responses",
-            Path.cwd() / ".claude"
+            project_claude_dir,
+            project_claude_dir / "agents",
+            project_claude_dir / "responses",
+            project_claude_dir / "memory",
+            project_claude_dir / "logs",
         ]
-        
+
         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"
+                fix_command="chmod -R 755 .claude",
+                fix_description="Fix project .claude 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]}
+                message="No project .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}
+            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)
+
+            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)
+                "path": str(home_path),
             }
-            
+
             # Check for low disk space
             if free_gb < 0.1:  # Less than 100MB
                 return DiagnosticResult(
@@ -151,63 +153,63 @@ class FilesystemCheck(BaseDiagnosticCheck):
                     status=DiagnosticStatus.ERROR,
                     message=f"Critical: Only {free_gb:.2f}GB free",
                     details=details,
-                    fix_description="Free up disk space immediately"
+                    fix_description="Free up disk space immediately",
                 )
-            elif free_gb < 1:  # Less than 1GB
+            if 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"
+                    fix_description="Consider freeing up disk space",
                 )
-            
+
             return DiagnosticResult(
                 category="Disk Space",
                 status=DiagnosticStatus.OK,
                 message=f"{free_gb:.1f}GB available",
-                details=details
+                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)}
+                message=f"Could not check disk space: {e!s}",
+                details={"error": str(e)},
             )
-    
+
     def _check_directory_structure(self) -> DiagnosticResult:
-        """Check claude directory structure."""
-        base_dir = Path.home() / ".claude"
-        
+        """Check project claude directory structure."""
+        base_dir = Path.cwd() / ".claude"
+
         expected_dirs = {
             "agents": "Agent deployment directory",
             "responses": "Response logging directory",
             "memory": "Agent memory storage",
-            "logs": "Application logs"
+            "logs": "Application logs",
         }
-        
+
         missing = []
         present = []
-        
+
         if not base_dir.exists():
             return DiagnosticResult(
                 category="Directory Structure",
                 status=DiagnosticStatus.WARNING,
-                message="Base .claude directory missing",
+                message="Project .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"
+                fix_command="mkdir -p .claude/{agents,responses,memory,logs}",
+                fix_description="Create project claude directory structure",
             )
-        
-        for dir_name, description in expected_dirs.items():
+
+        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",
@@ -216,18 +218,15 @@ class FilesystemCheck(BaseDiagnosticCheck):
                 details={
                     "base_dir": str(base_dir),
                     "missing": missing,
-                    "present": present
+                    "present": present,
                 },
-                fix_command=f"mkdir -p ~/.claude/{{{','.join(missing)}}}",
-                fix_description="Create missing directories"
+                fix_command=f"mkdir -p .claude/{{{','.join(missing)}}}",
+                fix_description="Create missing project directories",
             )
-        
+
         return DiagnosticResult(
             category="Directory Structure",
             status=DiagnosticStatus.OK,
             message="Directory structure complete",
-            details={
-                "base_dir": str(base_dir),
-                "directories": present
-            }
-        )
+            details={"base_dir": str(base_dir), "directories": present},
+        )