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

claude_mpm/core/injectable_service.py

@@ -6,8 +6,8 @@ making services easier to test and configure.
 """
 
 from abc import ABC
-from typing import Any, Dict, Optional, Type, TypeVar, Union
 from pathlib import Path
+from typing import Any, Dict, Optional, Type, TypeVar, Union
 
 from .base_service import BaseService
 from .container import DIContainer
@@ -15,20 +15,20 @@ from .logger import get_logger
 
 logger = get_logger(__name__)
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 class InjectableService(BaseService, ABC):
     """
     Enhanced base service with full dependency injection support.
-    
+
     Features:
     - Automatic dependency resolution from container
     - Property injection support
     - Service locator pattern (optional)
     - Easy testing with mock dependencies
     """
-    
+
     def __init__(
         self,
         name: str,
@@ -36,11 +36,11 @@ class InjectableService(BaseService, ABC):
         config_path: Optional[Path] = None,
         enable_enhanced_features: bool = True,
         container: Optional[DIContainer] = None,
-        **injected_deps
+        **injected_deps,
     ):
         """
         Initialize injectable service.
-        
+
         Args:
             name: Service name
             config: Configuration dictionary
@@ -52,48 +52,54 @@ class InjectableService(BaseService, ABC):
         # Store container before calling parent init
         self._di_container = container
         self._injected_deps = injected_deps
-        
+
         super().__init__(
             name=name,
             config=config,
             config_path=config_path,
             enable_enhanced_features=enable_enhanced_features,
-            container=container
+            container=container,
         )
-        
+
         # Inject dependencies after base initialization
         self._inject_dependencies()
-        
+
     def _inject_dependencies(self) -> None:
         """Inject dependencies based on class annotations."""
         # Get class annotations for dependency injection
-        annotations = getattr(self.__class__, '__annotations__', {})
-        
+        annotations = getattr(self.__class__, "__annotations__", {})
+
         for attr_name, attr_type in annotations.items():
             # Skip if already set or is a private attribute
-            if hasattr(self, attr_name) or attr_name.startswith('_'):
+            if hasattr(self, attr_name) or attr_name.startswith("_"):
                 continue
-                
+
             # Check if explicitly injected
             if attr_name in self._injected_deps:
                 setattr(self, attr_name, self._injected_deps[attr_name])
                 logger.debug(f"Injected {attr_name} from explicit dependencies")
                 continue
-                
+
             # Try to resolve from container
             if self._di_container:
                 try:
                     # Handle Optional types
-                    if hasattr(attr_type, '__origin__'):
+                    if hasattr(attr_type, "__origin__"):
                         if attr_type.__origin__ is Union:
                             # Get the non-None type from Optional
                             args = attr_type.__args__
-                            actual_type = next((arg for arg in args if arg is not type(None)), None)
+                            actual_type = next(
+                                (arg for arg in args if arg is not type(None)), None
+                            )
                             if actual_type:
-                                service = self._di_container.resolve_optional(actual_type)
+                                service = self._di_container.resolve_optional(
+                                    actual_type
+                                )
                                 if service:
                                     setattr(self, attr_name, service)
-                                    logger.debug(f"Injected optional {attr_name} from container")
+                                    logger.debug(
+                                        f"Injected optional {attr_name} from container"
+                                    )
                     else:
                         # Direct type resolution
                         service = self._di_container.resolve(attr_type)
@@ -101,106 +107,109 @@ class InjectableService(BaseService, ABC):
                         logger.debug(f"Injected {attr_name} from container")
                 except Exception as e:
                     logger.warning(f"Could not inject {attr_name}: {e}")
-                    
+
     def get_dependency(self, service_type: Type[T]) -> T:
         """
         Get a dependency from the container.
-        
+
         Service locator pattern - use sparingly, prefer constructor injection.
-        
+
         Args:
             service_type: Type to resolve
-            
+
         Returns:
             Resolved service instance
         """
         if not self._di_container:
             raise RuntimeError("No DI container available")
-            
+
         return self._di_container.resolve(service_type)
-        
+
     def get_optional_dependency(
-        self,
-        service_type: Type[T],
-        default: Optional[T] = None
+        self, service_type: Type[T], default: Optional[T] = None
     ) -> Optional[T]:
         """
         Get an optional dependency from the container.
-        
+
         Args:
             service_type: Type to resolve
             default: Default value if not found
-            
+
         Returns:
             Resolved service or default
         """
         if not self._di_container:
             return default
-            
+
         return self._di_container.resolve_optional(service_type, default)
-        
+
     def has_dependency(self, service_type: Type) -> bool:
         """Check if a dependency is available in the container."""
         if not self._di_container:
             return False
-            
+
         return self._di_container.is_registered(service_type)
-        
-    def with_dependencies(self, **deps) -> 'InjectableService':
+
+    def with_dependencies(self, **deps) -> "InjectableService":
         """
         Create a new instance with specific dependencies.
-        
+
         Useful for testing with mocks.
-        
+
         Args:
             **deps: Dependencies to inject
-            
+
         Returns:
             New service instance with injected dependencies
         """
         # Merge with existing config
-        config = self.config._config if hasattr(self.config, '_config') else {}
-        
+        config = self.config._config if hasattr(self.config, "_config") else {}
+
         # Create new instance with dependencies
         return self.__class__(
             name=self.name,
             config=config,
             enable_enhanced_features=self._enable_enhanced,
             container=self._di_container,
-            **deps
+            **deps,
         )
-        
+
     async def _initialize_dependencies(self) -> None:
         """Initialize injected dependencies that need async setup."""
         # Initialize any dependencies that need async initialization
         for attr_name in dir(self):
-            if attr_name.startswith('_'):
+            if attr_name.startswith("_"):
                 continue
-                
+
             attr = getattr(self, attr_name, None)
-            if attr and hasattr(attr, 'start') and hasattr(attr, 'running'):
-                # It's a service that needs to be started
-                if not attr.running:
-                    try:
-                        await attr.start()
-                        logger.debug(f"Started dependency {attr_name}")
-                    except Exception as e:
-                        logger.warning(f"Failed to start dependency {attr_name}: {e}")
-                        
+            if (
+                attr
+                and hasattr(attr, "start")
+                and hasattr(attr, "running")
+                and not attr.running
+            ):
+                try:
+                    await attr.start()
+                    logger.debug(f"Started dependency {attr_name}")
+                except Exception as e:
+                    logger.warning(f"Failed to start dependency {attr_name}: {e}")
+
     def __repr__(self) -> str:
         """Enhanced string representation showing dependencies."""
         base_repr = super().__repr__()
-        
+
         # Add dependency information
         deps = []
-        annotations = getattr(self.__class__, '__annotations__', {})
-        
-        for attr_name, attr_type in annotations.items():
-            if hasattr(self, attr_name) and not attr_name.startswith('_'):
-                deps.append(f"{attr_name}={getattr(self, attr_name).__class__.__name__}")
-                
+        annotations = getattr(self.__class__, "__annotations__", {})
+
+        for attr_name, _attr_type in annotations.items():
+            if hasattr(self, attr_name) and not attr_name.startswith("_"):
+                deps.append(
+                    f"{attr_name}={getattr(self, attr_name).__class__.__name__}"
+                )
+
         if deps:
             deps_str = ", ".join(deps)
-            return base_repr.replace(')>', f', deps=[{deps_str}])>')
-            
-        return base_repr
+            return base_repr.replace(")>", f", deps=[{deps_str}])>")
+
+        return base_repr

claude_mpm/core/instruction_reinforcement_hook.py

@@ -0,0 +1,267 @@
+"""Instruction Reinforcement Hook for PM instruction drift prevention.
+
+This module implements a hook that intercepts TodoWrite calls and injects
+reminder messages at configurable intervals to combat PM instruction drift
+during long conversations.
+
+WHY this is needed:
+- PM agents can drift from their original instructions during long sessions
+- Direct tool usage (Edit, Write, Bash) is a common drift pattern
+- Reminder injection via TodoWrite is a non-intrusive way to reinforce instructions
+- Configurable intervals and message rotation provide flexibility
+
+The hook works by:
+1. Tracking TodoWrite call count
+2. Injecting reminders at configured intervals (default: every 5 calls)
+3. Rotating through multiple reminder messages
+4. Providing metrics for monitoring effectiveness
+"""
+
+import threading
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from ..core.enums import OperationResult
+from ..core.logger import get_logger
+
+
+class InstructionReinforcementHook:
+    """Hook for injecting instruction reminders into TodoWrite calls.
+
+    This class intercepts TodoWrite operations and periodically injects
+    reminder messages to help prevent PM instruction drift.
+
+    Key features:
+    - Configurable injection intervals
+    - Message rotation for variety
+    - Thread-safe operation
+    - Metrics tracking
+    - Test mode support
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize the instruction reinforcement hook.
+
+        Args:
+            config: Configuration dictionary with optional keys:
+                - enabled: Whether the hook is enabled (default: True)
+                - test_mode: Whether to use test messages (default: True)
+                - injection_interval: Calls between injections (default: 5)
+                - test_messages: List of test messages to rotate through
+        """
+        self.logger = get_logger("instruction_reinforcement_hook")
+
+        # Initialize configuration
+        config = config or {}
+        self.enabled = config.get("enabled", True)
+        self.test_mode = config.get("test_mode", True)
+        self.injection_interval = config.get("injection_interval", 5)
+
+        # Thread-safe counters
+        self._lock = threading.Lock()
+        self.call_count = 0
+        self.injection_count = 0
+        self.message_index = 0
+
+        # Default test messages (will be used in test_mode)
+        self.test_messages = config.get(
+            "test_messages",
+            [
+                "[TEST-REMINDER] This is an injected instruction reminder",
+                "[PM-INSTRUCTION] Remember to delegate all work to agents",
+                "[PM-INSTRUCTION] Do not use Edit, Write, or Bash tools directly",
+                "[PM-INSTRUCTION] Your role is orchestration and coordination",
+            ],
+        )
+
+        # Production messages (used when test_mode=False)
+        self.production_messages = [
+            "[STOP] Are you about to use Edit/Write/Bash? Delegate to Engineer instead!",
+            "[DELEGATE] Your job is coordination, not implementation - pass this to an agent",
+            "[REMINDER] PM = Project Manager, not Project Implementer - delegate this work",
+            "[CHECK] If you're reading code files, stop and delegate to Research Agent",
+            "[WARNING] Direct implementation detected - use 'do this yourself' to override",
+        ]
+
+        self.logger.info(
+            f"InstructionReinforcementHook initialized: "
+            f"enabled={self.enabled}, test_mode={self.test_mode}, "
+            f"interval={self.injection_interval}"
+        )
+
+    def intercept_todowrite(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Intercept TodoWrite parameters and potentially inject reminders.
+
+        Args:
+            params: TodoWrite parameters dictionary containing 'todos' list
+
+        Returns:
+            Modified parameters with potentially injected reminders
+        """
+        if not self.enabled:
+            return params
+
+        try:
+            # Extract todos safely
+            todos = params.get("todos", [])
+            if not isinstance(todos, list):
+                self.logger.warning("Invalid todos format - skipping injection")
+                return params
+
+            with self._lock:
+                self.call_count += 1
+
+                # Check if we should inject
+                if self.should_inject():
+                    modified_todos = self.inject_reminders(todos)
+                    params = params.copy()  # Don't modify original
+                    params["todos"] = modified_todos
+                    self.injection_count += 1
+
+                    self.logger.info(
+                        f"Injected reminder #{self.injection_count} at call #{self.call_count}"
+                    )
+
+            return params
+
+        except Exception as e:
+            self.logger.error(f"Error in TodoWrite interception: {e}")
+            # Return original params on error to avoid breaking functionality
+            return params
+
+    def should_inject(self) -> bool:
+        """Determine if a reminder should be injected.
+
+        Returns:
+            True if injection should occur
+        """
+        if not self.enabled:
+            return False
+
+        return self.call_count % self.injection_interval == 0
+
+    def inject_reminders(self, todos: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Inject reminder message into todos list.
+
+        Args:
+            todos: Original todos list
+
+        Returns:
+            Modified todos list with reminder injected at the beginning
+        """
+        # Choose message set based on mode
+        messages = self.test_messages if self.test_mode else self.production_messages
+
+        # Get next message (rotate through available messages)
+        message = messages[self.message_index % len(messages)]
+        self.message_index += 1
+
+        # Create reminder todo
+        reminder_todo = {
+            "content": message,
+            "status": OperationResult.PENDING,
+            "activeForm": "Processing instruction reminder",
+        }
+
+        # Insert at beginning of todos list
+        modified_todos = todos.copy()
+        modified_todos.insert(0, reminder_todo)
+
+        self.logger.debug(f"Injected reminder: {message}")
+
+        return modified_todos
+
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get current hook metrics.
+
+        Returns:
+            Dictionary containing metrics:
+            - call_count: Total TodoWrite calls processed
+            - injection_count: Total reminders injected
+            - injection_rate: Ratio of injections to calls
+            - next_injection_in: Calls until next injection
+            - enabled: Whether hook is enabled
+            - test_mode: Whether using test messages
+        """
+        with self._lock:
+            next_injection = self.injection_interval - (
+                self.call_count % self.injection_interval
+            )
+            if next_injection == self.injection_interval:
+                next_injection = 0  # Next call will trigger injection
+
+            return {
+                "call_count": self.call_count,
+                "injection_count": self.injection_count,
+                "injection_rate": self.injection_count / max(self.call_count, 1),
+                "next_injection_in": next_injection,
+                "enabled": self.enabled,
+                "test_mode": self.test_mode,
+                "injection_interval": self.injection_interval,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+
+    def reset_counters(self):
+        """Reset all counters to zero.
+
+        Useful for testing or starting fresh tracking.
+        """
+        with self._lock:
+            self.call_count = 0
+            self.injection_count = 0
+            self.message_index = 0
+
+        self.logger.info("Reset instruction reinforcement counters")
+
+    def update_config(self, config: Dict[str, Any]):
+        """Update hook configuration.
+
+        Args:
+            config: New configuration values
+        """
+        if "enabled" in config:
+            self.enabled = config["enabled"]
+        if "test_mode" in config:
+            self.test_mode = config["test_mode"]
+        if "injection_interval" in config:
+            self.injection_interval = max(1, config["injection_interval"])  # Minimum 1
+        if "test_messages" in config:
+            self.test_messages = config["test_messages"]
+
+        self.logger.info(f"Updated configuration: {config}")
+
+
+# Global instance for singleton pattern
+_instruction_reinforcement_hook: Optional[InstructionReinforcementHook] = None
+_hook_lock = threading.Lock()
+
+
+def get_instruction_reinforcement_hook(
+    config: Optional[Dict[str, Any]] = None,
+) -> InstructionReinforcementHook:
+    """Get the global instruction reinforcement hook instance.
+
+    Args:
+        config: Configuration for first-time initialization
+
+    Returns:
+        InstructionReinforcementHook instance
+    """
+    global _instruction_reinforcement_hook
+
+    with _hook_lock:
+        if _instruction_reinforcement_hook is None:
+            _instruction_reinforcement_hook = InstructionReinforcementHook(config)
+
+    return _instruction_reinforcement_hook
+
+
+def reset_instruction_reinforcement_hook():
+    """Reset the global hook instance.
+
+    Primarily used for testing to ensure clean state.
+    """
+    global _instruction_reinforcement_hook
+
+    with _hook_lock:
+        _instruction_reinforcement_hook = None