claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/core/config_aliases.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Configuration alias management for Claude PM Framework.
 
@@ -5,75 +7,73 @@ Manages friendly directory aliases for configuration paths, allowing users to
 reference configurations using memorable names instead of full paths.
 
 Example:
-    claude-pm --config personal  # Resolves to ~/.claude-pm/configs/personal/
+    claude-pm --config personal  # Resolves to ~/.claude-mpm/configs/personal/
     claude-pm --config work      # Resolves to ~/work/claude-configs/
 
-Aliases are stored in ~/.claude-pm/config_aliases.json
+Aliases are stored in ~/.claude-mpm/config_aliases.json
 """
 
 import json
-import logging
-import os
-from pathlib import Path
-from typing import Dict, Optional, List, Tuple
+from typing import Dict, List, Optional, Tuple
+
+from claude_mpm.core.logging_utils import get_logger
 
 from ..utils.config_manager import ConfigurationManager
+from .unified_paths import get_path_manager
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class ConfigAliasError(Exception):
     """Base exception for configuration alias errors."""
-    pass
 
 
 class AliasNotFoundError(ConfigAliasError):
     """Raised when attempting to resolve a non-existent alias."""
-    pass
 
 
 class DuplicateAliasError(ConfigAliasError):
     """Raised when attempting to create an alias that already exists."""
-    pass
 
 
 class InvalidDirectoryError(ConfigAliasError):
     """Raised when a directory path is invalid or cannot be created."""
-    pass
 
 
 class ConfigAliasManager:
     """
     Manages configuration directory aliases for the Claude PM Framework.
-    
+
     Provides methods to create, delete, list, and resolve aliases that map
     friendly names to actual directory paths.
     """
-    
+
     def __init__(self, aliases_file: Optional[Path] = None):
         """
         Initialize the configuration alias manager.
-        
+
         Args:
             aliases_file: Path to the aliases JSON file. Defaults to
                          ~/.claude-pm/config_aliases.json
         """
         if aliases_file is None:
-            self.aliases_file = Path.home() / ".claude-pm" / "config_aliases.json"
+            self.aliases_file = (
+                get_path_manager().get_user_config_dir() / "config_aliases.json"
+            )
         else:
             self.aliases_file = Path(aliases_file)
-        
+
         self.config_mgr = ConfigurationManager(cache_enabled=True)
         self._ensure_aliases_file()
         self._aliases: Dict[str, str] = self._load_aliases()
-        
+
     def _ensure_aliases_file(self) -> None:
         """Ensure the aliases file and its parent directory exist."""
         self.aliases_file.parent.mkdir(parents=True, exist_ok=True)
         if not self.aliases_file.exists():
             self._save_aliases({})
             logger.info(f"Created new aliases file at {self.aliases_file}")
-    
+
     def _load_aliases(self) -> Dict[str, str]:
         """Load aliases from the JSON file."""
         try:
@@ -81,23 +81,23 @@ class ConfigAliasManager:
         except (json.JSONDecodeError, Exception) as e:
             logger.error(f"Failed to load aliases: {e}")
             return {}
-    
+
     def _save_aliases(self, aliases: Dict[str, str]) -> None:
         """Save aliases to the JSON file."""
         try:
             self.config_mgr.save_json(aliases, self.aliases_file, sort_keys=True)
         except Exception as e:
             logger.error(f"Failed to save aliases: {e}")
-            raise ConfigAliasError(f"Failed to save aliases: {e}")
-    
+            raise ConfigAliasError(f"Failed to save aliases: {e}") from e
+
     def create_alias(self, alias_name: str, directory_path: str) -> None:
         """
         Create a new configuration alias.
-        
+
         Args:
             alias_name: The friendly name for the alias
             directory_path: The directory path this alias should resolve to
-            
+
         Raises:
             DuplicateAliasError: If the alias already exists
             InvalidDirectoryError: If the directory path is invalid
@@ -105,103 +105,104 @@ class ConfigAliasManager:
         # Validate alias name
         if not alias_name or not alias_name.strip():
             raise ValueError("Alias name cannot be empty")
-        
+
         alias_name = alias_name.strip()
-        
+
         # Check for duplicate
         if alias_name in self._aliases:
             raise DuplicateAliasError(
                 f"Alias '{alias_name}' already exists, pointing to: {self._aliases[alias_name]}"
             )
-        
+
         # Validate and normalize the directory path
         validated_path = self.validate_directory(directory_path)
-        
+
         # Add the alias
         self._aliases[alias_name] = str(validated_path)
         self._save_aliases(self._aliases)
-        
+
         logger.info(f"Created alias '{alias_name}' -> {validated_path}")
-    
+
     def resolve_alias(self, alias_name: str) -> Path:
         """
         Resolve an alias to its directory path.
-        
+
         Args:
             alias_name: The alias to resolve
-            
+
         Returns:
             The Path object for the resolved directory
-            
+
         Raises:
             AliasNotFoundError: If the alias does not exist
         """
         if alias_name not in self._aliases:
             raise AliasNotFoundError(f"Alias '{alias_name}' not found")
-        
+
         path = Path(self._aliases[alias_name])
-        
+
         # Ensure the directory still exists or can be created
         try:
             path = self.validate_directory(str(path))
         except InvalidDirectoryError:
-            logger.warning(f"Directory for alias '{alias_name}' no longer valid: {path}")
+            logger.warning(
+                f"Directory for alias '{alias_name}' no longer valid: {path}"
+            )
             # Still return the path, let the caller handle the missing directory
-        
+
         return path
-    
+
     def list_aliases(self) -> List[Tuple[str, str]]:
         """
         List all configured aliases.
-        
+
         Returns:
             A list of tuples containing (alias_name, directory_path)
         """
         return sorted(self._aliases.items())
-    
+
     def delete_alias(self, alias_name: str) -> None:
         """
         Delete a configuration alias.
-        
+
         Args:
             alias_name: The alias to delete
-            
+
         Raises:
             AliasNotFoundError: If the alias does not exist
         """
         if alias_name not in self._aliases:
             raise AliasNotFoundError(f"Alias '{alias_name}' not found")
-        
+
         directory_path = self._aliases[alias_name]
         del self._aliases[alias_name]
         self._save_aliases(self._aliases)
-        
+
         logger.info(f"Deleted alias '{alias_name}' (was pointing to: {directory_path})")
-    
+
     def validate_directory(self, path: str) -> Path:
         """
         Validate that a directory exists or can be created.
-        
+
         Args:
             path: The directory path to validate
-            
+
         Returns:
             The normalized Path object
-            
+
         Raises:
             InvalidDirectoryError: If the path is invalid or cannot be created
         """
         try:
             # Expand user home directory and environment variables
-            expanded_path = os.path.expanduser(os.path.expandvars(path))
-            directory_path = Path(expanded_path).resolve()
-            
+            directory_path = Path(path).expanduser().resolve()
+
             # Check if it's a file
             if directory_path.exists() and directory_path.is_file():
                 raise InvalidDirectoryError(
                     f"Path exists but is a file, not a directory: {directory_path}"
                 )
-            
+
             # Try to create the directory if it doesn't exist
             if not directory_path.exists():
                 try:
@@ -210,8 +211,8 @@ class ConfigAliasManager:
                 except Exception as e:
                     raise InvalidDirectoryError(
                         f"Cannot create directory '{directory_path}': {e}"
-                    )
-            
+                    ) from e
+
             # Verify we can write to the directory
             test_file = directory_path / ".claude_pm_test"
             try:
@@ -220,73 +221,73 @@ class ConfigAliasManager:
             except Exception as e:
                 raise InvalidDirectoryError(
                     f"Directory '{directory_path}' is not writable: {e}"
-                )
-            
+                ) from e
+
             return directory_path
-            
+
         except InvalidDirectoryError:
             raise
         except Exception as e:
-            raise InvalidDirectoryError(f"Invalid directory path '{path}': {e}")
-    
+            raise InvalidDirectoryError(f"Invalid directory path '{path}': {e}") from e
+
     def get_alias(self, alias_name: str) -> Optional[str]:
         """
         Get the directory path for an alias without validation.
-        
+
         Args:
             alias_name: The alias to look up
-            
+
         Returns:
             The directory path string if the alias exists, None otherwise
         """
         return self._aliases.get(alias_name)
-    
+
     def update_alias(self, alias_name: str, new_directory_path: str) -> None:
         """
         Update an existing alias to point to a new directory.
-        
+
         Args:
             alias_name: The alias to update
             new_directory_path: The new directory path
-            
+
         Raises:
             AliasNotFoundError: If the alias does not exist
             InvalidDirectoryError: If the new directory path is invalid
         """
         if alias_name not in self._aliases:
             raise AliasNotFoundError(f"Alias '{alias_name}' not found")
-        
+
         # Validate the new directory path
         validated_path = self.validate_directory(new_directory_path)
-        
+
         old_path = self._aliases[alias_name]
         self._aliases[alias_name] = str(validated_path)
         self._save_aliases(self._aliases)
-        
+
         logger.info(f"Updated alias '{alias_name}': {old_path} -> {validated_path}")
-    
+
     def alias_exists(self, alias_name: str) -> bool:
         """
         Check if an alias exists.
-        
+
         Args:
             alias_name: The alias to check
-            
+
         Returns:
             True if the alias exists, False otherwise
         """
         return alias_name in self._aliases
-    
+
     def get_all_aliases(self) -> Dict[str, str]:
         """
         Get a copy of all aliases.
-        
+
         Returns:
             A dictionary mapping alias names to directory paths
         """
         return self._aliases.copy()
-    
+
     def reload_aliases(self) -> None:
         """Reload aliases from the file, discarding any in-memory changes."""
         self._aliases = self._load_aliases()
-        logger.debug("Reloaded aliases from file")
+        logger.debug("Reloaded aliases from file")

claude_mpm/core/config_constants.py

@@ -0,0 +1,314 @@
+"""
+Configuration constants for Claude MPM.
+
+This module provides centralized access to configuration values that were
+previously hardcoded throughout the codebase. It serves as a bridge between
+the old hardcoded values and the new unified configuration system.
+
+Usage:
+    from claude_mpm.core.config_constants import ConfigConstants
+
+    # Get timeout value
+    timeout = ConfigConstants.get_timeout('hook_execution')
+
+    # Get port value
+    port = ConfigConstants.get_port('socketio')
+
+    # Get cache setting
+    cache_size = ConfigConstants.get_cache_setting('max_size_mb')
+"""
+
+from typing import Any, Optional
+
+from .unified_config import ConfigurationService
+
+
+class ConfigConstants:
+    """
+    Centralized access to configuration constants.
+
+    This class provides a convenient way to access configuration values
+    that were previously hardcoded, while maintaining backward compatibility.
+    """
+
+    _config_service: Optional[ConfigurationService] = None
+
+    # Default values for backward compatibility
+    DEFAULT_VALUES = {
+        # Timeouts (in seconds)
+        "timeouts": {
+            "hook_execution": 5,
+            "session_default": 30,
+            "session_extended": 60,
+            "agent_loading": 10,
+            "startup": 60,
+            "graceful_shutdown": 30,
+        },
+        # Ports
+        "ports": {
+            "socketio_default": 8765,
+            "socketio_range_start": 8765,
+            "socketio_range_end": 8775,
+        },
+        # Cache settings
+        "cache": {
+            "max_size_mb": 100,
+            "max_entries": 10000,
+            "default_ttl_seconds": 300,
+        },
+        # Session settings
+        "sessions": {
+            "max_age_minutes": 30,
+            "cleanup_max_age_hours": 24,
+            "timeout_minutes": 60,
+        },
+        # Retry and recovery
+        "recovery": {
+            "max_restarts": 3,
+            "max_recovery_attempts": 3,
+        },
+        # Sleep and polling intervals (in seconds)
+        "intervals": {
+            "health_check": 0.1,
+            "batch_window_ms": 100,
+            "polling": 1.0,
+            "brief_pause": 0.1,
+        },
+        # File and memory limits
+        "limits": {
+            "max_file_size_mb": 10,
+            "max_memory_usage_mb": 1024,
+        },
+        # Logging configuration
+        "logging": {
+            "startup_logs_retention_count": 10,
+            "mpm_logs_retention_count": 10,
+        },
+    }
+
+    @classmethod
+    def _get_config_service(cls) -> ConfigurationService:
+        """Get or create the configuration service."""
+        if cls._config_service is None:
+            cls._config_service = ConfigurationService()
+        return cls._config_service
+
+    @classmethod
+    def set_config_service(cls, config_service: ConfigurationService) -> None:
+        """Set the configuration service (for dependency injection)."""
+        cls._config_service = config_service
+
+    @classmethod
+    def get_timeout(cls, timeout_type: str) -> int:
+        """
+        Get timeout value by type.
+
+        Args:
+            timeout_type: Type of timeout (e.g., 'hook_execution', 'session_default')
+
+        Returns:
+            Timeout value in seconds
+        """
+        try:
+            config = cls._get_config_service().config
+
+            if timeout_type == "hook_execution":
+                return config.performance.hook_timeout_seconds
+            if timeout_type == "session_default":
+                return config.performance.session_timeout_seconds
+            if timeout_type == "session_extended":
+                return config.sessions.session_timeout_minutes * 60
+            if timeout_type == "agent_loading":
+                return config.performance.agent_load_timeout_seconds
+            if timeout_type == "startup":
+                return config.performance.startup_timeout
+            if timeout_type == "graceful_shutdown":
+                return config.performance.graceful_shutdown_timeout
+            return cls.DEFAULT_VALUES["timeouts"].get(timeout_type, 30)
+        except Exception:
+            return cls.DEFAULT_VALUES["timeouts"].get(timeout_type, 30)
+
+    @classmethod
+    def get_port(cls, port_type: str) -> int:
+        """
+        Get port value by type.
+
+        Args:
+            port_type: Type of port (e.g., 'socketio_default')
+
+        Returns:
+            Port number
+        """
+        try:
+            config = cls._get_config_service().config
+
+            if port_type == "socketio_default":
+                return config.network.socketio_port
+            if port_type == "socketio_range_start":
+                return config.network.socketio_port_range[0]
+            if port_type == "socketio_range_end":
+                return config.network.socketio_port_range[1]
+            return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
+        except Exception:
+            return cls.DEFAULT_VALUES["ports"].get(port_type, 8765)
+
+    @classmethod
+    def get_cache_setting(cls, setting_name: str) -> Any:
+        """
+        Get cache setting by name.
+
+        Args:
+            setting_name: Name of cache setting
+
+        Returns:
+            Cache setting value
+        """
+        try:
+            config = cls._get_config_service().config
+
+            if setting_name == "max_size_mb":
+                return config.performance.cache_max_size_mb
+            if setting_name == "max_entries":
+                return config.performance.cache_max_entries
+            if setting_name == "default_ttl_seconds":
+                return config.performance.cache_default_ttl_seconds
+            return cls.DEFAULT_VALUES["cache"].get(setting_name)
+        except Exception:
+            return cls.DEFAULT_VALUES["cache"].get(setting_name)
+
+    @classmethod
+    def get_logging_setting(cls, setting_name: str) -> Any:
+        """
+        Get logging setting by name.
+
+        Args:
+            setting_name: Name of logging setting
+
+        Returns:
+            Logging setting value
+        """
+        try:
+            # For now, just return from DEFAULT_VALUES
+            # Can be extended to read from unified config later
+            return cls.DEFAULT_VALUES["logging"].get(setting_name)
+        except Exception:
+            # Fallback to default values
+            if setting_name in {
+                "startup_logs_retention_count",
+                "mpm_logs_retention_count",
+            }:
+                return 10
+            return None
+
+    @classmethod
+    def get_session_setting(cls, setting_name: str) -> Any:
+        """
+        Get session setting by name.
+
+        Args:
+            setting_name: Name of session setting
+
+        Returns:
+            Session setting value
+        """
+        try:
+            config = cls._get_config_service().config
+
+            if setting_name == "max_age_minutes":
+                return config.sessions.max_age_minutes
+            if setting_name == "cleanup_max_age_hours":
+                return config.sessions.cleanup_max_age_hours
+            if setting_name == "timeout_minutes":
+                return config.sessions.session_timeout_minutes
+            return cls.DEFAULT_VALUES["sessions"].get(setting_name)
+        except Exception:
+            return cls.DEFAULT_VALUES["sessions"].get(setting_name)
+
+    @classmethod
+    def get_recovery_setting(cls, setting_name: str) -> int:
+        """
+        Get recovery setting by name.
+
+        Args:
+            setting_name: Name of recovery setting
+
+        Returns:
+            Recovery setting value
+        """
+        try:
+            config = cls._get_config_service().config
+
+            if setting_name == "max_restarts":
+                return config.performance.max_restarts
+            if setting_name == "max_recovery_attempts":
+                return config.performance.max_recovery_attempts
+            return cls.DEFAULT_VALUES["recovery"].get(setting_name, 3)
+        except Exception:
+            return cls.DEFAULT_VALUES["recovery"].get(setting_name, 3)
+
+    @classmethod
+    def get_interval(cls, interval_type: str) -> float:
+        """
+        Get interval value by type.
+
+        Args:
+            interval_type: Type of interval
+
+        Returns:
+            Interval value in seconds
+        """
+        try:
+            config = cls._get_config_service().config
+
+            if interval_type == "health_check":
+                return config.performance.health_check_interval_seconds
+            if interval_type == "polling":
+                return config.performance.polling_interval_seconds
+            if interval_type == "batch_window_ms":
+                return config.performance.batch_window_ms / 1000.0
+            return cls.DEFAULT_VALUES["intervals"].get(interval_type, 1.0)
+        except Exception:
+            return cls.DEFAULT_VALUES["intervals"].get(interval_type, 1.0)
+
+    @classmethod
+    def get_limit(cls, limit_type: str) -> int:
+        """
+        Get limit value by type.
+
+        Args:
+            limit_type: Type of limit
+
+        Returns:
+            Limit value
+        """
+        try:
+            config = cls._get_config_service().config
+
+            if limit_type == "max_file_size_mb":
+                return config.security.max_file_size_mb
+            if limit_type == "max_memory_usage_mb":
+                return config.performance.max_memory_usage_mb
+            return cls.DEFAULT_VALUES["limits"].get(limit_type, 100)
+        except Exception:
+            return cls.DEFAULT_VALUES["limits"].get(limit_type, 100)
+
+
+# Convenience functions for common values
+def get_default_timeout() -> int:
+    """Get default timeout value."""
+    return ConfigConstants.get_timeout("session_default")
+
+
+def get_socketio_port() -> int:
+    """Get default SocketIO port."""
+    return ConfigConstants.get_port("socketio_default")
+
+
+def get_cache_size() -> float:
+    """Get default cache size in MB."""
+    return ConfigConstants.get_cache_setting("max_size_mb")
+
+
+def get_max_restarts() -> int:
+    """Get maximum restart attempts."""
+    return ConfigConstants.get_recovery_setting("max_restarts")