claude-mpm 4.1.1__py3-none-any.whl → 4.1.3__py3-none-any.whl

claude_mpm/services/core/base.py

@@ -9,7 +9,6 @@ and lifecycle management.
 Part of TSK-0046: Service Layer Architecture Reorganization
 """
 
-import logging
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional
 
@@ -56,7 +55,6 @@ class BaseService(ABC):
         Returns:
             True if initialization successful, False otherwise
         """
-        pass
 
     @abstractmethod
     async def shutdown(self) -> None:
@@ -65,7 +63,6 @@ class BaseService(ABC):
 
         This method should clean up any resources held by the service.
         """
-        pass
 
     def get_config(self, key: str, default: Any = None) -> Any:
         """
@@ -157,7 +154,6 @@ class SyncBaseService(ABC):
         Returns:
             True if initialization successful, False otherwise
         """
-        pass
 
     @abstractmethod
     def shutdown(self) -> None:
@@ -166,7 +162,6 @@ class SyncBaseService(ABC):
 
         This method should clean up any resources held by the service.
         """
-        pass
 
     def get_config(self, key: str, default: Any = None) -> Any:
         """

claude_mpm/services/core/cache_manager.py

@@ -0,0 +1,311 @@
+"""
+Cache Manager Service for Framework Loader
+==========================================
+
+WHY: This service extracts and centralizes cache management logic from the FrameworkLoader,
+providing a clean interface for managing multiple cache types with different TTLs.
+
+DESIGN DECISION: Built on top of the existing FileSystemCache infrastructure while
+providing a specialized interface for framework-specific caching needs.
+
+EXTRACTED FROM: core/framework_loader.py (lines 89-140)
+- Reduces FrameworkLoader complexity by ~50 lines
+- Provides thread-safe, type-specific cache management
+
+NOTE: The ICacheManager interface has been moved to service_interfaces.py for
+better organization and to support dependency injection.
+"""
+
+import threading
+import time
+from typing import Any, Dict, Optional, Set, Tuple
+
+from claude_mpm.core.cache import FileSystemCache
+from claude_mpm.core.logger import get_logger
+
+# Import interface from consolidated location
+from .service_interfaces import ICacheManager
+
+
+class CacheManager(ICacheManager):
+    """
+    Centralized cache management service for framework loader.
+
+    This service manages multiple cache types with different TTLs:
+    - Agent capabilities (60s TTL)
+    - Deployed agents (30s TTL)
+    - Agent metadata (60s TTL)
+    - Memories (60s TTL)
+
+    Thread-safe implementation using locks for concurrent access.
+    """
+
+    # Default TTL values (in seconds)
+    DEFAULT_CAPABILITIES_TTL = 60
+    DEFAULT_DEPLOYED_AGENTS_TTL = 30
+    DEFAULT_METADATA_TTL = 60
+    DEFAULT_MEMORIES_TTL = 60
+
+    def __init__(
+        self,
+        capabilities_ttl: float = DEFAULT_CAPABILITIES_TTL,
+        deployed_agents_ttl: float = DEFAULT_DEPLOYED_AGENTS_TTL,
+        metadata_ttl: float = DEFAULT_METADATA_TTL,
+        memories_ttl: float = DEFAULT_MEMORIES_TTL,
+    ):
+        """
+        Initialize cache manager with configurable TTLs.
+
+        Args:
+            capabilities_ttl: TTL for agent capabilities cache
+            deployed_agents_ttl: TTL for deployed agents cache
+            metadata_ttl: TTL for agent metadata cache
+            memories_ttl: TTL for memories cache
+        """
+        self.logger = get_logger("cache_manager")
+
+        # TTL configuration
+        self.capabilities_ttl = capabilities_ttl
+        self.deployed_agents_ttl = deployed_agents_ttl
+        self.metadata_ttl = metadata_ttl
+        self.memories_ttl = memories_ttl
+
+        # Cache storage with timestamps
+        self._capabilities_cache: Optional[str] = None
+        self._capabilities_cache_time: float = 0
+
+        self._deployed_agents_cache: Optional[Set[str]] = None
+        self._deployed_agents_cache_time: float = 0
+
+        self._agent_metadata_cache: Dict[
+            str, Tuple[Optional[Dict[str, Any]], float]
+        ] = {}
+
+        self._memories_cache: Optional[Dict[str, Any]] = None
+        self._memories_cache_time: float = 0
+
+        # Thread safety
+        self._lock = threading.RLock()
+
+        # Underlying file system cache (optional, for persistence)
+        self._fs_cache = FileSystemCache(
+            max_size_mb=50,  # 50MB for framework caches
+            default_ttl=max(
+                capabilities_ttl, deployed_agents_ttl, metadata_ttl, memories_ttl
+            ),
+        )
+
+        self.logger.debug(
+            f"Cache manager initialized with TTLs: "
+            f"capabilities={capabilities_ttl}s, "
+            f"deployed_agents={deployed_agents_ttl}s, "
+            f"metadata={metadata_ttl}s, "
+            f"memories={memories_ttl}s"
+        )
+
+    def is_cache_valid(self, cache_time: float, ttl: float) -> bool:
+        """Check if a cache entry is still valid based on its timestamp and TTL."""
+        current_time = time.time()
+        age = current_time - cache_time
+        return age < ttl
+
+    # Agent capabilities cache
+    def get_capabilities(self) -> Optional[str]:
+        """Get cached agent capabilities."""
+        with self._lock:
+            if self._capabilities_cache is not None and self.is_cache_valid(
+                self._capabilities_cache_time, self.capabilities_ttl
+            ):
+                age = time.time() - self._capabilities_cache_time
+                self.logger.debug(f"Cache hit: agent capabilities (age: {age:.1f}s)")
+                return self._capabilities_cache
+
+            self.logger.debug("Cache miss: agent capabilities")
+            return None
+
+    def set_capabilities(self, value: str) -> None:
+        """Set agent capabilities cache."""
+        with self._lock:
+            self._capabilities_cache = value
+            self._capabilities_cache_time = time.time()
+            self.logger.debug("Updated agent capabilities cache")
+
+    # Deployed agents cache
+    def get_deployed_agents(self) -> Optional[Set[str]]:
+        """Get cached deployed agents set."""
+        with self._lock:
+            if self._deployed_agents_cache is not None and self.is_cache_valid(
+                self._deployed_agents_cache_time, self.deployed_agents_ttl
+            ):
+                age = time.time() - self._deployed_agents_cache_time
+                self.logger.debug(f"Cache hit: deployed agents (age: {age:.1f}s)")
+                return (
+                    self._deployed_agents_cache.copy()
+                )  # Return a copy to prevent external modification
+
+            self.logger.debug("Cache miss: deployed agents")
+            return None
+
+    def set_deployed_agents(self, agents: Set[str]) -> None:
+        """Set deployed agents cache."""
+        with self._lock:
+            self._deployed_agents_cache = agents.copy()  # Store a copy
+            self._deployed_agents_cache_time = time.time()
+            self.logger.debug(
+                f"Updated deployed agents cache with {len(agents)} agents"
+            )
+
+    # Agent metadata cache
+    def get_agent_metadata(
+        self, agent_file: str
+    ) -> Optional[Tuple[Optional[Dict[str, Any]], float]]:
+        """Get cached agent metadata for a specific file."""
+        with self._lock:
+            if agent_file in self._agent_metadata_cache:
+                cached_data, cached_mtime = self._agent_metadata_cache[agent_file]
+                # Check if cache is still valid
+                if self.is_cache_valid(cached_mtime, self.metadata_ttl):
+                    self.logger.debug(f"Cache hit: metadata for {agent_file}")
+                    return cached_data, cached_mtime
+
+            self.logger.debug(f"Cache miss: metadata for {agent_file}")
+            return None
+
+    def set_agent_metadata(
+        self, agent_file: str, metadata: Optional[Dict[str, Any]], mtime: float
+    ) -> None:
+        """Set agent metadata cache for a specific file."""
+        with self._lock:
+            self._agent_metadata_cache[agent_file] = (metadata, mtime)
+            self.logger.debug(f"Updated metadata cache for {agent_file}")
+
+    # Memories cache
+    def get_memories(self) -> Optional[Dict[str, Any]]:
+        """Get cached memories."""
+        with self._lock:
+            if self._memories_cache is not None and self.is_cache_valid(
+                self._memories_cache_time, self.memories_ttl
+            ):
+                age = time.time() - self._memories_cache_time
+                self.logger.debug(f"Cache hit: memories (age: {age:.1f}s)")
+                return self._memories_cache.copy()  # Return a copy
+
+            self.logger.debug("Cache miss: memories")
+            return None
+
+    def set_memories(self, memories: Dict[str, Any]) -> None:
+        """Set memories cache."""
+        with self._lock:
+            self._memories_cache = memories.copy()  # Store a copy
+            self._memories_cache_time = time.time()
+            self.logger.debug("Updated memories cache")
+
+    # Cache clearing methods
+    def clear_all(self) -> None:
+        """Clear all caches."""
+        with self._lock:
+            self.logger.info("Clearing all caches")
+
+            # Clear capabilities
+            self._capabilities_cache = None
+            self._capabilities_cache_time = 0
+
+            # Clear deployed agents
+            self._deployed_agents_cache = None
+            self._deployed_agents_cache_time = 0
+
+            # Clear metadata
+            self._agent_metadata_cache.clear()
+
+            # Clear memories
+            self._memories_cache = None
+            self._memories_cache_time = 0
+
+            # Clear underlying file system cache
+            self._fs_cache.clear()
+
+    def clear_agent_caches(self) -> None:
+        """Clear agent-related caches only."""
+        with self._lock:
+            self.logger.info("Clearing agent-related caches")
+
+            # Clear capabilities
+            self._capabilities_cache = None
+            self._capabilities_cache_time = 0
+
+            # Clear deployed agents
+            self._deployed_agents_cache = None
+            self._deployed_agents_cache_time = 0
+
+            # Clear metadata
+            self._agent_metadata_cache.clear()
+
+    def clear_memory_caches(self) -> None:
+        """Clear memory-related caches only."""
+        with self._lock:
+            self.logger.info("Clearing memory caches")
+
+            self._memories_cache = None
+            self._memories_cache_time = 0
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics."""
+        with self._lock:
+            current_time = time.time()
+
+            stats = {
+                "capabilities": {
+                    "cached": self._capabilities_cache is not None,
+                    "age": (
+                        current_time - self._capabilities_cache_time
+                        if self._capabilities_cache
+                        else None
+                    ),
+                    "valid": (
+                        self.is_cache_valid(
+                            self._capabilities_cache_time, self.capabilities_ttl
+                        )
+                        if self._capabilities_cache
+                        else False
+                    ),
+                },
+                "deployed_agents": {
+                    "cached": self._deployed_agents_cache is not None,
+                    "count": (
+                        len(self._deployed_agents_cache)
+                        if self._deployed_agents_cache
+                        else 0
+                    ),
+                    "age": (
+                        current_time - self._deployed_agents_cache_time
+                        if self._deployed_agents_cache
+                        else None
+                    ),
+                    "valid": (
+                        self.is_cache_valid(
+                            self._deployed_agents_cache_time, self.deployed_agents_ttl
+                        )
+                        if self._deployed_agents_cache
+                        else False
+                    ),
+                },
+                "metadata": {"entries": len(self._agent_metadata_cache)},
+                "memories": {
+                    "cached": self._memories_cache is not None,
+                    "age": (
+                        current_time - self._memories_cache_time
+                        if self._memories_cache
+                        else None
+                    ),
+                    "valid": (
+                        self.is_cache_valid(
+                            self._memories_cache_time, self.memories_ttl
+                        )
+                        if self._memories_cache
+                        else False
+                    ),
+                },
+                "fs_cache": self._fs_cache.get_stats() if self._fs_cache else {},
+            }
+
+            return stats

claude_mpm/services/core/interfaces/__init__.py

@@ -143,46 +143,46 @@ class InterfaceRegistry:
 
 # Re-export everything for backward compatibility
 __all__ = [
-    # Type variables
-    "T",
-    "ServiceType",
-    # Infrastructure interfaces
-    "IServiceContainer",
-    "IConfigurationService",
-    "IConfigurationManager",
-    "ICacheService",
-    "IPromptCache",
+    "AgentCapabilitiesInterface",
+    "AgentDeploymentInterface",
+    "AgentMetadata",
     "CacheEntry",
-    "IHealthMonitor",
+    "CommandHandlerInterface",
     "HealthStatus",
-    "ITemplateManager",
-    "TemplateRenderContext",
-    "IServiceFactory",
-    "IStructuredLogger",
-    "IServiceLifecycle",
-    "IErrorHandler",
-    "IPerformanceMonitor",
-    "IEventBus",
+    "HookServiceInterface",
     # Agent interfaces
     "IAgentRegistry",
-    "AgentMetadata",
-    "AgentDeploymentInterface",
-    "AgentCapabilitiesInterface",
-    "SystemInstructionsInterface",
-    "SubprocessLauncherInterface",
-    "RunnerConfigurationInterface",
-    # Service interfaces
-    "VersionServiceInterface",
-    "CommandHandlerInterface",
+    "ICacheService",
+    "IConfigurationManager",
+    "IConfigurationService",
+    "IErrorHandler",
+    "IEventBus",
+    "IHealthMonitor",
+    "IPerformanceMonitor",
+    "IPromptCache",
+    # Infrastructure interfaces
+    "IServiceContainer",
+    "IServiceFactory",
+    "IServiceLifecycle",
+    "IStructuredLogger",
+    "ITemplateManager",
+    # Registry
+    "InterfaceRegistry",
     "MemoryHookInterface",
     "MemoryServiceInterface",
+    "ProjectAnalyzerInterface",
+    "RunnerConfigurationInterface",
+    "ServiceType",
     "SessionManagementInterface",
-    "UtilityServiceInterface",
-    "HookServiceInterface",
     # Communication interfaces
     "SocketIOServiceInterface",
-    "ProjectAnalyzerInterface",
+    "SubprocessLauncherInterface",
+    "SystemInstructionsInterface",
+    # Type variables
+    "T",
+    "TemplateRenderContext",
     "TicketManagerInterface",
-    # Registry
-    "InterfaceRegistry",
+    "UtilityServiceInterface",
+    # Service interfaces
+    "VersionServiceInterface",
 ]

claude_mpm/services/core/interfaces/agent.py

@@ -68,29 +68,24 @@ class IAgentRegistry(ABC):
         self, force_refresh: bool = False
     ) -> Dict[str, AgentMetadata]:
         """Discover all available agents"""
-        pass
 
     @abstractmethod
     async def get_agent(self, agent_name: str) -> Optional[AgentMetadata]:
         """Get specific agent metadata"""
-        pass
 
     @abstractmethod
     async def list_agents(
         self, agent_type: Optional[str] = None, tier: Optional[str] = None
     ) -> List[AgentMetadata]:
         """List agents with optional filtering"""
-        pass
 
     @abstractmethod
     async def get_specialized_agents(self, agent_type: str) -> List[AgentMetadata]:
         """Get agents of a specific specialized type"""
-        pass
 
     @abstractmethod
     async def refresh_agent_cache(self) -> None:
         """Refresh the agent metadata cache"""
-        pass
 
 
 # Agent deployment interface
@@ -118,7 +113,6 @@ class AgentDeploymentInterface(ABC):
         Returns:
             Dictionary with deployment results and status
         """
-        pass
 
     @abstractmethod
     def validate_agent(self, agent_path: Path) -> Tuple[bool, List[str]]:
@@ -130,7 +124,6 @@ class AgentDeploymentInterface(ABC):
         Returns:
             Tuple of (is_valid, list_of_errors)
         """
-        pass
 
     @abstractmethod
     def get_deployment_status(self, agent_name: str) -> Dict[str, Any]:
@@ -142,7 +135,6 @@ class AgentDeploymentInterface(ABC):
         Returns:
             Dictionary with deployment status information
         """
-        pass
 
 
 # Agent capabilities interface
@@ -168,7 +160,6 @@ class AgentCapabilitiesInterface(ABC):
         Returns:
             Formatted capabilities string for Claude consumption
         """
-        pass
 
 
 # System instructions interface
@@ -194,7 +185,6 @@ class SystemInstructionsInterface(ABC):
         Returns:
             Processed system instructions string
         """
-        pass
 
     @abstractmethod
     def get_available_instruction_types(self) -> List[str]:
@@ -203,7 +193,6 @@ class SystemInstructionsInterface(ABC):
         Returns:
             List of available instruction type names
         """
-        pass
 
     @abstractmethod
     def validate_instructions(self, instructions: str) -> Tuple[bool, List[str]]:
@@ -215,7 +204,6 @@ class SystemInstructionsInterface(ABC):
         Returns:
             Tuple of (is_valid, list_of_errors)
         """
-        pass
 
 
 # Subprocess launcher interface
@@ -241,7 +229,6 @@ class SubprocessLauncherInterface(ABC):
         Returns:
             Dictionary with subprocess information and handles
         """
-        pass
 
     @abstractmethod
     async def launch_subprocess_async(
@@ -256,7 +243,6 @@ class SubprocessLauncherInterface(ABC):
         Returns:
             Dictionary with subprocess information and handles
         """
-        pass
 
     @abstractmethod
     def terminate_subprocess(self, process_id: str) -> bool:
@@ -268,7 +254,6 @@ class SubprocessLauncherInterface(ABC):
         Returns:
             True if termination successful
         """
-        pass
 
     @abstractmethod
     def get_subprocess_status(self, process_id: str) -> Dict[str, Any]:
@@ -280,7 +265,6 @@ class SubprocessLauncherInterface(ABC):
         Returns:
             Dictionary with process status information
         """
-        pass
 
 
 # Runner configuration interface
@@ -306,7 +290,6 @@ class RunnerConfigurationInterface(ABC):
         Returns:
             Dictionary with initialization results
         """
-        pass
 
     @abstractmethod
     def register_services(self, service_container) -> None:
@@ -315,7 +298,6 @@ class RunnerConfigurationInterface(ABC):
         Args:
             service_container: Service container for registration
         """
-        pass
 
     @abstractmethod
     def load_configuration(self, config_path: Optional[Path] = None) -> Dict[str, Any]:
@@ -327,7 +309,6 @@ class RunnerConfigurationInterface(ABC):
         Returns:
             Loaded configuration dictionary
         """
-        pass
 
     @abstractmethod
     def validate_configuration(self, config: Dict[str, Any]) -> Tuple[bool, List[str]]:
@@ -339,7 +320,6 @@ class RunnerConfigurationInterface(ABC):
         Returns:
             Tuple of (is_valid, list_of_errors)
         """
-        pass
 
     @abstractmethod
     def setup_logging(self, config: Dict[str, Any]) -> None:
@@ -348,4 +328,3 @@ class RunnerConfigurationInterface(ABC):
         Args:
             config: Logging configuration
         """
-        pass