claude-mpm 3.8.1__py3-none-any.whl → 3.9.2__py3-none-any.whl

claude_mpm/core/container.py

@@ -18,6 +18,7 @@ from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Set, Type, TypeVar, Union
 
 from .logger import get_logger
+from claude_mpm.services.core.interfaces import IServiceContainer
 
 logger = get_logger(__name__)
 
@@ -144,10 +145,13 @@ class ServiceScope:
         self.dispose()
 
 
-class DIContainer:
+class DIContainer(IServiceContainer):
     """
     Enhanced Dependency Injection Container.
     
+    Implements IServiceContainer interface to provide a complete
+    dependency injection solution.
+    
     Provides:
     - Service registration with multiple lifetime options
     - Automatic constructor injection
@@ -174,6 +178,34 @@ class DIContainer:
         self._current_scope: Optional[ServiceScope] = None
         
     def register(
+        self,
+        service_type: type,
+        implementation: type,
+        singleton: bool = True
+    ) -> None:
+        """
+        Register a service implementation (IServiceContainer interface method).
+        
+        Args:
+            service_type: The interface/base type to register
+            implementation: The concrete implementation class
+            singleton: Whether to use singleton lifetime (default True)
+            
+        Examples:
+            # Register interface with implementation
+            container.register(ILogger, ConsoleLogger)
+            
+            # Register as transient (new instance each time)
+            container.register(IService, ServiceImpl, singleton=False)
+        """
+        lifetime = ServiceLifetime.SINGLETON if singleton else ServiceLifetime.TRANSIENT
+        self._register_internal(
+            service_type=service_type,
+            implementation=implementation,
+            lifetime=lifetime
+        )
+    
+    def _register_internal(
         self,
         service_type: Type[T],
         implementation: Optional[Union[Type[T], Callable[..., T]]] = None,
@@ -183,7 +215,7 @@ class DIContainer:
         dependencies: Optional[Dict[str, Type]] = None
     ) -> None:
         """
-        Register a service in the container.
+        Internal registration method with full flexibility.
         
         Args:
             service_type: The interface/base type to register
@@ -192,19 +224,6 @@ class DIContainer:
             factory: Optional factory function
             instance: Pre-created instance (for singleton)
             dependencies: Explicit dependency mapping for constructor params
-            
-        Examples:
-            # Register interface with implementation
-            container.register(ILogger, ConsoleLogger)
-            
-            # Register with factory
-            container.register(IDatabase, factory=lambda c: Database(c.resolve(IConfig)))
-            
-            # Register singleton instance
-            container.register(IConfig, instance=Config())
-            
-            # Register with explicit dependencies
-            container.register(IService, ServiceImpl, dependencies={'logger': ILogger})
         """
         with self._lock:
             registration = ServiceRegistration(
@@ -220,6 +239,50 @@ class DIContainer:
             # If instance provided, store as singleton
             if instance is not None:
                 self._singletons[service_type] = instance
+    
+    def register_instance(self, service_type: type, instance: Any) -> None:
+        """
+        Register a service instance (IServiceContainer interface method).
+        
+        Args:
+            service_type: The interface/base type to register
+            instance: Pre-created instance to register as singleton
+            
+        Examples:
+            # Register a pre-created instance
+            config = Config()
+            container.register_instance(IConfig, config)
+        """
+        self._register_internal(
+            service_type=service_type,
+            instance=instance,
+            lifetime=ServiceLifetime.SINGLETON
+        )
+    
+    def resolve_all(self, service_type: type) -> List[Any]:
+        """
+        Resolve all implementations of a service type (IServiceContainer interface method).
+        
+        Args:
+            service_type: The type to resolve
+            
+        Returns:
+            List of all registered implementations for the service type
+            
+        Examples:
+            # Register multiple implementations
+            container.register(IPlugin, PluginA)
+            container.register(IPlugin, PluginB)
+            
+            # Get all implementations
+            plugins = container.resolve_all(IPlugin)
+        """
+        with self._lock:
+            # For now, return a list with the single registered implementation
+            # In the future, we could support multiple registrations for the same type
+            if service_type in self._registrations:
+                return [self._resolve_internal(service_type)]
+            return []
                 
     def register_singleton(
         self,
@@ -274,12 +337,12 @@ class DIContainer:
         else:
             # Normal registration without name
             if instance is not None:
-                self.register(interface, instance=instance)
+                self._register_internal(interface, instance=instance)
             elif implementation is not None and not inspect.isclass(implementation):
                 # It's an instance passed as implementation (backward compatibility)
-                self.register(interface, instance=implementation)
+                self._register_internal(interface, instance=implementation)
             else:
-                self.register(interface, implementation, lifetime=ServiceLifetime.SINGLETON)
+                self._register_internal(interface, implementation, lifetime=ServiceLifetime.SINGLETON)
                 
         # Handle disposal handler
         if dispose_handler:
@@ -321,7 +384,7 @@ class DIContainer:
                 context = container.get(IRequestContext)  # Created
                 context2 = container.get(IRequestContext)  # Same instance
         """
-        self.register(interface, implementation, lifetime=ServiceLifetime.SCOPED)
+        self._register_internal(interface, implementation, lifetime=ServiceLifetime.SCOPED)
         if name:
             self._named_registrations[name] = self._registrations[interface]
     
@@ -335,7 +398,7 @@ class DIContainer:
         
         Convenience method for registering transient services.
         """
-        self.register(service_type, implementation, lifetime=ServiceLifetime.TRANSIENT)
+        self._register_internal(service_type, implementation, lifetime=ServiceLifetime.TRANSIENT)
         
     def register_factory(
         self,
@@ -363,7 +426,7 @@ class DIContainer:
                 lifetime=ServiceLifetime.SINGLETON
             )
         """
-        self.register(interface, factory=factory, lifetime=lifetime)
+        self._register_internal(interface, factory=factory, lifetime=lifetime)
         self._factories[interface] = factory
         if name:
             self._named_registrations[name] = self._registrations[interface]
@@ -551,6 +614,12 @@ class DIContainer:
                         module = frame.f_globals
                         if param_type in module:
                             param_type = module[param_type]
+                        else:
+                            # Try looking in registrations by name
+                            for reg_type in self._registrations:
+                                if reg_type.__name__ == param_type:
+                                    param_type = reg_type
+                                    break
                     except:
                         # If we can't resolve, skip this parameter
                         if param.default != param.empty:
@@ -564,11 +633,13 @@ class DIContainer:
                     param_type = next((arg for arg in args if arg is not type(None)), None)
                     
                 if param_type and param_type in self._registrations:
-                    # Avoid circular dependency by checking if we're already resolving this type
-                    if param_type not in self._resolving:
+                    # Check for circular dependency
+                    if param_type in self._resolving:
+                        # Circular dependency detected
+                        cycle = " -> ".join(str(t.__name__) for t in self._resolving) + f" -> {param_type.__name__}"
+                        raise CircularDependencyError(f"Circular dependency detected: {cycle}")
+                    else:
                         kwargs[param_name] = self.resolve(param_type)
-                    elif param.default != param.empty:
-                        kwargs[param_name] = param.default
                 elif param.default != param.empty:
                     # Use default value
                     kwargs[param_name] = param.default

claude_mpm/core/framework_loader.py

@@ -204,6 +204,37 @@ class FrameworkLoader:
                     content["project_workflow"] = "system"
                     self.logger.info("Using system WORKFLOW.md")
     
+    def _load_memory_instructions(self, content: Dict[str, Any]) -> None:
+        """
+        Load MEMORY.md with project-specific override support.
+        
+        Precedence:
+        1. Project-specific: .claude-mpm/agents/MEMORY.md
+        2. System default: src/claude_mpm/agents/MEMORY.md
+        
+        Args:
+            content: Dictionary to update with memory instructions
+        """
+        # Check for project-specific memory instructions first
+        project_memory_path = Path.cwd() / ".claude-mpm" / "agents" / "MEMORY.md"
+        if project_memory_path.exists():
+            loaded_content = self._try_load_file(project_memory_path, "project-specific MEMORY.md")
+            if loaded_content:
+                content["memory_instructions"] = loaded_content
+                content["project_memory"] = "project"
+                self.logger.info("Using project-specific MEMORY.md")
+                return
+        
+        # Fall back to system memory instructions
+        if self.framework_path:
+            system_memory_path = self.framework_path / "src" / "claude_mpm" / "agents" / "MEMORY.md"
+            if system_memory_path.exists():
+                loaded_content = self._try_load_file(system_memory_path, "system MEMORY.md")
+                if loaded_content:
+                    content["memory_instructions"] = loaded_content
+                    content["project_memory"] = "system"
+                    self.logger.info("Using system MEMORY.md")
+    
     def _load_single_agent(self, agent_file: Path) -> tuple[Optional[str], Optional[str]]:
         """
         Load a single agent file.
@@ -277,7 +308,9 @@ class FrameworkLoader:
             "working_claude_md": "",
             "framework_instructions": "",
             "workflow_instructions": "",
-            "project_workflow": ""
+            "project_workflow": "",
+            "memory_instructions": "",
+            "project_memory": ""
         }
         
         # Load instructions file from working directory
@@ -311,6 +344,9 @@ class FrameworkLoader:
         # Load WORKFLOW.md - check for project-specific first, then system
         self._load_workflow_instructions(content)
         
+        # Load MEMORY.md - check for project-specific first, then system
+        self._load_memory_instructions(content)
+        
         # Discover agent directories
         agents_dir, templates_dir, main_dir = self._discover_framework_paths()
         
@@ -364,6 +400,12 @@ class FrameworkLoader:
                 instructions += f"\n\n{workflow_content}\n"
                 # Note: project-specific workflow is being used (logged elsewhere)
             
+            # Add MEMORY.md after workflow instructions
+            if self.framework_content.get("memory_instructions"):
+                memory_content = self._strip_metadata_comments(self.framework_content['memory_instructions'])
+                instructions += f"\n\n{memory_content}\n"
+                # Note: project-specific memory instructions being used (logged elsewhere)
+            
             # Add dynamic agent capabilities section
             instructions += self._generate_agent_capabilities_section()
             

claude_mpm/core/interactive_session.py

@@ -40,6 +40,29 @@ class InteractiveSession:
         self.session_id = None
         self.original_cwd = os.getcwd()
         
+        # Initialize response tracking for interactive sessions
+        # WHY: Interactive sessions need response logging just like oneshot sessions.
+        # The hook system captures events, but we need the ResponseTracker to be
+        # initialized to actually store them.
+        self.response_tracker = None
+        
+        # Check if response logging is enabled in configuration
+        try:
+            response_config = self.runner.config.get('response_logging', {})
+            response_logging_enabled = response_config.get('enabled', False)
+        except (AttributeError, TypeError):
+            # Handle mock or missing config gracefully
+            response_logging_enabled = False
+        
+        if response_logging_enabled:
+            try:
+                from claude_mpm.services.response_tracker import ResponseTracker
+                self.response_tracker = ResponseTracker(self.runner.config)
+                self.logger.info("Response tracking initialized for interactive session")
+            except Exception as e:
+                self.logger.warning(f"Failed to initialize response tracker: {e}")
+                # Continue without response tracking - not fatal
+        
     def initialize_interactive_session(self) -> Tuple[bool, Optional[str]]:
         """Initialize the interactive session environment.
         
@@ -71,6 +94,18 @@ class InteractiveSession:
                     component="session"
                 )
             
+            # Initialize response tracking session if enabled
+            # WHY: The ResponseTracker needs to know about the session to properly
+            # correlate prompts and responses during the interactive session.
+            if self.response_tracker and self.response_tracker.enabled:
+                try:
+                    # Set the session ID in the tracker for correlation
+                    if hasattr(self.response_tracker, 'session_logger') and self.response_tracker.session_logger:
+                        self.response_tracker.session_logger.set_session_id(self.session_id)
+                        self.logger.debug(f"Response tracker session ID set to: {self.session_id}")
+                except Exception as e:
+                    self.logger.debug(f"Could not set session ID in response tracker: {e}")
+            
             return True, None
             
         except Exception as e:
@@ -213,6 +248,18 @@ class InteractiveSession:
                     "event": "session_end",
                     "session_id": self.session_id
                 })
+            
+            # Clean up response tracker if initialized
+            # WHY: Ensure proper cleanup of response tracking resources and
+            # finalize any pending response logs.
+            if self.response_tracker:
+                try:
+                    # Clear the session ID to stop tracking this session
+                    if hasattr(self.response_tracker, 'session_logger') and self.response_tracker.session_logger:
+                        self.response_tracker.session_logger.set_session_id(None)
+                        self.logger.debug("Response tracker session cleared")
+                except Exception as e:
+                    self.logger.debug(f"Error clearing response tracker session: {e}")
                 
         except Exception as e:
             self.logger.debug(f"Error during cleanup: {e}")