claude-mpm 4.0.22__py3-none-any.whl → 4.0.25__py3-none-any.whl

claude_mpm/config/agent_config.py

@@ -10,6 +10,8 @@ This module handles:
 - Environment variable support for agent paths
 - Project-specific agent overrides
 - Tier precedence configuration
+
+UPDATED: Migrated to use shared ConfigLoader pattern (TSK-0141)
 """
 
 import json
@@ -21,6 +23,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.unified_paths import get_path_manager
+from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern
 
 logger = logging.getLogger(__name__)
 
@@ -62,6 +65,9 @@ class AgentConfig:
     validate_on_load: bool = True
     strict_validation: bool = False
 
+    # ConfigLoader instance for consistent configuration loading
+    _config_loader: ConfigLoader = field(default_factory=ConfigLoader, init=False)
+
     @classmethod
     def from_environment(cls) -> "AgentConfig":
         """
@@ -147,14 +153,29 @@ class AgentConfig:
             return cls()
 
         try:
-            if config_file.suffix in [".yaml", ".yml"]:
-                import yaml
-
-                with open(config_file, "r") as f:
-                    data = yaml.safe_load(f)
-            else:
-                with open(config_file, "r") as f:
-                    data = json.load(f)
+            # Use ConfigLoader for consistent file loading
+            config_loader = ConfigLoader()
+
+            # Create a pattern for agent configuration
+            pattern = ConfigPattern(
+                filenames=[config_file.name],
+                search_paths=[str(config_file.parent)],
+                env_prefix="CLAUDE_MPM_AGENT_",
+                defaults={
+                    "enable_project_agents": True,
+                    "enable_user_agents": True,
+                    "enable_system_agents": True,
+                    "enable_hot_reload": True,
+                    "cache_ttl_seconds": 3600,
+                    "enable_caching": True,
+                    "validate_on_load": True,
+                    "strict_validation": False,
+                    "precedence_mode": "override"
+                }
+            )
+
+            loaded_config = config_loader.load_config(pattern, cache_key=f"agent_{config_file}")
+            data = loaded_config.to_dict()
 
             config = cls()
 

claude_mpm/core/container.py

@@ -250,8 +250,9 @@ class DIContainer(IServiceContainer):
             instance: Pre-created instance to register as singleton
 
         Examples:
-            # Register a pre-created instance
-            config = Config()
+            # Register a pre-created instance using ConfigLoader
+            config_loader = ConfigLoader()
+            config = config_loader.load_main_config()
             container.register_instance(IConfig, config)
         """
         self._register_internal(
@@ -307,8 +308,9 @@ class DIContainer(IServiceContainer):
             # Register with implementation class
             container.register_singleton(ILogger, ConsoleLogger)
 
-            # Register with instance
-            container.register_singleton(IConfig, instance=Config())
+            # Register with instance using ConfigLoader
+            config_loader = ConfigLoader()
+            container.register_singleton(IConfig, instance=config_loader.load_main_config())
 
             # Register with disposal handler
             container.register_singleton(

claude_mpm/core/framework_loader.py

@@ -640,9 +640,10 @@ class FrameworkLoader:
         Aggregate multiple memory entries into a single memory string.
         
         Strategy:
-        - Parse memories by sections
-        - Merge sections, with project-level taking precedence
-        - Remove exact duplicates within sections
+        - Support both sectioned and non-sectioned memories
+        - Preserve all bullet-point items (lines starting with -)
+        - Merge sections when present, with project-level taking precedence
+        - Remove exact duplicates within sections and unsectioned items
         - Preserve unique entries from both sources
         
         Args:
@@ -658,15 +659,16 @@ class FrameworkLoader:
         if len(memory_entries) == 1:
             return memory_entries[0]["content"]
         
-        # Parse all memories into sections
+        # Parse all memories into sections and unsectioned items
         all_sections = {}
+        unsectioned_items = {}  # Items without a section header
         metadata_lines = []
         
         for entry in memory_entries:
             content = entry["content"]
             source = entry["source"]
             
-            # Parse content into sections
+            # Parse content into sections and unsectioned items
             current_section = None
             current_items = []
             
@@ -690,11 +692,25 @@ class FrameworkLoader:
                     # Start new section
                     current_section = line
                     current_items = []
-                # Check for content lines (skip empty lines)
-                elif line.strip() and current_section:
-                    current_items.append(line)
+                # Check for content lines (including unsectioned bullet points)
+                elif line.strip():
+                    # If it's a bullet point or regular content
+                    if current_section:
+                        # Add to current section
+                        current_items.append(line)
+                    elif line.strip().startswith('-'):
+                        # It's an unsectioned bullet point - preserve it
+                        # Use content as key to detect duplicates
+                        # Project source overrides user source
+                        if line not in unsectioned_items or source == "project":
+                            unsectioned_items[line] = source
+                    # Skip other non-bullet unsectioned content (like headers)
+                    elif not line.strip().startswith('#'):
+                        # Include non-header orphaned content in unsectioned items
+                        if line not in unsectioned_items or source == "project":
+                            unsectioned_items[line] = source
             
-            # Save last section
+            # Save last section if exists
             if current_section and current_items:
                 if current_section not in all_sections:
                     all_sections[current_section] = {}
@@ -717,6 +733,13 @@ class FrameworkLoader:
         lines.append("*This memory combines user-level and project-level memories.*")
         lines.append("")
         
+        # Add unsectioned items first (if any)
+        if unsectioned_items:
+            # Sort items to ensure consistent output
+            for item in sorted(unsectioned_items.keys()):
+                lines.append(item)
+            lines.append("")  # Empty line after unsectioned items
+        
         # Add sections
         for section_header in sorted(all_sections.keys()):
             lines.append(section_header)

claude_mpm/core/service_registry.py

@@ -11,6 +11,7 @@ from .base_service import BaseService
 from .config import Config
 from .container import DIContainer, ServiceLifetime, get_container
 from .logger import get_logger
+from .shared.config_loader import ConfigLoader
 
 if TYPE_CHECKING:
     from claude_mpm.services.agents.deployment import AgentDeploymentService
@@ -46,8 +47,9 @@ class ServiceRegistry:
         from .agent_session_manager import AgentSessionManager
         from .session_manager import SessionManager
 
-        # Register configuration as singleton with name
-        config = Config()
+        # Register configuration as singleton with name using ConfigLoader
+        config_loader = ConfigLoader()
+        config = config_loader.load_main_config()
         self.container.register_singleton(Config, instance=config, name="main_config")
 
         # Register core services with proper lifetime management

claude_mpm/core/shared/__init__.py

@@ -0,0 +1,17 @@
+"""
+Shared core utilities to reduce code duplication.
+
+This module provides common utilities that can be used across
+different parts of the application.
+"""
+
+from .config_loader import ConfigLoader, ConfigPattern
+from .path_resolver import PathResolver
+from .singleton_manager import SingletonManager
+
+__all__ = [
+    "ConfigLoader",
+    "ConfigPattern", 
+    "PathResolver",
+    "SingletonManager",
+]

claude_mpm/core/shared/config_loader.py

@@ -0,0 +1,320 @@
+"""
+Shared configuration loading utilities to reduce duplication.
+"""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from ..config import Config
+from ..logger import get_logger
+
+
+@dataclass
+class ConfigPattern:
+    """Configuration loading pattern definition."""
+    
+    # File patterns to search for
+    filenames: List[str]
+    
+    # Search paths (relative to working directory)
+    search_paths: List[str]
+    
+    # Environment variable prefix
+    env_prefix: Optional[str] = None
+    
+    # Default values
+    defaults: Optional[Dict[str, Any]] = None
+    
+    # Required configuration keys
+    required_keys: Optional[List[str]] = None
+    
+    # Configuration section name
+    section: Optional[str] = None
+
+
+class ConfigLoader:
+    """
+    Centralized configuration loading utility.
+    
+    Reduces duplication by providing standard patterns for:
+    - Configuration file discovery
+    - Environment variable loading
+    - Default value management
+    - Configuration validation
+    """
+    
+    # Standard configuration patterns
+    AGENT_CONFIG = ConfigPattern(
+        filenames=[".agent.yaml", ".agent.yml", "agent.yaml", "agent.yml"],
+        search_paths=[".", ".claude-mpm", "agents"],
+        env_prefix="CLAUDE_MPM_AGENT_",
+        defaults={
+            "timeout": 30,
+            "max_retries": 3,
+            "log_level": "INFO"
+        },
+        required_keys=["name", "model"]
+    )
+    
+    MEMORY_CONFIG = ConfigPattern(
+        filenames=[".memory.yaml", ".memory.yml", "memory.yaml", "memory.yml"],
+        search_paths=[".", ".claude-mpm", "memories"],
+        env_prefix="CLAUDE_MPM_MEMORY_",
+        defaults={
+            "max_entries": 1000,
+            "cleanup_interval": 3600,
+            "compression": True
+        }
+    )
+    
+    SERVICE_CONFIG = ConfigPattern(
+        filenames=[".service.yaml", ".service.yml", "service.yaml", "service.yml"],
+        search_paths=[".", ".claude-mpm", "config"],
+        env_prefix="CLAUDE_MPM_SERVICE_",
+        defaults={
+            "enabled": True,
+            "auto_start": False,
+            "health_check_interval": 60
+        }
+    )
+    
+    def __init__(self, working_dir: Union[str, Path] = None):
+        """
+        Initialize config loader.
+        
+        Args:
+            working_dir: Working directory for relative paths
+        """
+        self.working_dir = Path(working_dir) if working_dir else Path.cwd()
+        self.logger = get_logger("config_loader")
+        self._cache: Dict[str, Config] = {}
+    
+    def load_config(self, 
+                   pattern: ConfigPattern,
+                   cache_key: str = None,
+                   force_reload: bool = False) -> Config:
+        """
+        Load configuration using a pattern.
+        
+        Args:
+            pattern: Configuration pattern to use
+            cache_key: Optional cache key (defaults to pattern hash)
+            force_reload: Force reload even if cached
+            
+        Returns:
+            Loaded configuration
+        """
+        # Generate cache key if not provided
+        if cache_key is None:
+            cache_key = self._generate_cache_key(pattern)
+        
+        # Check cache
+        if not force_reload and cache_key in self._cache:
+            self.logger.debug(f"Using cached config: {cache_key}")
+            return self._cache[cache_key]
+        
+        # Start with defaults
+        config_data = pattern.defaults.copy() if pattern.defaults else {}
+        
+        # Load from files
+        config_file = self._find_config_file(pattern)
+        if config_file:
+            file_config = self._load_config_file(config_file)
+            if pattern.section:
+                file_config = file_config.get(pattern.section, {})
+            config_data.update(file_config)
+            self.logger.info(f"Loaded config from: {config_file}")
+        
+        # Load from environment
+        if pattern.env_prefix:
+            env_config = self._load_env_config(pattern.env_prefix)
+            config_data.update(env_config)
+            if env_config:
+                self.logger.debug(f"Loaded {len(env_config)} env vars with prefix {pattern.env_prefix}")
+        
+        # Create config instance
+        config = Config(config_data)
+        
+        # Validate required keys
+        if pattern.required_keys:
+            self._validate_required_keys(config, pattern.required_keys)
+        
+        # Cache the result
+        self._cache[cache_key] = config
+        
+        return config
+    
+    def load_agent_config(self, agent_dir: Union[str, Path] = None) -> Config:
+        """Load agent configuration."""
+        pattern = self.AGENT_CONFIG
+        if agent_dir:
+            # Override search paths for specific agent directory
+            pattern = ConfigPattern(
+                filenames=pattern.filenames,
+                search_paths=[str(agent_dir)],
+                env_prefix=pattern.env_prefix,
+                defaults=pattern.defaults,
+                required_keys=pattern.required_keys
+            )
+        
+        return self.load_config(pattern, cache_key=f"agent_{agent_dir}")
+
+    def load_main_config(self) -> Config:
+        """Load main application configuration."""
+        pattern = ConfigPattern(
+            filenames=["claude-mpm.yaml", "claude-mpm.yml", ".claude-mpm.yaml", ".claude-mpm.yml", "config.yaml", "config.yml"],
+            search_paths=["~/.config/claude-mpm", ".", "./config", "/etc/claude-mpm"],
+            env_prefix="CLAUDE_MPM_",
+            defaults={}
+        )
+        return self.load_config(pattern, cache_key="main_config")
+
+    def load_memory_config(self, memory_dir: Union[str, Path] = None) -> Config:
+        """Load memory configuration."""
+        pattern = self.MEMORY_CONFIG
+        if memory_dir:
+            pattern = ConfigPattern(
+                filenames=pattern.filenames,
+                search_paths=[str(memory_dir)],
+                env_prefix=pattern.env_prefix,
+                defaults=pattern.defaults
+            )
+        
+        return self.load_config(pattern, cache_key=f"memory_{memory_dir}")
+    
+    def load_service_config(self, service_name: str, config_dir: Union[str, Path] = None) -> Config:
+        """Load service configuration."""
+        pattern = self.SERVICE_CONFIG
+        
+        # Add service-specific filenames
+        service_filenames = [
+            f".{service_name}.yaml",
+            f".{service_name}.yml", 
+            f"{service_name}.yaml",
+            f"{service_name}.yml"
+        ]
+        
+        pattern = ConfigPattern(
+            filenames=service_filenames + pattern.filenames,
+            search_paths=[str(config_dir)] if config_dir else pattern.search_paths,
+            env_prefix=f"CLAUDE_MPM_{service_name.upper()}_",
+            defaults=pattern.defaults,
+            section=service_name
+        )
+        
+        return self.load_config(pattern, cache_key=f"service_{service_name}")
+    
+    def _find_config_file(self, pattern: ConfigPattern) -> Optional[Path]:
+        """Find configuration file using pattern."""
+        for search_path in pattern.search_paths:
+            search_dir = self.working_dir / search_path
+            if not search_dir.exists():
+                continue
+            
+            for filename in pattern.filenames:
+                config_file = search_dir / filename
+                if config_file.exists() and config_file.is_file():
+                    return config_file
+        
+        return None
+    
+    def _load_config_file(self, config_file: Path) -> Dict[str, Any]:
+        """Load configuration from file."""
+        try:
+            import yaml
+            
+            with open(config_file, 'r') as f:
+                if config_file.suffix.lower() in ('.yaml', '.yml'):
+                    return yaml.safe_load(f) or {}
+                else:
+                    # Try JSON as fallback
+                    import json
+                    f.seek(0)
+                    return json.load(f)
+        
+        except Exception as e:
+            self.logger.error(f"Failed to load config file {config_file}: {e}")
+            return {}
+    
+    def _load_env_config(self, prefix: str) -> Dict[str, Any]:
+        """Load configuration from environment variables."""
+        config = {}
+        
+        for key, value in os.environ.items():
+            if key.startswith(prefix):
+                # Convert env var name to config key
+                config_key = key[len(prefix):].lower().replace('_', '.')
+                
+                # Try to parse value
+                parsed_value = self._parse_env_value(value)
+                config[config_key] = parsed_value
+        
+        return config
+    
+    def _parse_env_value(self, value: str) -> Any:
+        """Parse environment variable value."""
+        # Try boolean
+        if value.lower() in ('true', 'false'):
+            return value.lower() == 'true'
+        
+        # Try integer
+        try:
+            return int(value)
+        except ValueError:
+            pass
+        
+        # Try float
+        try:
+            return float(value)
+        except ValueError:
+            pass
+        
+        # Try JSON
+        try:
+            import json
+            return json.loads(value)
+        except (json.JSONDecodeError, ValueError):
+            pass
+        
+        # Return as string
+        return value
+    
+    def _validate_required_keys(self, config: Config, required_keys: List[str]) -> None:
+        """Validate that required keys are present."""
+        missing_keys = []
+        
+        for key in required_keys:
+            if config.get(key) is None:
+                missing_keys.append(key)
+        
+        if missing_keys:
+            raise ValueError(f"Missing required configuration keys: {missing_keys}")
+    
+    def _generate_cache_key(self, pattern: ConfigPattern) -> str:
+        """Generate cache key for pattern."""
+        import hashlib
+        
+        # Create a string representation of the pattern
+        pattern_str = f"{pattern.filenames}_{pattern.search_paths}_{pattern.env_prefix}"
+        
+        # Generate hash
+        return hashlib.md5(pattern_str.encode()).hexdigest()[:8]
+    
+    def clear_cache(self, cache_key: str = None) -> None:
+        """Clear configuration cache."""
+        if cache_key:
+            self._cache.pop(cache_key, None)
+            self.logger.debug(f"Cleared cache for: {cache_key}")
+        else:
+            self._cache.clear()
+            self.logger.debug("Cleared all config cache")
+    
+    def get_cache_info(self) -> Dict[str, Any]:
+        """Get cache information."""
+        return {
+            "cached_configs": len(self._cache),
+            "cache_keys": list(self._cache.keys()),
+            "working_dir": str(self.working_dir)
+        }