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

claude_mpm/services/mcp_gateway/tools/health_check_tool.py

@@ -19,11 +19,11 @@ DESIGN DECISIONS:
 import asyncio
 import os
 import platform
-import psutil
 import sys
 from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict
+
+import psutil
 
 from claude_mpm.config.paths import paths
 from claude_mpm.core.logger import get_logger
@@ -38,11 +38,11 @@ from claude_mpm.services.mcp_gateway.tools.base_adapter import BaseToolAdapter
 class HealthCheckTool(BaseToolAdapter):
     """
     Comprehensive health check tool for MCP Gateway diagnostics.
-    
+
     Provides system health, gateway status, tool availability, and
     configuration validation checks.
     """
-    
+
     def __init__(self):
         """Initialize the health check tool."""
         definition = MCPToolDefinition(
@@ -75,34 +75,34 @@ class HealthCheckTool(BaseToolAdapter):
         )
         super().__init__(definition)
         self.logger = get_logger("HealthCheckTool")
-    
+
     async def invoke(self, invocation: MCPToolInvocation) -> MCPToolResult:
         """
         Perform health checks based on the requested type.
-        
+
         Args:
             invocation: Tool invocation request
-            
+
         Returns:
             Tool execution result with health check results
         """
         start_time = datetime.now()
-        
+
         try:
             # Get parameters
             check_type = invocation.parameters.get("check_type", "all")
             detailed = invocation.parameters.get("detailed", False)
             timeout = invocation.parameters.get("timeout", 30)
-            
+
             # Perform health checks
             results = await self._perform_health_checks(check_type, detailed, timeout)
-            
+
             # Calculate execution time
             execution_time = (datetime.now() - start_time).total_seconds()
-            
+
             # Update metrics
             self._update_metrics(True, execution_time)
-            
+
             return MCPToolResult(
                 success=True,
                 data=results,
@@ -113,18 +113,18 @@ class HealthCheckTool(BaseToolAdapter):
                     "detailed": detailed,
                 },
             )
-            
+
         except Exception as e:
             execution_time = (datetime.now() - start_time).total_seconds()
             self._update_metrics(False, execution_time)
-            
+
             return MCPToolResult(
                 success=False,
-                error=f"Health check failed: {str(e)}",
+                error=f"Health check failed: {e!s}",
                 execution_time=execution_time,
                 metadata={"tool": "health_check", "error": str(e)},
             )
-    
+
     async def _perform_health_checks(
         self, check_type: str, detailed: bool, timeout: int
     ) -> Dict[str, Any]:
@@ -137,14 +137,14 @@ class HealthCheckTool(BaseToolAdapter):
             "checks": {},
             "summary": {},
         }
-        
+
         # Determine which checks to run
         checks_to_run = []
         if check_type == "all":
             checks_to_run = ["system", "gateway", "tools", "config"]
         else:
             checks_to_run = [check_type]
-        
+
         # Run checks with timeout
         try:
             check_tasks = []
@@ -157,13 +157,12 @@ class HealthCheckTool(BaseToolAdapter):
                     check_tasks.append(self._check_tools_health(detailed))
                 elif check == "config":
                     check_tasks.append(self._check_config_health(detailed))
-            
+
             # Run all checks concurrently with timeout
             check_results = await asyncio.wait_for(
-                asyncio.gather(*check_tasks, return_exceptions=True),
-                timeout=timeout
+                asyncio.gather(*check_tasks, return_exceptions=True), timeout=timeout
             )
-            
+
             # Process results
             for i, check_name in enumerate(checks_to_run):
                 if i < len(check_results):
@@ -179,19 +178,19 @@ class HealthCheckTool(BaseToolAdapter):
                         "status": "timeout",
                         "error": "Check timed out",
                     }
-            
+
         except asyncio.TimeoutError:
             results["checks"]["timeout"] = {
                 "status": "error",
                 "error": f"Health checks timed out after {timeout} seconds",
             }
-        
+
         # Calculate overall status and summary
         results["overall_status"] = self._calculate_overall_status(results["checks"])
         results["summary"] = self._generate_summary(results["checks"])
-        
+
         return results
-    
+
     async def _check_system_health(self, detailed: bool) -> Dict[str, Any]:
         """Check system health (CPU, memory, disk, etc.)."""
         check_result = {
@@ -200,7 +199,7 @@ class HealthCheckTool(BaseToolAdapter):
             "warnings": [],
             "errors": [],
         }
-        
+
         try:
             # Basic system info
             check_result["checks"]["platform"] = {
@@ -208,7 +207,7 @@ class HealthCheckTool(BaseToolAdapter):
                 "release": platform.release(),
                 "python_version": sys.version,
             }
-            
+
             # Memory check
             memory = psutil.virtual_memory()
             memory_usage = memory.percent
@@ -217,26 +216,26 @@ class HealthCheckTool(BaseToolAdapter):
                 "available_gb": round(memory.available / (1024**3), 2),
                 "total_gb": round(memory.total / (1024**3), 2),
             }
-            
+
             if memory_usage > 90:
                 check_result["errors"].append("High memory usage detected")
                 check_result["status"] = "unhealthy"
             elif memory_usage > 80:
                 check_result["warnings"].append("Elevated memory usage")
-            
+
             # CPU check
             cpu_usage = psutil.cpu_percent(interval=1)
             check_result["checks"]["cpu"] = {
                 "usage_percent": cpu_usage,
                 "count": psutil.cpu_count(),
             }
-            
+
             if cpu_usage > 95:
                 check_result["errors"].append("High CPU usage detected")
                 check_result["status"] = "unhealthy"
             elif cpu_usage > 80:
                 check_result["warnings"].append("Elevated CPU usage")
-            
+
             # Disk check for claude-mpm data directory
             if paths.data_dir.exists():
                 disk_usage = psutil.disk_usage(str(paths.data_dir))
@@ -246,13 +245,13 @@ class HealthCheckTool(BaseToolAdapter):
                     "free_gb": round(disk_usage.free / (1024**3), 2),
                     "total_gb": round(disk_usage.total / (1024**3), 2),
                 }
-                
+
                 if disk_usage_percent > 95:
                     check_result["errors"].append("Disk space critically low")
                     check_result["status"] = "unhealthy"
                 elif disk_usage_percent > 85:
                     check_result["warnings"].append("Disk space running low")
-            
+
             # Process check
             current_process = psutil.Process()
             check_result["checks"]["process"] = {
@@ -261,13 +260,13 @@ class HealthCheckTool(BaseToolAdapter):
                 "cpu_percent": current_process.cpu_percent(),
                 "threads": current_process.num_threads(),
             }
-            
+
         except Exception as e:
             check_result["status"] = "error"
             check_result["errors"].append(f"System health check failed: {e}")
-        
+
         return check_result
-    
+
     async def _check_gateway_health(self, detailed: bool) -> Dict[str, Any]:
         """Check MCP Gateway health."""
         check_result = {
@@ -276,41 +275,41 @@ class HealthCheckTool(BaseToolAdapter):
             "warnings": [],
             "errors": [],
         }
-        
+
         try:
             # Check singleton manager
             from ..core.singleton_manager import get_gateway_manager, is_gateway_running
-            
+
             manager = get_gateway_manager()
             check_result["checks"]["singleton_manager"] = {
                 "available": True,
                 "gateway_running": is_gateway_running(),
             }
-            
+
             # Check gateway instance info
             instance_info = manager.get_running_instance_info()
             if instance_info:
                 check_result["checks"]["instance"] = instance_info
             else:
                 check_result["warnings"].append("No gateway instance currently running")
-            
+
             # Check MCP directories
             mcp_dir = paths.data_dir / "mcp"
             check_result["checks"]["directories"] = {
                 "mcp_dir_exists": mcp_dir.exists(),
                 "mcp_dir_writable": mcp_dir.exists() and os.access(mcp_dir, os.W_OK),
             }
-            
+
             if not mcp_dir.exists():
                 check_result["errors"].append("MCP directory does not exist")
                 check_result["status"] = "unhealthy"
-            
+
         except Exception as e:
             check_result["status"] = "error"
             check_result["errors"].append(f"Gateway health check failed: {e}")
-        
+
         return check_result
-    
+
     async def _check_tools_health(self, detailed: bool) -> Dict[str, Any]:
         """Check MCP tools health."""
         check_result = {
@@ -319,48 +318,50 @@ class HealthCheckTool(BaseToolAdapter):
             "warnings": [],
             "errors": [],
         }
-        
+
         try:
             # Try to import and check tool registry
             from ..registry.tool_registry import ToolRegistry
-            
+
             registry = ToolRegistry()
             await registry.initialize()
-            
+
             # Get tool list
             tools = registry.list_tools()
             check_result["checks"]["tool_count"] = len(tools)
             check_result["checks"]["tools"] = [tool.name for tool in tools]
-            
+
             # Check essential tools
             essential_tools = ["echo", "calculator", "system_info"]
             available_essential = []
             missing_essential = []
-            
+
             for tool_name in essential_tools:
                 if registry.get_tool(tool_name):
                     available_essential.append(tool_name)
                 else:
                     missing_essential.append(tool_name)
-            
+
             check_result["checks"]["essential_tools"] = {
                 "available": available_essential,
                 "missing": missing_essential,
             }
-            
+
             if missing_essential:
-                check_result["warnings"].append(f"Missing essential tools: {missing_essential}")
-            
+                check_result["warnings"].append(
+                    f"Missing essential tools: {missing_essential}"
+                )
+
             if len(available_essential) == 0:
                 check_result["status"] = "unhealthy"
                 check_result["errors"].append("No essential tools available")
-            
+
         except Exception as e:
             check_result["status"] = "error"
             check_result["errors"].append(f"Tools health check failed: {e}")
-        
+
         return check_result
-    
+
     async def _check_config_health(self, detailed: bool) -> Dict[str, Any]:
         """Check configuration health."""
         check_result = {
@@ -369,27 +370,28 @@ class HealthCheckTool(BaseToolAdapter):
             "warnings": [],
             "errors": [],
         }
-        
+
         try:
             # Check configuration files
             config_dir = paths.data_dir / "mcp"
             config_file = config_dir / "gateway_config.json"
-            
+
             check_result["checks"]["config_dir"] = config_dir.exists()
             check_result["checks"]["config_file"] = config_file.exists()
-            
+
             if config_file.exists():
                 # Try to load configuration
                 import json
-                with open(config_file, 'r') as f:
+
+                with open(config_file) as f:
                     config_data = json.load(f)
-                
+
                 check_result["checks"]["config_valid"] = True
                 if detailed:
                     check_result["checks"]["config_content"] = config_data
             else:
                 check_result["warnings"].append("Gateway configuration file not found")
-            
+
             # Check paths
             check_result["checks"]["paths"] = {
                 "data_dir": str(paths.data_dir),
@@ -397,31 +399,30 @@ class HealthCheckTool(BaseToolAdapter):
                 "data_dir_exists": paths.data_dir.exists(),
                 "logs_dir_exists": paths.logs_dir.exists(),
             }
-            
+
         except Exception as e:
             check_result["status"] = "error"
             check_result["errors"].append(f"Config health check failed: {e}")
-        
+
         return check_result
-    
+
     def _calculate_overall_status(self, checks: Dict[str, Any]) -> str:
         """Calculate overall health status from individual checks."""
         if not checks:
             return "unknown"
-        
+
         statuses = [check.get("status", "unknown") for check in checks.values()]
-        
+
         if "error" in statuses:
             return "error"
-        elif "unhealthy" in statuses:
+        if "unhealthy" in statuses:
             return "unhealthy"
-        elif "warning" in statuses:
+        if "warning" in statuses:
             return "warning"
-        elif all(status == "healthy" for status in statuses):
+        if all(status == "healthy" for status in statuses):
             return "healthy"
-        else:
-            return "unknown"
-    
+        return "unknown"
+
     def _generate_summary(self, checks: Dict[str, Any]) -> Dict[str, Any]:
         """Generate a summary of health check results."""
         summary = {
@@ -431,10 +432,10 @@ class HealthCheckTool(BaseToolAdapter):
             "errors": 0,
             "issues": [],
         }
-        
+
         for check_name, check_result in checks.items():
             status = check_result.get("status", "unknown")
-            
+
             if status == "healthy":
                 summary["healthy"] += 1
             elif status in ["warning", "unhealthy"]:
@@ -449,5 +450,5 @@ class HealthCheckTool(BaseToolAdapter):
                 errors = check_result.get("errors", [])
                 for error in errors:
                     summary["issues"].append(f"{check_name}: {error}")
-        
+
         return summary

claude_mpm/services/mcp_gateway/tools/hello_world.py

@@ -395,7 +395,7 @@ class HelloWorldTool(BaseToolAdapter):
 
             return MCPToolResult(
                 success=False,
-                error=f"Hello World tool failed: {str(e)}",
+                error=f"Hello World tool failed: {e!s}",
                 execution_time=execution_time,
             )
 
@@ -426,8 +426,7 @@ class HelloWorldTool(BaseToolAdapter):
         if name:
             # Add name if provided (works for most languages)
             return f"{greeting_word}, {name}!"
-        else:
-            return f"{greeting_word}, World!"
+        return f"{greeting_word}, World!"
 
     async def _system_info_greeting(self) -> str:
         """Generate a greeting with system information."""
@@ -458,21 +457,20 @@ class HelloWorldTool(BaseToolAdapter):
                 error="Simulated validation error: Invalid input parameters",
                 execution_time=0.001,
             )
-        elif error_type == "runtime":
+        if error_type == "runtime":
             # Simulate a runtime error
             raise RuntimeError("Simulated runtime error during greeting generation")
-        elif error_type == "timeout":
+        if error_type == "timeout":
             # Simulate a timeout by sleeping longer than reasonable
             await asyncio.sleep(10)  # This would typically trigger a timeout
             return MCPToolResult(
                 success=False, error="Operation timed out", execution_time=10.0
             )
-        else:
-            return MCPToolResult(
-                success=False,
-                error=f"Unknown error type: {error_type}",
-                execution_time=0.001,
-            )
+        return MCPToolResult(
+            success=False,
+            error=f"Unknown error type: {error_type}",
+            execution_time=0.001,
+        )
 
     def _add_to_history(self, mode: str, greeting: str, execution_time: float) -> None:
         """
@@ -524,9 +522,9 @@ class HelloWorldTool(BaseToolAdapter):
             "total_greetings": len(self.greeting_history),
             "modes_used": modes_used,
             "average_execution_time": total_time / len(self.greeting_history),
-            "last_greeting": self.greeting_history[-1]
-            if self.greeting_history
-            else None,
+            "last_greeting": (
+                self.greeting_history[-1] if self.greeting_history else None
+            ),
             "metrics": self.get_metrics(),
         }