claude-mpm 3.9.11__py3-none-any.whl → 4.0.4__py3-none-any.whl

claude_mpm/core/tool_access_control.py

@@ -1,7 +1,7 @@
 """Tool access control system for managing which tools agents can use."""
 
-from typing import Dict, List, Set, Optional
 import logging
+from typing import Dict, List, Optional, Set
 
 logger = logging.getLogger(__name__)
 
@@ -9,39 +9,38 @@ logger = logging.getLogger(__name__)
 class ToolAccessControl:
     """
     Manages tool access permissions for different agent types.
-    
+
     This ensures that only authorized agents can access specific tools,
     particularly restricting TodoWrite to the PM (parent process) only.
     """
-    
+
     # Default tool sets for different contexts
     PM_TOOLS = {
-        "Task",           # For delegating to agents
-        "TodoWrite",      # For tracking tasks (PM ONLY)
-        "WebSearch",      # For understanding requirements
-        "WebFetch"        # For fetching external resources
+        "Task",  # For delegating to agents
+        "TodoWrite",  # For tracking tasks (PM ONLY)
+        "WebSearch",  # For understanding requirements
+        "WebFetch",  # For fetching external resources
     }
-    
+
     AGENT_TOOLS = {
-        "Read",           # Read files
-        "Write",          # Write files
-        "Edit",           # Edit files
-        "MultiEdit",      # Multiple edits
-        "Bash",           # Execute commands
-        "Grep",           # Search in files
-        "Glob",           # File pattern matching
-        "LS",             # List directory
-        "WebSearch",      # Search the web
-        "WebFetch",       # Fetch web content
-        "NotebookRead",   # Read Jupyter notebooks
-        "NotebookEdit"    # Edit Jupyter notebooks
+        "Read",  # Read files
+        "Write",  # Write files
+        "Edit",  # Edit files
+        "MultiEdit",  # Multiple edits
+        "Bash",  # Execute commands
+        "Grep",  # Search in files
+        "Glob",  # File pattern matching
+        "LS",  # List directory
+        "WebSearch",  # Search the web
+        "WebFetch",  # Fetch web content
+        "NotebookRead",  # Read Jupyter notebooks
+        "NotebookEdit",  # Edit Jupyter notebooks
     }
-    
+
     # Tool restrictions by agent type
     AGENT_RESTRICTIONS: Dict[str, Set[str]] = {
         # PM has very limited tools - delegation only
         "pm": PM_TOOLS,
-        
         # All other agents get standard tools WITHOUT TodoWrite
         "engineer": AGENT_TOOLS,
         "research": AGENT_TOOLS,
@@ -51,34 +50,34 @@ class ToolAccessControl:
         "ops": AGENT_TOOLS,
         "version_control": AGENT_TOOLS,
         "data_engineer": AGENT_TOOLS,
-        "architect": AGENT_TOOLS
+        "architect": AGENT_TOOLS,
     }
-    
+
     def __init__(self):
         """Initialize the tool access control system."""
         self.custom_restrictions: Dict[str, Set[str]] = {}
         logger.info("Tool access control system initialized")
-    
+
     def get_allowed_tools(self, agent_type: str, is_parent: bool = False) -> List[str]:
         """
         Get the list of allowed tools for an agent type.
-        
+
         Args:
             agent_type: The type of agent (pm, engineer, research, etc.)
             is_parent: Whether this is the parent process (PM)
-            
+
         Returns:
             List of allowed tool names
         """
         # Normalize agent type
         agent_type = agent_type.lower().replace(" ", "_").replace("-", "_")
-        
+
         # Parent process (PM) gets PM tools
         if is_parent or agent_type == "pm":
             allowed = self.PM_TOOLS.copy()
             logger.debug(f"PM/Parent process allowed tools: {allowed}")
             return sorted(list(allowed))
-        
+
         # Check custom restrictions first
         if agent_type in self.custom_restrictions:
             allowed = self.custom_restrictions[agent_type]
@@ -86,74 +85,82 @@ class ToolAccessControl:
             allowed = self.AGENT_RESTRICTIONS[agent_type]
         else:
             # Default to agent tools for unknown types
-            logger.warning(f"Unknown agent type '{agent_type}', using default agent tools")
+            logger.warning(
+                f"Unknown agent type '{agent_type}', using default agent tools"
+            )
             allowed = self.AGENT_TOOLS.copy()
-        
+
         # Ensure TodoWrite is NEVER in child agent tools
         allowed = allowed - {"TodoWrite"}
-        
+
         logger.debug(f"Agent '{agent_type}' allowed tools: {allowed}")
         return sorted(list(allowed))
-    
+
     def format_allowed_tools_arg(self, agent_type: str, is_parent: bool = False) -> str:
         """
         Format the allowed tools as a comma-separated string for --allowedTools argument.
-        
+
         Args:
             agent_type: The type of agent
             is_parent: Whether this is the parent process
-            
+
         Returns:
             Comma-separated string of allowed tools
         """
         allowed_tools = self.get_allowed_tools(agent_type, is_parent)
         return ",".join(allowed_tools)
-    
+
     def set_custom_restrictions(self, agent_type: str, allowed_tools: Set[str]):
         """
         Set custom tool restrictions for a specific agent type.
-        
+
         Args:
             agent_type: The agent type to customize
             allowed_tools: Set of allowed tool names
         """
         agent_type = agent_type.lower().replace(" ", "_").replace("-", "_")
-        
+
         # Ensure TodoWrite is not in custom restrictions for non-PM agents
         if agent_type != "pm" and "TodoWrite" in allowed_tools:
-            logger.warning(f"Removing TodoWrite from custom restrictions for {agent_type}")
+            logger.warning(
+                f"Removing TodoWrite from custom restrictions for {agent_type}"
+            )
             allowed_tools = allowed_tools - {"TodoWrite"}
-        
+
         self.custom_restrictions[agent_type] = allowed_tools
         logger.info(f"Set custom tool restrictions for {agent_type}: {allowed_tools}")
-    
-    def validate_tool_usage(self, agent_type: str, tool_name: str, is_parent: bool = False) -> bool:
+
+    def validate_tool_usage(
+        self, agent_type: str, tool_name: str, is_parent: bool = False
+    ) -> bool:
         """
         Validate if an agent is allowed to use a specific tool.
-        
+
         Args:
             agent_type: The type of agent
             tool_name: The name of the tool
             is_parent: Whether this is the parent process
-            
+
         Returns:
             True if allowed, False otherwise
         """
         allowed_tools = self.get_allowed_tools(agent_type, is_parent)
         is_allowed = tool_name in allowed_tools
-        
+
         if not is_allowed:
-            logger.warning(f"Agent '{agent_type}' attempted to use forbidden tool '{tool_name}'")
-        
+            logger.warning(
+                f"Agent '{agent_type}' attempted to use forbidden tool '{tool_name}'"
+            )
+
         return is_allowed
-    
+
     def get_todo_guidance(self, agent_type: str) -> str:
         """
         Get guidance text for agents on how to handle TODOs.
-        
+
         Args:
             agent_type: The type of agent
-            
+
         Returns:
             Guidance text for handling TODOs
         """
@@ -170,4 +177,4 @@ class ToolAccessControl:
 
 
 # Global instance for easy access
-tool_access_control = ToolAccessControl()
+tool_access_control = ToolAccessControl()

claude_mpm/core/types.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Central type definitions for Claude MPM.
 
@@ -16,7 +18,6 @@ Module-specific types should remain in their respective modules.
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
-from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 
@@ -24,18 +25,19 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 @dataclass
 class ServiceResult:
     """Standard result type for service operations."""
+
     success: bool
     message: str
     data: Optional[Dict[str, Any]] = None
     errors: Optional[List[str]] = None
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary representation."""
         return {
-            'success': self.success,
-            'message': self.message,
-            'data': self.data,
-            'errors': self.errors
+            "success": self.success,
+            "message": self.message,
+            "data": self.data,
+            "errors": self.errors,
         }
 
 
@@ -43,18 +45,24 @@ class ServiceResult:
 @dataclass
 class DeploymentResult:
     """Result of an agent deployment operation."""
+
     deployed: List[str]
     updated: List[str]
     failed: List[str]
     skipped: List[str]
     errors: Dict[str, str]
     metadata: Dict[str, Any]
-    
+
     @property
     def total_processed(self) -> int:
         """Get total number of agents processed."""
-        return len(self.deployed) + len(self.updated) + len(self.failed) + len(self.skipped)
-    
+        return (
+            len(self.deployed)
+            + len(self.updated)
+            + len(self.failed)
+            + len(self.skipped)
+        )
+
     @property
     def success_rate(self) -> float:
         """Calculate deployment success rate."""
@@ -67,12 +75,13 @@ class DeploymentResult:
 # Agent-related types
 class AgentTier(Enum):
     """Agent tier levels for precedence."""
+
     PROJECT = "PROJECT"  # Highest precedence - project-specific agents
-    USER = "USER"        # User-level agents
-    SYSTEM = "SYSTEM"    # Lowest precedence - system agents
-    
+    USER = "USER"  # User-level agents
+    SYSTEM = "SYSTEM"  # Lowest precedence - system agents
+
     @classmethod
-    def from_string(cls, value: str) -> 'AgentTier':
+    def from_string(cls, value: str) -> "AgentTier":
         """Convert string to AgentTier enum."""
         value_upper = value.upper()
         for tier in cls:
@@ -84,6 +93,7 @@ class AgentTier(Enum):
 @dataclass
 class AgentInfo:
     """Basic agent information."""
+
     agent_id: str
     name: str
     tier: AgentTier
@@ -92,7 +102,7 @@ class AgentInfo:
     description: Optional[str] = None
     capabilities: Optional[List[str]] = None
     metadata: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.capabilities is None:
@@ -105,13 +115,14 @@ class AgentInfo:
 @dataclass
 class MemoryEntry:
     """Single memory entry for an agent."""
+
     timestamp: datetime
     content: str
     category: str
     agent_id: str
     session_id: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.metadata is None:
@@ -121,6 +132,7 @@ class MemoryEntry:
 # Hook-related types
 class HookType(Enum):
     """Types of hooks in the system."""
+
     PRE_DELEGATION = "pre_delegation"
     POST_DELEGATION = "post_delegation"
     PRE_RESPONSE = "pre_response"
@@ -129,16 +141,17 @@ class HookType(Enum):
     SHUTDOWN = "shutdown"
 
 
-@dataclass 
+@dataclass
 class HookContext:
     """Context passed to hook handlers."""
+
     event_type: str
     data: Dict[str, Any]
     timestamp: datetime
     source: Optional[str] = None
     session_id: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.metadata is None:
@@ -149,12 +162,13 @@ class HookContext:
 @dataclass
 class ConfigSection:
     """Configuration section with validation."""
+
     name: str
     values: Dict[str, Any]
     schema: Optional[Dict[str, Any]] = None
     is_valid: bool = True
     validation_errors: Optional[List[str]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.validation_errors is None:
@@ -164,6 +178,7 @@ class ConfigSection:
 # Task/Ticket types
 class TaskStatus(Enum):
     """Task/ticket status values."""
+
     TODO = "todo"
     IN_PROGRESS = "in_progress"
     BLOCKED = "blocked"
@@ -175,6 +190,7 @@ class TaskStatus(Enum):
 @dataclass
 class TaskInfo:
     """Basic task/ticket information."""
+
     task_id: str
     title: str
     status: TaskStatus
@@ -184,7 +200,7 @@ class TaskInfo:
     created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
     metadata: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.metadata is None:
@@ -199,13 +215,14 @@ class TaskInfo:
 @dataclass
 class SocketMessage:
     """WebSocket/SocketIO message."""
+
     event: str
     data: Any
     room: Optional[str] = None
     namespace: Optional[str] = None
     sid: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.metadata is None:
@@ -215,6 +232,7 @@ class SocketMessage:
 # Health monitoring types
 class HealthStatus(Enum):
     """Service health status levels."""
+
     HEALTHY = "healthy"
     DEGRADED = "degraded"
     UNHEALTHY = "unhealthy"
@@ -224,13 +242,14 @@ class HealthStatus(Enum):
 @dataclass
 class HealthCheck:
     """Health check result."""
+
     service_name: str
     status: HealthStatus
     message: str
     timestamp: datetime
     metrics: Optional[Dict[str, Any]] = None
     checks: Optional[Dict[str, bool]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.metrics is None:
@@ -243,6 +262,7 @@ class HealthCheck:
 @dataclass
 class ProjectCharacteristics:
     """Analyzed project characteristics."""
+
     path: Path
     name: str
     type: str  # e.g., "python", "node", "mixed"
@@ -250,7 +270,7 @@ class ProjectCharacteristics:
     entry_points: List[Path]
     structure: Dict[str, Any]
     metadata: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.metadata is None:
@@ -260,6 +280,7 @@ class ProjectCharacteristics:
 # Error types
 class ErrorSeverity(Enum):
     """Error severity levels."""
+
     DEBUG = "debug"
     INFO = "info"
     WARNING = "warning"
@@ -270,6 +291,7 @@ class ErrorSeverity(Enum):
 @dataclass
 class ErrorContext:
     """Context for error handling."""
+
     error: Exception
     severity: ErrorSeverity
     component: str
@@ -278,7 +300,7 @@ class ErrorContext:
     traceback: Optional[str] = None
     recovery_attempted: bool = False
     metadata: Optional[Dict[str, Any]] = None
-    
+
     def __post_init__(self):
         """Initialize default values."""
         if self.metadata is None:
@@ -289,4 +311,4 @@ class ErrorContext:
 ConfigDict = Dict[str, Any]
 ErrorDict = Dict[str, str]
 MetricsDict = Dict[str, Union[int, float, str]]
-ValidationResult = Tuple[bool, Optional[List[str]]]
+ValidationResult = Tuple[bool, Optional[List[str]]]