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

claude_mpm/services/diagnostics/checks/agent_check.py

@@ -5,7 +5,6 @@ WHY: Verify that agents are properly deployed, up-to-date, and functioning corre
 """
 
 from pathlib import Path
-from typing import Dict, Any, List
 
 from ..models import DiagnosticResult, DiagnosticStatus
 from .base_check import BaseDiagnosticCheck
@@ -13,52 +12,57 @@ from .base_check import BaseDiagnosticCheck
 
 class AgentCheck(BaseDiagnosticCheck):
     """Check agent deployment and configuration."""
-    
+
     @property
     def name(self) -> str:
         return "agent_check"
-    
+
     @property
     def category(self) -> str:
         return "Agents"
-    
+
     def run(self) -> DiagnosticResult:
         """Run agent diagnostics."""
         try:
-            from ....services.agents.deployment.agent_validator import AgentValidator
-            from ....services.agents.deployment.agent_discovery_service import AgentDiscoveryService
-            
+            from ....services.agents.deployment.agent_discovery_service import (
+                AgentDiscoveryService,
+            )
+
             sub_results = []
             details = {}
-            
+
             # Get available agents
-            discovery = AgentDiscoveryService()
-            available_agents = discovery.discover_available_agents()
+            # AgentDiscoveryService requires templates_dir parameter
+            templates_dir = Path(__file__).parents[3] / "agents" / "templates"
+            discovery = AgentDiscoveryService(templates_dir)
+            available_agents = discovery.list_available_agents()
             details["available_count"] = len(available_agents)
-            details["available_agents"] = [a.name for a in available_agents]
-            
+            details["available_agents"] = [
+                a.get("name", "unknown") for a in available_agents
+            ]
+
             # Check deployed agents
             deployed_result = self._check_deployed_agents()
             sub_results.append(deployed_result)
             details["deployed_count"] = deployed_result.details.get("count", 0)
-            
+
             # Check agent versions
             version_result = self._check_agent_versions()
             sub_results.append(version_result)
             details["outdated_agents"] = version_result.details.get("outdated", [])
-            
+
             # Validate agent configurations
             validation_result = self._validate_agents()
             sub_results.append(validation_result)
-            
+
             # Check for common agent issues
             issues_result = self._check_common_issues()
             sub_results.append(issues_result)
-            
+
             # Determine overall status
             deployed_count = details["deployed_count"]
             available_count = details["available_count"]
-            
+
             if deployed_count == 0:
                 status = DiagnosticStatus.ERROR
                 message = f"No agents deployed (0/{available_count} available)"
@@ -68,7 +72,9 @@ class AgentCheck(BaseDiagnosticCheck):
                 status = DiagnosticStatus.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"
+                fix_description = (
+                    f"Deploy remaining {available_count - deployed_count} agents"
+                )
             elif any(r.status == DiagnosticStatus.ERROR for r in sub_results):
                 status = DiagnosticStatus.ERROR
                 message = "Agents have critical issues"
@@ -84,7 +90,7 @@ class AgentCheck(BaseDiagnosticCheck):
                 message = f"All {deployed_count} agents properly deployed"
                 fix_command = None
                 fix_description = None
-            
+
             return DiagnosticResult(
                 category=self.category,
                 status=status,
@@ -92,21 +98,21 @@ class AgentCheck(BaseDiagnosticCheck):
                 details=details,
                 fix_command=fix_command,
                 fix_description=fix_description,
-                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"Agent check failed: {str(e)}",
-                details={"error": str(e)}
+                message=f"Agent check failed: {e!s}",
+                details={"error": str(e)},
             )
-    
+
     def _check_deployed_agents(self) -> DiagnosticResult:
         """Check deployed agents in user directory."""
         agents_dir = Path.home() / ".claude" / "agents"
-        
+
         if not agents_dir.exists():
             return DiagnosticResult(
                 category="Deployed Agents",
@@ -114,12 +120,12 @@ class AgentCheck(BaseDiagnosticCheck):
                 message="Agents directory does not exist",
                 details={"path": str(agents_dir), "count": 0},
                 fix_command="claude-mpm agents deploy",
-                fix_description="Create agents directory and deploy agents"
+                fix_description="Create agents directory and deploy agents",
             )
-        
+
         # Count deployed agent files
         agent_files = list(agents_dir.glob("*.md"))
-        
+
         if not agent_files:
             return DiagnosticResult(
                 category="Deployed Agents",
@@ -127,14 +133,14 @@ class AgentCheck(BaseDiagnosticCheck):
                 message="No agents deployed",
                 details={"path": str(agents_dir), "count": 0},
                 fix_command="claude-mpm agents deploy",
-                fix_description="Deploy available agents"
+                fix_description="Deploy available agents",
             )
-        
+
         # Check for required core agents
         core_agents = ["research.md", "engineer.md", "qa.md", "documentation.md"]
         deployed_names = [f.name for f in agent_files]
         missing_core = [a for a in core_agents if a not in deployed_names]
-        
+
         if missing_core:
             return DiagnosticResult(
                 category="Deployed Agents",
@@ -144,12 +150,12 @@ class AgentCheck(BaseDiagnosticCheck):
                     "path": str(agents_dir),
                     "count": len(agent_files),
                     "deployed": deployed_names,
-                    "missing_core": missing_core
+                    "missing_core": missing_core,
                 },
                 fix_command="claude-mpm agents deploy",
-                fix_description="Deploy missing core agents"
+                fix_description="Deploy missing core agents",
             )
-        
+
         return DiagnosticResult(
             category="Deployed Agents",
             status=DiagnosticStatus.OK,
@@ -157,37 +163,39 @@ class AgentCheck(BaseDiagnosticCheck):
             details={
                 "path": str(agents_dir),
                 "count": len(agent_files),
-                "deployed": deployed_names
-            }
+                "deployed": deployed_names,
+            },
         )
-    
+
     def _check_agent_versions(self) -> DiagnosticResult:
         """Check if deployed agents are up-to-date."""
         try:
-            from ....services.agents.deployment.agent_version_manager import AgentVersionManager
-            
+            from ....services.agents.deployment.agent_version_manager import (
+                AgentVersionManager,
+            )
+
             version_manager = AgentVersionManager()
             agents_dir = Path.home() / ".claude" / "agents"
-            
+
             if not agents_dir.exists():
                 return DiagnosticResult(
                     category="Agent Versions",
                     status=DiagnosticStatus.SKIPPED,
                     message="No agents to check",
-                    details={}
+                    details={},
                 )
-            
+
             outdated = []
             checked = 0
-            
+
             for agent_file in agents_dir.glob("*.md"):
                 checked += 1
                 agent_name = agent_file.stem
-                
+
                 # Check if agent needs update (simplified check)
                 if version_manager.needs_update(agent_name):
                     outdated.append(agent_name)
-            
+
             if outdated:
                 return DiagnosticResult(
                     category="Agent Versions",
@@ -195,95 +203,95 @@ class AgentCheck(BaseDiagnosticCheck):
                     message=f"{len(outdated)} agent(s) outdated",
                     details={"outdated": outdated, "checked": checked},
                     fix_command="claude-mpm agents update",
-                    fix_description="Update agents to latest versions"
+                    fix_description="Update agents to latest versions",
                 )
-            
+
             if checked == 0:
                 return DiagnosticResult(
                     category="Agent Versions",
                     status=DiagnosticStatus.WARNING,
                     message="No agents to check",
-                    details={"checked": 0}
+                    details={"checked": 0},
                 )
-            
+
             return DiagnosticResult(
                 category="Agent Versions",
                 status=DiagnosticStatus.OK,
                 message=f"All {checked} agents up-to-date",
-                details={"checked": checked}
+                details={"checked": checked},
             )
-            
+
         except Exception as e:
             return DiagnosticResult(
                 category="Agent Versions",
                 status=DiagnosticStatus.WARNING,
-                message=f"Could not check versions: {str(e)}",
-                details={"error": str(e)}
+                message=f"Could not check versions: {e!s}",
+                details={"error": str(e)},
             )
-    
+
     def _validate_agents(self) -> DiagnosticResult:
         """Validate agent configurations."""
         try:
             from ....services.agents.deployment.agent_validator import AgentValidator
-            
-            validator = AgentValidator()
+
+            AgentValidator()
             agents_dir = Path.home() / ".claude" / "agents"
-            
+
             if not agents_dir.exists():
                 return DiagnosticResult(
                     category="Agent Validation",
                     status=DiagnosticStatus.SKIPPED,
                     message="No agents to validate",
-                    details={}
+                    details={},
                 )
-            
+
             invalid = []
             validated = 0
-            
+
             for agent_file in agents_dir.glob("*.md"):
                 validated += 1
-                
+
                 # Basic validation
                 try:
-                    with open(agent_file, 'r') as f:
+                    with open(agent_file) as f:
                         content = f.read()
-                        
+
                         # Check for required sections
                         if "## Core Identity" not in content:
                             invalid.append(f"{agent_file.stem}: missing Core Identity")
                         elif len(content) < 100:
                             invalid.append(f"{agent_file.stem}: file too small")
-                        
+
                 except Exception as e:
-                    invalid.append(f"{agent_file.stem}: {str(e)}")
-            
+                    invalid.append(f"{agent_file.stem}: {e!s}")
+
             if invalid:
                 return DiagnosticResult(
                     category="Agent Validation",
                     status=DiagnosticStatus.WARNING,
                     message=f"{len(invalid)} validation issue(s)",
-                    details={"issues": invalid, "validated": validated}
+                    details={"issues": invalid, "validated": validated},
                 )
-            
+
             return DiagnosticResult(
                 category="Agent Validation",
                 status=DiagnosticStatus.OK,
                 message=f"All {validated} agents valid",
-                details={"validated": validated}
+                details={"validated": validated},
             )
-            
+
         except Exception as e:
             return DiagnosticResult(
                 category="Agent Validation",
                 status=DiagnosticStatus.WARNING,
-                message=f"Validation failed: {str(e)}",
-                details={"error": str(e)}
+                message=f"Validation failed: {e!s}",
+                details={"error": str(e)},
             )
-    
+
     def _check_common_issues(self) -> DiagnosticResult:
         """Check for common agent-related issues."""
         issues = []
-        
+
         # Check for duplicate agents
         agents_dir = Path.home() / ".claude" / "agents"
         if agents_dir.exists():
@@ -294,26 +302,27 @@ class AgentCheck(BaseDiagnosticCheck):
                     issues.append(f"Duplicate agent: {agent_file.stem}")
                 else:
                     agent_names[name] = agent_file
-        
+
         # Check permissions
         if agents_dir.exists():
             import os
+
             if not os.access(agents_dir, os.R_OK):
                 issues.append("Agents directory not readable")
             if not os.access(agents_dir, os.W_OK):
                 issues.append("Agents directory not writable")
-        
+
         if issues:
             return DiagnosticResult(
                 category="Common Issues",
                 status=DiagnosticStatus.WARNING,
                 message=f"{len(issues)} issue(s) found",
-                details={"issues": issues}
+                details={"issues": issues},
             )
-        
+
         return DiagnosticResult(
             category="Common Issues",
             status=DiagnosticStatus.OK,
             message="No common issues detected",
-            details={}
-        )
+            details={},
+        )

claude_mpm/services/diagnostics/checks/base_check.py

@@ -6,59 +6,55 @@ they can be easily added, tested, and executed by the diagnostic runner.
 """
 
 from abc import ABC, abstractmethod
-from typing import Optional
 
 from ..models import DiagnosticResult
 
 
 class BaseDiagnosticCheck(ABC):
     """Base class for all diagnostic checks.
-    
+
     WHY: Ensures all checks follow the same pattern and can be
     executed uniformly by the diagnostic runner.
     """
-    
+
     def __init__(self, verbose: bool = False):
         """Initialize the check.
-        
+
         Args:
             verbose: Whether to include detailed information in results
         """
         self.verbose = verbose
-    
+
     @property
     @abstractmethod
     def name(self) -> str:
         """Get the name of this check."""
-        pass
-    
+
     @property
     @abstractmethod
     def category(self) -> str:
         """Get the category this check belongs to."""
-        pass
-    
+
     @property
     def description(self) -> str:
         """Get a description of what this check does."""
         return f"Checking {self.category.lower()} health"
-    
+
     @abstractmethod
     def run(self) -> DiagnosticResult:
         """Run the diagnostic check.
-        
+
         Returns:
             DiagnosticResult with the check results
         """
-        pass
-    
+
     def should_run(self) -> bool:
         """Determine if this check should run.
-        
+
         WHY: Some checks may not be applicable in certain environments
         or configurations. This allows checks to opt out gracefully.
-        
+
         Returns:
             True if the check should run, False to skip
         """
-        return True
+        return True