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

claude_mpm/core/shared/path_resolver.py

@@ -12,24 +12,24 @@ from ..logger import get_logger
 class PathResolver:
     """
     Centralized path resolution utility.
-    
+
     Reduces duplication by providing standard patterns for:
     - Working directory resolution
     - Configuration directory discovery
     - Agent directory resolution
     - Memory directory resolution
     """
-    
-    def __init__(self, base_dir: Union[str, Path] = None):
+
+    def __init__(self, base_dir: Optional[Union[str, Path]] = None):
         """
         Initialize path resolver.
-        
+
         Args:
             base_dir: Base directory for relative paths
         """
         self.base_dir = Path(base_dir) if base_dir else self._get_working_dir()
         self.logger = get_logger("path_resolver")
-    
+
     def _get_working_dir(self) -> Path:
         """Get working directory respecting CLAUDE_MPM_USER_PWD."""
         # Use CLAUDE_MPM_USER_PWD if available (when called via shell script)
@@ -37,111 +37,113 @@ class PathResolver:
         if user_pwd:
             return Path(user_pwd)
         return Path.cwd()
-    
+
     def resolve_config_dir(self, create: bool = False) -> Path:
         """
         Resolve configuration directory.
-        
+
         Args:
             create: Whether to create directory if it doesn't exist
-            
+
         Returns:
             Path to configuration directory
         """
         config_dir = self.base_dir / ".claude-mpm"
-        
+
         if create and not config_dir.exists():
             config_dir.mkdir(parents=True, exist_ok=True)
             self.logger.debug(f"Created config directory: {config_dir}")
-        
+
         return config_dir
-    
+
     def resolve_agents_dir(self, create: bool = False) -> Path:
         """
         Resolve agents directory.
-        
+
         Args:
             create: Whether to create directory if it doesn't exist
-            
+
         Returns:
             Path to agents directory
         """
         agents_dir = self.resolve_config_dir(create) / "agents"
-        
+
         if create and not agents_dir.exists():
             agents_dir.mkdir(parents=True, exist_ok=True)
             self.logger.debug(f"Created agents directory: {agents_dir}")
-        
+
         return agents_dir
-    
+
     def resolve_memories_dir(self, create: bool = False) -> Path:
         """
         Resolve memories directory.
-        
+
         Args:
             create: Whether to create directory if it doesn't exist
-            
+
         Returns:
             Path to memories directory
         """
         memories_dir = self.resolve_config_dir(create) / "memories"
-        
+
         if create and not memories_dir.exists():
             memories_dir.mkdir(parents=True, exist_ok=True)
             self.logger.debug(f"Created memories directory: {memories_dir}")
-        
+
         return memories_dir
-    
+
     def resolve_logs_dir(self, create: bool = False) -> Path:
         """
         Resolve logs directory.
-        
+
         Args:
             create: Whether to create directory if it doesn't exist
-            
+
         Returns:
             Path to logs directory
         """
         logs_dir = self.resolve_config_dir(create) / "logs"
-        
+
         if create and not logs_dir.exists():
             logs_dir.mkdir(parents=True, exist_ok=True)
             self.logger.debug(f"Created logs directory: {logs_dir}")
-        
+
         return logs_dir
-    
+
     def resolve_temp_dir(self, create: bool = False) -> Path:
         """
         Resolve temporary directory.
-        
+
         Args:
             create: Whether to create directory if it doesn't exist
-            
+
         Returns:
             Path to temporary directory
         """
         temp_dir = self.resolve_config_dir(create) / "tmp"
-        
+
         if create and not temp_dir.exists():
             temp_dir.mkdir(parents=True, exist_ok=True)
             self.logger.debug(f"Created temp directory: {temp_dir}")
-        
+
         return temp_dir
-    
-    def find_agent_file(self, agent_name: str, filename: str = None) -> Optional[Path]:
+
+    def find_agent_file(
+        self, agent_name: str, filename: Optional[str] = None
+    ) -> Optional[Path]:
         """
         Find agent file in standard locations.
-        
+
         Args:
             agent_name: Name of the agent
             filename: Specific filename to look for (defaults to agent_name.md)
-            
+
         Returns:
             Path to agent file if found
         """
         if filename is None:
             filename = f"{agent_name}.md"
-        
+
         # Search locations in order of preference
         search_paths = [
             self.resolve_agents_dir(),  # Project agents
@@ -149,50 +151,52 @@ class PathResolver:
             self.base_dir / "agents",  # Local agents directory
             self.base_dir,  # Current directory
         ]
-        
+
         for search_path in search_paths:
             if not search_path.exists():
                 continue
-            
+
             agent_file = search_path / filename
             if agent_file.exists() and agent_file.is_file():
                 self.logger.debug(f"Found agent file: {agent_file}")
                 return agent_file
-        
+
         return None
-    
-    def find_memory_file(self, agent_name: str, filename: str = None) -> Optional[Path]:
+
+    def find_memory_file(
+        self, agent_name: str, filename: Optional[str] = None
+    ) -> Optional[Path]:
         """
         Find memory file for an agent.
-        
+
         Args:
             agent_name: Name of the agent
             filename: Specific filename to look for (defaults to agent_name.md)
-            
+
         Returns:
             Path to memory file if found
         """
         if filename is None:
             filename = f"{agent_name}.md"
-        
+
         memories_dir = self.resolve_memories_dir()
         memory_file = memories_dir / filename
-        
+
         if memory_file.exists() and memory_file.is_file():
             return memory_file
-        
+
         return None
-    
-    def find_config_file(self, 
-                        filename: str,
-                        search_paths: List[Union[str, Path]] = None) -> Optional[Path]:
+
+    def find_config_file(
+        self, filename: str, search_paths: Optional[List[Union[str, Path]]] = None
+    ) -> Optional[Path]:
         """
         Find configuration file in standard locations.
-        
+
         Args:
             filename: Configuration filename
             search_paths: Additional search paths
-            
+
         Returns:
             Path to configuration file if found
         """
@@ -201,64 +205,64 @@ class PathResolver:
             self.base_dir,
             Path.home() / ".claude-mpm",
         ]
-        
+
         if search_paths:
             all_paths = [Path(p) for p in search_paths] + default_paths
         else:
             all_paths = default_paths
-        
+
         for search_path in all_paths:
             if not search_path.exists():
                 continue
-            
+
             config_file = search_path / filename
             if config_file.exists() and config_file.is_file():
                 self.logger.debug(f"Found config file: {config_file}")
                 return config_file
-        
+
         return None
-    
+
     def ensure_directory(self, path: Union[str, Path]) -> Path:
         """
         Ensure directory exists.
-        
+
         Args:
             path: Directory path
-            
+
         Returns:
             Path object for the directory
         """
         dir_path = Path(path)
-        
+
         if not dir_path.exists():
             dir_path.mkdir(parents=True, exist_ok=True)
             self.logger.debug(f"Created directory: {dir_path}")
         elif not dir_path.is_dir():
             raise ValueError(f"Path exists but is not a directory: {dir_path}")
-        
+
         return dir_path
-    
+
     def resolve_relative_path(self, path: Union[str, Path]) -> Path:
         """
         Resolve path relative to base directory.
-        
+
         Args:
             path: Path to resolve
-            
+
         Returns:
             Resolved absolute path
         """
         path_obj = Path(path)
-        
+
         if path_obj.is_absolute():
             return path_obj
-        
+
         return (self.base_dir / path_obj).resolve()
-    
+
     def get_path_info(self) -> dict:
         """
         Get information about resolved paths.
-        
+
         Returns:
             Dictionary with path information
         """
@@ -271,7 +275,7 @@ class PathResolver:
             "temp_dir": str(self.resolve_temp_dir()),
             "working_dir_from_env": os.environ.get("CLAUDE_MPM_USER_PWD"),
         }
-    
+
     def __repr__(self) -> str:
         """String representation."""
         return f"PathResolver(base_dir={self.base_dir})"

claude_mpm/core/shared/singleton_manager.py

@@ -3,40 +3,38 @@ Shared singleton management utilities to reduce duplication.
 """
 
 import threading
-from typing import Any, Dict, Optional, Type, TypeVar
+from typing import Any, Dict, Type, TypeVar
 
 from ..logger import get_logger
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 class SingletonManager:
     """
     Centralized singleton management utility.
-    
+
     Reduces duplication by providing thread-safe singleton patterns
     that can be used across different classes.
     """
-    
+
     _instances: Dict[Type, Any] = {}
     _locks: Dict[Type, threading.Lock] = {}
     _global_lock = threading.Lock()
-    
+
     @classmethod
-    def get_instance(cls, 
-                    singleton_class: Type[T],
-                    *args,
-                    force_new: bool = False,
-                    **kwargs) -> T:
+    def get_instance(
+        cls, singleton_class: Type[T], *args, force_new: bool = False, **kwargs
+    ) -> T:
         """
         Get singleton instance of a class.
-        
+
         Args:
             singleton_class: Class to get singleton instance of
             *args: Arguments for class constructor
             force_new: Force creation of new instance
             **kwargs: Keyword arguments for class constructor
-            
+
         Returns:
             Singleton instance
         """
@@ -45,38 +43,38 @@ class SingletonManager:
             with cls._global_lock:
                 if singleton_class not in cls._locks:
                     cls._locks[singleton_class] = threading.Lock()
-        
+
         # Get instance with class-specific lock
         with cls._locks[singleton_class]:
             if force_new or singleton_class not in cls._instances:
                 logger = get_logger("singleton_manager")
                 logger.debug(f"Creating singleton instance: {singleton_class.__name__}")
-                
+
                 instance = singleton_class(*args, **kwargs)
                 cls._instances[singleton_class] = instance
-                
+
                 return instance
-            
+
             return cls._instances[singleton_class]
-    
+
     @classmethod
     def has_instance(cls, singleton_class: Type) -> bool:
         """
         Check if singleton instance exists.
-        
+
         Args:
             singleton_class: Class to check
-            
+
         Returns:
             True if instance exists
         """
         return singleton_class in cls._instances
-    
+
     @classmethod
     def clear_instance(cls, singleton_class: Type) -> None:
         """
         Clear singleton instance.
-        
+
         Args:
             singleton_class: Class to clear instance for
         """
@@ -84,9 +82,11 @@ class SingletonManager:
             with cls._locks[singleton_class]:
                 if singleton_class in cls._instances:
                     logger = get_logger("singleton_manager")
-                    logger.debug(f"Clearing singleton instance: {singleton_class.__name__}")
+                    logger.debug(
+                        f"Clearing singleton instance: {singleton_class.__name__}"
+                    )
                     del cls._instances[singleton_class]
-    
+
     @classmethod
     def clear_all_instances(cls) -> None:
         """Clear all singleton instances."""
@@ -94,47 +94,47 @@ class SingletonManager:
             logger = get_logger("singleton_manager")
             logger.debug(f"Clearing {len(cls._instances)} singleton instances")
             cls._instances.clear()
-    
+
     @classmethod
     def get_instance_info(cls) -> Dict[str, Any]:
         """
         Get information about managed instances.
-        
+
         Returns:
             Dictionary with instance information
         """
         return {
             "instance_count": len(cls._instances),
-            "instance_types": [cls_type.__name__ for cls_type in cls._instances.keys()],
-            "lock_count": len(cls._locks)
+            "instance_types": [cls_type.__name__ for cls_type in cls._instances],
+            "lock_count": len(cls._locks),
         }
 
 
 class SingletonMixin:
     """
     Mixin class to add singleton behavior to any class.
-    
+
     Usage:
         class MyService(SingletonMixin):
             def __init__(self):
                 super().__init__()
                 # Your initialization code
     """
-    
+
     def __new__(cls, *args, **kwargs):
         """Override __new__ to implement singleton pattern."""
         return SingletonManager.get_instance(cls, *args, **kwargs)
-    
+
     @classmethod
     def get_instance(cls, *args, **kwargs):
         """Get singleton instance."""
         return SingletonManager.get_instance(cls, *args, **kwargs)
-    
+
     @classmethod
     def clear_instance(cls):
         """Clear singleton instance."""
         SingletonManager.clear_instance(cls)
-    
+
     @classmethod
     def has_instance(cls) -> bool:
         """Check if instance exists."""
@@ -144,7 +144,7 @@ class SingletonMixin:
 def singleton(cls: Type[T]) -> Type[T]:
     """
     Decorator to make a class a singleton.
-    
+
     Usage:
         @singleton
         class MyService:
@@ -152,21 +152,25 @@ def singleton(cls: Type[T]) -> Type[T]:
                 # Your initialization code
                 pass
     """
-    original_new = cls.__new__
-    
+
     def new_new(cls_inner, *args, **kwargs):
         return SingletonManager.get_instance(cls_inner, *args, **kwargs)
-    
+
     cls.__new__ = new_new
-    
+
     # Add convenience methods
-    cls.get_instance = classmethod(lambda cls_inner, *args, **kwargs: 
-                                  SingletonManager.get_instance(cls_inner, *args, **kwargs))
-    cls.clear_instance = classmethod(lambda cls_inner: 
-                                    SingletonManager.clear_instance(cls_inner))
-    cls.has_instance = classmethod(lambda cls_inner: 
-                                  SingletonManager.has_instance(cls_inner))
-    
+    cls.get_instance = classmethod(
+        lambda cls_inner, *args, **kwargs: SingletonManager.get_instance(
+            cls_inner, *args, **kwargs
+        )
+    )
+    cls.clear_instance = classmethod(
+        lambda cls_inner: SingletonManager.clear_instance(cls_inner)
+    )
+    cls.has_instance = classmethod(
+        lambda cls_inner: SingletonManager.has_instance(cls_inner)
+    )
+
     return cls
 
 
@@ -177,32 +181,34 @@ if __name__ == "__main__":
         def __init__(self, config_path: str = "default.yaml"):
             self.config_path = config_path
             self.loaded = True
-    
+
     # Example 2: Using @singleton decorator
     @singleton
     class LoggerService:
         def __init__(self, log_level: str = "INFO"):
             self.log_level = log_level
             self.initialized = True
-    
+
     # Example 3: Using SingletonManager directly
     class DatabaseService:
         def __init__(self, connection_string: str):
             self.connection_string = connection_string
             self.connected = True
-    
+
     # Test the patterns
     config1 = ConfigService("config1.yaml")
     config2 = ConfigService("config2.yaml")  # Same instance as config1
     assert config1 is config2
     assert config1.config_path == "config1.yaml"  # First initialization wins
-    
+
     logger1 = LoggerService("DEBUG")
     logger2 = LoggerService("ERROR")  # Same instance as logger1
     assert logger1 is logger2
     assert logger1.log_level == "DEBUG"  # First initialization wins
-    
+
     db1 = SingletonManager.get_instance(DatabaseService, "postgres://localhost")
-    db2 = SingletonManager.get_instance(DatabaseService, "mysql://localhost")  # Same instance
+    db2 = SingletonManager.get_instance(
+        DatabaseService, "mysql://localhost"
+    )  # Same instance
     assert db1 is db2
     assert db1.connection_string == "postgres://localhost"  # First initialization wins

claude_mpm/core/socketio_pool.py

@@ -95,7 +95,7 @@ class CircuitBreaker:
         """Check if execution is allowed based on circuit state."""
         if self.state == CircuitState.CLOSED:
             return True
-        elif self.state == CircuitState.OPEN:
+        if self.state == CircuitState.OPEN:
             # Check if recovery timeout has passed
             if (
                 self.last_failure_time
@@ -108,7 +108,7 @@ class CircuitBreaker:
                 )
                 return True
             return False
-        elif self.state == CircuitState.HALF_OPEN:
+        if self.state == CircuitState.HALF_OPEN:
             # Allow one test request
             return True
 
@@ -496,7 +496,7 @@ class SocketIOConnectionPool:
                 await client.emit(event.event, enhanced_data, namespace=namespace)
 
             # Update stats
-            for conn_id, stats in self.connection_stats.items():
+            for _conn_id, stats in self.connection_stats.items():
                 if stats.is_connected:
                     stats.events_sent += len(events)
                     stats.consecutive_errors = 0
@@ -547,7 +547,7 @@ class SocketIOConnectionPool:
                     )
 
                 # Update stats
-                for conn_id, stats in self.connection_stats.items():
+                for _conn_id, stats in self.connection_stats.items():
                     if stats.is_connected:
                         stats.events_sent += len(events)
                         stats.consecutive_errors = 0
@@ -562,7 +562,7 @@ class SocketIOConnectionPool:
             self.logger.error(f"Failed to emit batch to {namespace}: {e}")
 
             # Update stats
-            for conn_id, stats in self.connection_stats.items():
+            for _conn_id, stats in self.connection_stats.items():
                 if stats.is_connected:
                     stats.errors += 1
                     stats.consecutive_errors += 1
@@ -572,7 +572,7 @@ class SocketIOConnectionPool:
         finally:
             self._return_connection(client)
             # Only close loop if we created it
-            if loop and not asyncio.get_event_loop() == loop:
+            if loop and asyncio.get_event_loop() != loop:
                 try:
                     # Ensure all tasks are done before closing
                     pending = asyncio.all_tasks(loop)
@@ -731,6 +731,26 @@ class SocketIOConnectionPool:
         except (asyncio.TimeoutError, Exception):
             return False
 
+    def emit(self, event: str, data: Dict[str, Any]) -> bool:
+        """Emit an event through the connection pool.
+
+        This method provides compatibility for the legacy emit() interface
+        by mapping to the modern emit_event() method with appropriate defaults.
+
+        Args:
+            event: Event name (e.g., "claude_event")
+            data: Event data dictionary
+
+        Returns:
+            bool: True if event was sent successfully (always True for async emission)
+        """
+        if not SOCKETIO_AVAILABLE or not self._running:
+            return False
+
+        # Map to the modern emit_event method using default namespace
+        self.emit_event("/", event, data)
+        return True
+
     def get_stats(self) -> Dict[str, Any]:
         """Get connection pool statistics."""
         with self.pool_lock: