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

claude_mpm/services/diagnostics/checks/startup_log_check.py

@@ -15,7 +15,7 @@ DESIGN DECISIONS:
 import re
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Any, List, Optional, Tuple
+from typing import Any, Dict, Optional
 
 from ..models import DiagnosticResult, DiagnosticStatus
 from .base_check import BaseDiagnosticCheck
@@ -23,51 +23,51 @@ from .base_check import BaseDiagnosticCheck
 
 class StartupLogCheck(BaseDiagnosticCheck):
     """Analyze startup logs for errors and issues."""
-    
+
     # Common error patterns and their fixes
     ERROR_PATTERNS = {
         r"Agent deployment.*failed": (
             "Agent deployment failure",
-            "Check agent configuration in .claude/agents/ and run 'claude-mpm deploy'"
+            "Check agent configuration in .claude/agents/ and run 'claude-mpm deploy'",
         ),
         r"MCP.*not found": (
             "MCP server not found",
-            "Install MCP server: npm install -g @modelcontextprotocol/server"
+            "Install MCP server: npm install -g @modelcontextprotocol/server",
         ),
         r"Port \d+ .*in use": (
             "Port binding conflict",
-            "Kill the process using the port or use --websocket-port to specify a different port"
+            "Kill the process using the port or use --websocket-port to specify a different port",
         ),
         r"Memory loading.*error": (
             "Memory loading failure",
-            "Check .claude-mpm/memory/ permissions and run 'claude-mpm memory validate'"
+            "Check .claude-mpm/memory/ permissions and run 'claude-mpm memory validate'",
         ),
         r"Permission denied": (
             "Permission error",
-            "Check file permissions in project directory and .claude-mpm/"
+            "Check file permissions in project directory and .claude-mpm/",
         ),
         r"ModuleNotFoundError|ImportError": (
             "Missing Python dependency",
-            "Install missing dependencies: pip install -e . or pip install claude-mpm[agents]"
+            "Install missing dependencies: pip install -e . or pip install claude-mpm[agents]",
         ),
         r"Socket\.IO.*failed|socketio.*error": (
             "Socket.IO initialization failure",
-            "Install monitor dependencies: pip install claude-mpm[monitor]"
+            "Install monitor dependencies: pip install claude-mpm[monitor]",
         ),
         r"Configuration.*invalid|yaml.*error": (
             "Configuration file error",
-            "Validate configuration: claude-mpm config validate"
+            "Validate configuration: claude-mpm config validate",
         ),
         r"claude\.json.*large|memory.*issue": (
             "Large .claude.json file",
-            "Run 'claude-mpm cleanup-memory' to archive old conversations"
+            "Run 'claude-mpm cleanup-memory' to archive old conversations",
         ),
         r"Failed to start.*daemon": (
             "Daemon startup failure",
-            "Check system resources and try: claude-mpm monitor stop && claude-mpm monitor start"
+            "Check system resources and try: claude-mpm monitor stop && claude-mpm monitor start",
         ),
     }
-    
+
     # Warning patterns that should be noted
     WARNING_PATTERNS = {
         r"agent.*source.*tracking": "Agent source tracking warning",
@@ -76,21 +76,21 @@ class StartupLogCheck(BaseDiagnosticCheck):
         r"Socket\.IO.*not available": "Monitor mode unavailable",
         r"Response logging.*disabled": "Response logging is disabled",
     }
-    
+
     @property
     def name(self) -> str:
         return "startup_log_check"
-    
+
     @property
     def category(self) -> str:
         return "Startup Log"
-    
+
     def run(self) -> DiagnosticResult:
         """Run startup log diagnostics."""
         try:
             # Find the latest startup log
             log_file = self._find_latest_log()
-            
+
             if not log_file:
                 return DiagnosticResult(
                     category=self.category,
@@ -98,16 +98,16 @@ class StartupLogCheck(BaseDiagnosticCheck):
                     message="No startup logs found",
                     details={
                         "recommendation": "Startup logging will be created on next run"
-                    }
+                    },
                 )
-            
+
             # Parse the log file
             analysis = self._analyze_log_file(log_file)
-            
+
             # Determine status based on findings
             status = self._determine_status(analysis)
             message = self._create_message(analysis)
-            
+
             # Build details
             details = {
                 "log_file": str(log_file),
@@ -116,18 +116,18 @@ class StartupLogCheck(BaseDiagnosticCheck):
                 "warnings": analysis["warning_count"],
                 "info_messages": analysis["info_count"],
             }
-            
+
             # Add specific issues found
             if analysis["errors_found"]:
                 details["errors_found"] = analysis["errors_found"]
-            
+
             if analysis["warnings_found"]:
                 details["warnings_found"] = analysis["warnings_found"]
-            
+
             # Add recommendations
             if analysis["recommendations"]:
                 details["recommendations"] = analysis["recommendations"]
-            
+
             # Create sub-results if verbose
             sub_results = []
             if self.verbose and analysis["errors_found"]:
@@ -137,42 +137,40 @@ class StartupLogCheck(BaseDiagnosticCheck):
                             category="Error",
                             status=DiagnosticStatus.ERROR,
                             message=error_type,
-                            details={"fix": fix}
+                            details={"fix": fix},
                         )
                     )
-            
+
             return DiagnosticResult(
                 category=self.category,
                 status=status,
                 message=message,
                 details=details,
                 sub_results=sub_results if self.verbose else [],
-                fix_command=self._get_fix_command(analysis)
+                fix_command=self._get_fix_command(analysis),
             )
-            
+
         except Exception as e:
             return DiagnosticResult(
                 category=self.category,
                 status=DiagnosticStatus.ERROR,
-                message=f"Startup log check failed: {str(e)}",
-                details={"error": str(e)}
+                message=f"Startup log check failed: {e!s}",
+                details={"error": str(e)},
             )
-    
+
     def _find_latest_log(self) -> Optional[Path]:
         """Find the most recent startup log file."""
         log_dir = Path.cwd() / ".claude-mpm" / "logs" / "startup"
-        
+
         if not log_dir.exists():
             return None
-        
+
         log_files = sorted(
-            log_dir.glob("startup-*.log"),
-            key=lambda p: p.stat().st_mtime,
-            reverse=True
+            log_dir.glob("startup-*.log"), key=lambda p: p.stat().st_mtime, reverse=True
         )
-        
+
         return log_files[0] if log_files else None
-    
+
     def _analyze_log_file(self, log_file: Path) -> Dict[str, Any]:
         """Analyze the contents of a startup log file."""
         analysis = {
@@ -186,19 +184,19 @@ class StartupLogCheck(BaseDiagnosticCheck):
             "recommendations": [],
             "startup_successful": False,
         }
-        
+
         try:
-            with open(log_file, 'r', encoding='utf-8') as f:
+            with open(log_file, encoding="utf-8") as f:
                 lines = f.readlines()
-            
+
             # Extract timestamp from filename or first line
-            match = re.search(r'(\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2})', log_file.name)
+            match = re.search(r"(\d{4}-\d{2}-\d{2}-\d{2}-\d{2}-\d{2})", log_file.name)
             if match:
                 timestamp_str = match.group(1)
                 # Convert to readable format
                 dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H-%M-%S")
                 analysis["timestamp"] = dt.strftime("%Y-%m-%d %H:%M:%S")
-            
+
             # Process each line
             for line in lines:
                 # Count log levels
@@ -212,22 +210,22 @@ class StartupLogCheck(BaseDiagnosticCheck):
                     analysis["info_count"] += 1
                 elif " - DEBUG - " in line:
                     analysis["debug_count"] += 1
-                
+
                 # Check for successful startup indicators
                 if "Claude session completed successfully" in line:
                     analysis["startup_successful"] = True
                 elif "Starting Claude MPM session" in line:
                     analysis["startup_successful"] = True  # At least startup began
-            
+
             # Generate recommendations based on findings
             self._generate_recommendations(analysis)
-            
+
         except Exception as e:
             analysis["error_count"] += 1
             analysis["errors_found"].append(("Failed to parse log", str(e)))
-        
+
         return analysis
-    
+
     def _check_error_patterns(self, line: str, analysis: Dict[str, Any]) -> None:
         """Check line for known error patterns."""
         for pattern, (error_type, fix) in self.ERROR_PATTERNS.items():
@@ -236,7 +234,7 @@ class StartupLogCheck(BaseDiagnosticCheck):
                 if (error_type, fix) not in analysis["errors_found"]:
                     analysis["errors_found"].append((error_type, fix))
                 break
-    
+
     def _check_warning_patterns(self, line: str, analysis: Dict[str, Any]) -> None:
         """Check line for known warning patterns."""
         for pattern, warning_type in self.WARNING_PATTERNS.items():
@@ -245,70 +243,66 @@ class StartupLogCheck(BaseDiagnosticCheck):
                 if warning_type not in analysis["warnings_found"]:
                     analysis["warnings_found"].append(warning_type)
                 break
-    
+
     def _generate_recommendations(self, analysis: Dict[str, Any]) -> None:
         """Generate recommendations based on analysis."""
         recommendations = []
-        
+
         # High error count
         if analysis["error_count"] > 5:
             recommendations.append(
                 "High error count detected. Review full log for systematic issues."
             )
-        
+
         # No successful startup
         if not analysis["startup_successful"] and analysis["error_count"] > 0:
             recommendations.append(
                 "Startup may have failed. Check error messages above."
             )
-        
+
         # Specific error recommendations
         if any("MCP" in error[0] for error in analysis["errors_found"]):
             recommendations.append(
                 "MCP issues detected. Run 'claude-mpm doctor' for full diagnostics."
             )
-        
+
         if any("Agent" in error[0] for error in analysis["errors_found"]):
             recommendations.append(
                 "Agent issues detected. Run 'claude-mpm agents validate' to check agents."
             )
-        
+
         if any("memory" in error[0].lower() for error in analysis["errors_found"]):
             recommendations.append(
                 "Memory issues detected. Run 'claude-mpm cleanup-memory' to free space."
             )
-        
+
         analysis["recommendations"] = recommendations
-    
+
     def _determine_status(self, analysis: Dict[str, Any]) -> DiagnosticStatus:
         """Determine overall status based on analysis."""
         if analysis["error_count"] > 0:
             return DiagnosticStatus.ERROR
-        elif analysis["warning_count"] > 3:
+        if analysis["warning_count"] > 3 or analysis["warning_count"] > 0:
             return DiagnosticStatus.WARNING
-        elif analysis["warning_count"] > 0:
-            return DiagnosticStatus.WARNING
-        else:
-            return DiagnosticStatus.OK
-    
+        return DiagnosticStatus.OK
+
     def _create_message(self, analysis: Dict[str, Any]) -> str:
         """Create summary message based on analysis."""
         if analysis["error_count"] > 0:
             return f"Startup has {analysis['error_count']} error(s)"
-        elif analysis["warning_count"] > 0:
+        if analysis["warning_count"] > 0:
             return f"Startup successful with {analysis['warning_count']} warning(s)"
-        elif analysis["startup_successful"]:
+        if analysis["startup_successful"]:
             return "Last startup was successful"
-        else:
-            return "Startup log is clean"
-    
+        return "Startup log is clean"
+
     def _get_fix_command(self, analysis: Dict[str, Any]) -> Optional[str]:
         """Get the most relevant fix command based on errors found."""
         if not analysis["errors_found"]:
             return None
-        
+
         # Priority order for fix commands
-        for error_type, fix in analysis["errors_found"]:
+        for _error_type, fix in analysis["errors_found"]:
             if "claude-mpm" in fix:
                 # Extract claude-mpm command from fix suggestion
                 match = re.search(r'(claude-mpm [^\'"\n]+)', fix)
@@ -318,5 +312,5 @@ class StartupLogCheck(BaseDiagnosticCheck):
                 match = re.search(r'(pip install [^\'"\n]+)', fix)
                 if match:
                     return match.group(1)
-        
-        return None
+
+        return None

claude_mpm/services/diagnostics/diagnostic_runner.py

@@ -8,7 +8,7 @@ and aggregate results for reporting.
 import asyncio
 import logging
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import List, Optional, Type
+from typing import List, Type
 
 from .checks import (
     AgentCheck,
@@ -27,14 +27,14 @@ from .models import DiagnosticResult, DiagnosticStatus, DiagnosticSummary
 
 class DiagnosticRunner:
     """Orchestrate diagnostic checks and aggregate results.
-    
+
     WHY: Provides a single entry point for running all diagnostics with
     proper error handling, parallel execution, and result aggregation.
     """
-    
+
     def __init__(self, verbose: bool = False, fix: bool = False):
         """Initialize diagnostic runner.
-        
+
         Args:
             verbose: Include detailed information in results
             fix: Attempt to fix issues automatically (future feature)
@@ -42,7 +42,7 @@ class DiagnosticRunner:
         self.verbose = verbose
         self.fix = fix
         self.logger = logging.getLogger(__name__)
-        
+
         # Define check order (dependencies first)
         self.check_classes: List[Type[BaseDiagnosticCheck]] = [
             InstallationCheck,
@@ -55,56 +55,56 @@ class DiagnosticRunner:
             StartupLogCheck,  # Check startup logs for recent issues
             CommonIssuesCheck,
         ]
-    
+
     def run_diagnostics(self) -> DiagnosticSummary:
         """Run all diagnostic checks synchronously.
-        
+
         Returns:
             DiagnosticSummary with all results
         """
         summary = DiagnosticSummary()
-        
+
         # Run checks in order
         for check_class in self.check_classes:
             try:
                 check = check_class(verbose=self.verbose)
-                
+
                 # Skip if check shouldn't run
                 if not check.should_run():
                     self.logger.debug(f"Skipping {check.name}")
                     continue
-                
+
                 self.logger.debug(f"Running {check.name}")
                 result = check.run()
                 summary.add_result(result)
-                
+
                 # If fix mode is enabled and there's a fix available
                 if self.fix and result.has_issues and result.fix_command:
                     self._attempt_fix(result)
-                    
+
             except Exception as e:
                 self.logger.error(f"Check {check_class.__name__} failed: {e}")
                 error_result = DiagnosticResult(
                     category=check_class.__name__.replace("Check", ""),
                     status=DiagnosticStatus.ERROR,
-                    message=f"Check failed: {str(e)}",
-                    details={"error": str(e)}
+                    message=f"Check failed: {e!s}",
+                    details={"error": str(e)},
                 )
                 summary.add_result(error_result)
-        
+
         return summary
-    
+
     def run_diagnostics_parallel(self) -> DiagnosticSummary:
         """Run diagnostic checks in parallel for faster execution.
-        
+
         WHY: Some checks may involve I/O or network operations, running them
         in parallel can significantly speed up the overall diagnostic process.
-        
+
         Returns:
             DiagnosticSummary with all results
         """
         summary = DiagnosticSummary()
-        
+
         # Group checks by dependency level
         # Level 1: No dependencies
         level1 = [InstallationCheck, FilesystemCheck, ConfigurationCheck]
@@ -112,28 +112,30 @@ class DiagnosticRunner:
         level2 = [ClaudeDesktopCheck, AgentCheck, MCPCheck, MonitorCheck]
         # Level 3: Depends on others
         level3 = [CommonIssuesCheck]
-        
+
         for level in [level1, level2, level3]:
             level_results = self._run_level_parallel(level)
             for result in level_results:
                 summary.add_result(result)
-        
+
         return summary
-    
-    def _run_level_parallel(self, check_classes: List[Type[BaseDiagnosticCheck]]) -> List[DiagnosticResult]:
+
+    def _run_level_parallel(
+        self, check_classes: List[Type[BaseDiagnosticCheck]]
+    ) -> List[DiagnosticResult]:
         """Run a group of checks in parallel.
-        
+
         Args:
             check_classes: List of check classes to run
-            
+
         Returns:
             List of DiagnosticResults
         """
         results = []
-        
+
         with ThreadPoolExecutor(max_workers=len(check_classes)) as executor:
             future_to_check = {}
-            
+
             for check_class in check_classes:
                 try:
                     check = check_class(verbose=self.verbose)
@@ -141,14 +143,18 @@ class DiagnosticRunner:
                         future = executor.submit(check.run)
                         future_to_check[future] = check_class.__name__
                 except Exception as e:
-                    self.logger.error(f"Failed to create check {check_class.__name__}: {e}")
-                    results.append(DiagnosticResult(
-                        category=check_class.__name__.replace("Check", ""),
-                        status=DiagnosticStatus.ERROR,
-                        message=f"Check initialization failed: {str(e)}",
-                        details={"error": str(e)}
-                    ))
-            
+                    self.logger.error(
+                        f"Failed to create check {check_class.__name__}: {e}"
+                    )
+                    results.append(
+                        DiagnosticResult(
+                            category=check_class.__name__.replace("Check", ""),
+                            status=DiagnosticStatus.ERROR,
+                            message=f"Check initialization failed: {e!s}",
+                            details={"error": str(e)},
+                        )
+                    )
+
             for future in as_completed(future_to_check):
                 check_name = future_to_check[future]
                 try:
@@ -156,26 +162,28 @@ class DiagnosticRunner:
                     results.append(result)
                 except Exception as e:
                     self.logger.error(f"Check {check_name} failed: {e}")
-                    results.append(DiagnosticResult(
-                        category=check_name.replace("Check", ""),
-                        status=DiagnosticStatus.ERROR,
-                        message=f"Check execution failed: {str(e)}",
-                        details={"error": str(e)}
-                    ))
-        
+                    results.append(
+                        DiagnosticResult(
+                            category=check_name.replace("Check", ""),
+                            status=DiagnosticStatus.ERROR,
+                            message=f"Check execution failed: {e!s}",
+                            details={"error": str(e)},
+                        )
+                    )
+
         return results
-    
+
     def run_specific_checks(self, check_names: List[str]) -> DiagnosticSummary:
         """Run only specific diagnostic checks.
-        
+
         Args:
             check_names: List of check names to run (e.g., ["installation", "agents"])
-            
+
         Returns:
             DiagnosticSummary with results from specified checks
         """
         summary = DiagnosticSummary()
-        
+
         # Map check names to classes
         check_map = {
             "installation": InstallationCheck,
@@ -193,13 +201,13 @@ class DiagnosticRunner:
             "common": CommonIssuesCheck,
             "issues": CommonIssuesCheck,
         }
-        
+
         for name in check_names:
             check_class = check_map.get(name.lower())
             if not check_class:
                 self.logger.warning(f"Unknown check: {name}")
                 continue
-            
+
             try:
                 check = check_class(verbose=self.verbose)
                 if check.should_run():
@@ -210,38 +218,38 @@ class DiagnosticRunner:
                 error_result = DiagnosticResult(
                     category=check_class.__name__.replace("Check", ""),
                     status=DiagnosticStatus.ERROR,
-                    message=f"Check failed: {str(e)}",
-                    details={"error": str(e)}
+                    message=f"Check failed: {e!s}",
+                    details={"error": str(e)},
                 )
                 summary.add_result(error_result)
-        
+
         return summary
-    
+
     def _attempt_fix(self, result: DiagnosticResult):
         """Attempt to fix an issue automatically.
-        
+
         Args:
             result: DiagnosticResult with fix_command
         """
         if not result.fix_command:
             return
-        
+
         self.logger.info(f"Attempting to fix: {result.message}")
         self.logger.info(f"Running: {result.fix_command}")
-        
+
         # In a real implementation, this would execute the fix command
         # For now, we just log it
         # TODO: Implement actual fix execution with proper safeguards
-        
+
     async def run_diagnostics_async(self) -> DiagnosticSummary:
         """Run diagnostics asynchronously (future enhancement).
-        
+
         WHY: For integration with async frameworks and better performance
         with I/O-bound checks.
-        
+
         Returns:
             DiagnosticSummary with all results
         """
         # Convert sync execution to async for now
         loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, self.run_diagnostics)
+        return await loop.run_in_executor(None, self.run_diagnostics)