claude-mpm 4.0.23__py3-none-any.whl → 4.0.28__py3-none-any.whl

claude_mpm/core/shared/path_resolver.py

@@ -0,0 +1,277 @@
+"""
+Shared path resolution utilities to reduce duplication.
+"""
+
+import os
+from pathlib import Path
+from typing import List, Optional, Union
+
+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):
+        """
+        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)
+        user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD")
+        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]:
+        """
+        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
+            Path.home() / ".claude" / "agents",  # User agents
+            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]:
+        """
+        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]:
+        """
+        Find configuration file in standard locations.
+        
+        Args:
+            filename: Configuration filename
+            search_paths: Additional search paths
+            
+        Returns:
+            Path to configuration file if found
+        """
+        default_paths = [
+            self.resolve_config_dir(),
+            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
+        """
+        return {
+            "base_dir": str(self.base_dir),
+            "config_dir": str(self.resolve_config_dir()),
+            "agents_dir": str(self.resolve_agents_dir()),
+            "memories_dir": str(self.resolve_memories_dir()),
+            "logs_dir": str(self.resolve_logs_dir()),
+            "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

@@ -0,0 +1,208 @@
+"""
+Shared singleton management utilities to reduce duplication.
+"""
+
+import threading
+from typing import Any, Dict, Optional, Type, TypeVar
+
+from ..logger import get_logger
+
+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:
+        """
+        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
+        """
+        # Get or create lock for this class
+        if singleton_class not in cls._locks:
+            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
+        """
+        if singleton_class in cls._locks:
+            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__}")
+                    del cls._instances[singleton_class]
+    
+    @classmethod
+    def clear_all_instances(cls) -> None:
+        """Clear all singleton instances."""
+        with cls._global_lock:
+            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)
+        }
+
+
+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."""
+        return SingletonManager.has_instance(cls)
+
+
+def singleton(cls: Type[T]) -> Type[T]:
+    """
+    Decorator to make a class a singleton.
+    
+    Usage:
+        @singleton
+        class MyService:
+            def __init__(self):
+                # 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))
+    
+    return cls
+
+
+# Example usage patterns
+if __name__ == "__main__":
+    # Example 1: Using SingletonMixin
+    class ConfigService(SingletonMixin):
+        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
+    assert db1 is db2
+    assert db1.connection_string == "postgres://localhost"  # First initialization wins

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -22,6 +22,7 @@ try:
     paths.ensure_in_path()
 
     from claude_mpm.core.config import Config
+    from claude_mpm.core.shared.config_loader import ConfigLoader
     from claude_mpm.hooks.base_hook import HookContext, HookType
     from claude_mpm.hooks.memory_integration_hook import (
         MemoryPostDelegationHook,
@@ -60,8 +61,9 @@ class MemoryHookManager:
         are triggered at the right times during agent delegation.
         """
         try:
-            # Create configuration
-            config = Config()
+            # Create configuration using ConfigLoader
+            config_loader = ConfigLoader()
+            config = config_loader.load_main_config()
 
             # Only initialize if memory system is enabled
             if not config.get("memory.enabled", True):

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -51,11 +51,22 @@ class ResponseTrackingManager:
         response tracking without code changes.
         """
         try:
-            # Create configuration with optional config file
+            # Create configuration with optional config file using ConfigLoader
             config_file = os.environ.get("CLAUDE_PM_CONFIG_FILE")
             from claude_mpm.core.config import Config
-
-            config = Config(config_file=config_file) if config_file else Config()
+            from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern
+
+            config_loader = ConfigLoader()
+            if config_file:
+                # Use specific config file with ConfigLoader
+                pattern = ConfigPattern(
+                    filenames=[os.path.basename(config_file)],
+                    search_paths=[os.path.dirname(config_file)],
+                    env_prefix="CLAUDE_MPM_"
+                )
+                config = config_loader.load_config(pattern, cache_key=f"response_tracking_{config_file}")
+            else:
+                config = config_loader.load_main_config()
 
             # Check if response tracking is enabled (check both sections for compatibility)
             response_tracking_enabled = config.get("response_tracking.enabled", False)

claude_mpm/hooks/memory_integration_hook.py

@@ -17,6 +17,7 @@ from typing import Any, Dict, List
 
 from claude_mpm.core.config import Config
 from claude_mpm.core.logger import get_logger
+from claude_mpm.core.shared.config_loader import ConfigLoader
 from claude_mpm.hooks.base_hook import (
     HookContext,
     HookResult,
@@ -65,7 +66,11 @@ class MemoryPreDelegationHook(PreDelegationHook):
             config: Optional Config object. If not provided, will create default Config.
         """
         super().__init__(name="memory_pre_delegation", priority=20)
-        self.config = config or Config()
+        if config:
+            self.config = config
+        else:
+            config_loader = ConfigLoader()
+            self.config = config_loader.load_main_config()
 
         # Initialize memory manager only if available
         if MEMORY_MANAGER_AVAILABLE and AgentMemoryManager:
@@ -196,7 +201,11 @@ class MemoryPostDelegationHook(PostDelegationHook):
             config: Optional Config object. If not provided, will create default Config.
         """
         super().__init__(name="memory_post_delegation", priority=80)
-        self.config = config or Config()
+        if config:
+            self.config = config
+        else:
+            config_loader = ConfigLoader()
+            self.config = config_loader.load_main_config()
 
         # Initialize memory manager only if available
         if MEMORY_MANAGER_AVAILABLE and AgentMemoryManager: