claude-mpm 4.1.26__py3-none-any.whl → 5.0.9__py3-none-any.whl

claude_mpm/hooks/claude_hooks/services/state_manager.py

@@ -11,7 +11,8 @@ import os
 import subprocess
 import time
 from collections import deque
-from datetime import datetime
+from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional
 
 # Import constants for configuration
@@ -77,7 +78,7 @@ class StateManagerService:
 
         if session_id and agent_type and agent_type != "unknown":
             self.active_delegations[session_id] = agent_type
-            key = f"{session_id}:{datetime.now().timestamp()}"
+            key = f"{session_id}:{datetime.now(timezone.utc).timestamp()}"
             self.delegation_history.append((key, agent_type))
 
             # Store request data for response tracking correlation
@@ -85,7 +86,7 @@ class StateManagerService:
                 self.delegation_requests[session_id] = {
                     "agent_type": agent_type,
                     "request": request_data,
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                 }
                 if DEBUG:
                     import sys
@@ -100,7 +101,7 @@ class StateManagerService:
                     )
 
             # Clean up old delegations (older than 5 minutes)
-            cutoff_time = datetime.now().timestamp() - 300
+            cutoff_time = datetime.now(timezone.utc).timestamp() - 300
             keys_to_remove = []
             for sid in list(self.active_delegations.keys()):
                 # Check if this is an old entry by looking in history
@@ -136,7 +137,7 @@ class StateManagerService:
 
     def cleanup_old_entries(self):
         """Clean up old entries to prevent memory growth."""
-        datetime.now().timestamp() - self.MAX_CACHE_AGE_SECONDS
+        datetime.now(timezone.utc).timestamp() - self.MAX_CACHE_AGE_SECONDS
 
         # Clean up delegation tracking dictionaries
         for storage in [self.active_delegations, self.delegation_requests]:
@@ -158,7 +159,8 @@ class StateManagerService:
         expired_keys = [
             key
             for key, cache_time in self._git_branch_cache_time.items()
-            if datetime.now().timestamp() - cache_time > self.MAX_CACHE_AGE_SECONDS
+            if datetime.now(timezone.utc).timestamp() - cache_time
+            > self.MAX_CACHE_AGE_SECONDS
         ]
         for key in expired_keys:
             self._git_branch_cache.pop(key, None)
@@ -175,10 +177,10 @@ class StateManagerService:
         """
         # Use current working directory if not specified
         if not working_dir:
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
 
         # Check cache first (cache for 30 seconds)
-        current_time = datetime.now().timestamp()
+        current_time = datetime.now(timezone.utc).timestamp()
         cache_key = working_dir
 
         if (
@@ -191,7 +193,7 @@ class StateManagerService:
         # Try to get git branch
         try:
             # Change to the working directory temporarily
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             os.chdir(working_dir)
 
             # Run git command to get current branch

claude_mpm/hooks/claude_hooks/services/subagent_processor.py

@@ -11,7 +11,7 @@ import json
 import os
 import re
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional, Tuple
 
 # Debug mode is enabled by default for better visibility into hook processing
@@ -272,7 +272,7 @@ class SubagentResponseProcessor:
                         "duration_ms": event.get("duration_ms"),
                         "working_directory": working_dir,
                         "git_branch": git_branch,
-                        "timestamp": datetime.now().isoformat(),
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
                         "event_type": "subagent_stop",
                         "reason": reason,
                         "original_request_timestamp": request_info.get("timestamp"),
@@ -347,7 +347,7 @@ class SubagentResponseProcessor:
             "session_id": session_id,
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "is_successful_completion": reason in ["completed", "finished", "done"],
             "is_error_termination": reason in ["error", "timeout", "failed", "blocked"],
             "is_delegation_related": agent_type

claude_mpm/hooks/failure_learning/__init__.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+Failure-Learning Hook System
+=============================
+
+Automatic learning extraction from failure-fix cycles.
+
+WHY: When tasks fail and agents fix them, valuable knowledge is created. This
+hook system automatically captures failures, detects fixes, and extracts learnings
+without requiring manual intervention.
+
+Components:
+- FailureDetectionHook (priority 85): Detects task failures from tool outputs
+- FixDetectionHook (priority 87): Matches successful executions with failures
+- LearningExtractionHook (priority 89): Synthesizes and persists learnings
+
+Integration:
+The hooks work together as a chain:
+1. Tool executes and fails → FailureDetectionHook records failure
+2. User or agent makes changes
+3. Tool executes and succeeds → FixDetectionHook detects fix
+4. Fix matched with failure → LearningExtractionHook creates learning
+5. Learning written to agent memory file
+
+Usage:
+    from claude_mpm.hooks.failure_learning import (
+        get_failure_detection_hook,
+        get_fix_detection_hook,
+        get_learning_extraction_hook,
+    )
+
+    # Register hooks with hook service
+    hook_service.register_hook(get_failure_detection_hook())
+    hook_service.register_hook(get_fix_detection_hook())
+    hook_service.register_hook(get_learning_extraction_hook())
+"""
+
+from .failure_detection_hook import FailureDetectionHook, get_failure_detection_hook
+from .fix_detection_hook import FixDetectionHook, get_fix_detection_hook
+from .learning_extraction_hook import (
+    LearningExtractionHook,
+    get_learning_extraction_hook,
+)
+
+__all__ = [
+    # Hooks
+    "FailureDetectionHook",
+    "FixDetectionHook",
+    "LearningExtractionHook",
+    # Factory functions
+    "get_failure_detection_hook",
+    "get_fix_detection_hook",
+    "get_learning_extraction_hook",
+]

claude_mpm/hooks/failure_learning/failure_detection_hook.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Failure Detection Hook
+======================
+
+Detects task failures from tool outputs and registers them with the FailureTracker.
+
+WHY: Failures are the first step in the failure-learning cycle. By detecting
+failures early, we can match them with fixes later and extract valuable learnings.
+
+DESIGN DECISION: This hook runs after tool execution (priority=85) to inspect
+tool outputs for failure patterns. It integrates with the PostDelegationHook
+lifecycle to access tool execution results.
+
+Integration points:
+- Monitors post_tool events for Bash, NotebookEdit, and other execution tools
+- Extracts error messages, exceptions, and test failures
+- Registers failures with FailureTracker for fix matching
+"""
+
+import logging
+from typing import Any, Dict
+
+from claude_mpm.hooks.base_hook import BaseHook, HookContext, HookResult, HookType
+from claude_mpm.services.memory.failure_tracker import get_failure_tracker
+
+logger = logging.getLogger(__name__)
+
+
+class FailureDetectionHook(BaseHook):
+    """Hook that detects and tracks task failures.
+
+    WHY: Automatically captures failures without requiring manual tracking.
+    Runs after tool execution to inspect outputs and detect error patterns.
+
+    DESIGN DECISION: Priority 85 ensures this runs after tool execution but
+    before fix detection and learning extraction. This ordering is critical
+    for the failure-learning cycle.
+    """
+
+    # Tools to monitor for failures
+    MONITORED_TOOLS = [
+        "Bash",  # Command execution
+        "NotebookEdit",  # Jupyter notebook execution
+        "Task",  # Subagent delegation
+    ]
+
+    def __init__(self):
+        """Initialize the failure detection hook."""
+        super().__init__(
+            name="failure_detection",
+            priority=85,  # After tool execution, before fix detection
+        )
+        self.tracker = get_failure_tracker()
+
+    def execute(self, context: HookContext) -> HookResult:
+        """Execute failure detection on tool output.
+
+        WHY: Inspects tool execution results to identify failures. When a failure
+        is detected, it's registered with the FailureTracker for later matching
+        with fixes.
+
+        Args:
+            context: Hook context containing tool execution data
+
+        Returns:
+            HookResult with detection results
+        """
+        try:
+            # Extract tool execution data
+            tool_name = context.data.get("tool_name")
+            tool_output = self._extract_tool_output(context.data)
+            exit_code = context.data.get("exit_code", 0)
+
+            # Only process monitored tools
+            if tool_name not in self.MONITORED_TOOLS:
+                return HookResult(success=True, modified=False)
+
+            # Skip if tool succeeded
+            if exit_code == 0 and not self._contains_failure_indicators(tool_output):
+                return HookResult(success=True, modified=False)
+
+            # Detect failure
+            failure_context = self._build_failure_context(context)
+            failure = self.tracker.detect_failure(
+                tool_name=tool_name, tool_output=tool_output, context=failure_context
+            )
+
+            if failure:
+                logger.info(
+                    f"Failure detected: {failure.task_type} - "
+                    f"{failure.error_message[:50]}..."
+                )
+                return HookResult(
+                    success=True,
+                    modified=False,
+                    metadata={"failure_detected": True, "failure_id": failure.task_id},
+                )
+
+            return HookResult(success=True, modified=False)
+
+        except Exception as e:
+            logger.error(f"Error in failure detection hook: {e}", exc_info=True)
+            return HookResult(success=False, error=str(e), modified=False)
+
+    def validate(self, context: HookContext) -> bool:
+        """Validate if this hook should run for the given context.
+
+        Args:
+            context: Hook context to validate
+
+        Returns:
+            True if hook should execute
+        """
+        if not super().validate(context):
+            return False
+
+        # Run for POST_DELEGATION events (after tool execution)
+        if context.hook_type != HookType.POST_DELEGATION:
+            return False
+
+        # Must have tool execution data
+        return "tool_name" in context.data
+
+    def _extract_tool_output(self, data: Dict[str, Any]) -> str:
+        """Extract tool output from event data.
+
+        Args:
+            data: Event data dictionary
+
+        Returns:
+            Tool output string
+        """
+        # Try various output fields
+        output = (
+            data.get("output")
+            or data.get("result")
+            or data.get("error_output")
+            or data.get("stderr")
+            or ""
+        )
+
+        # Handle nested result structures
+        if isinstance(output, dict):
+            output = (
+                output.get("output")
+                or output.get("content")
+                or output.get("error")
+                or str(output)
+            )
+
+        return str(output) if output else ""
+
+    def _contains_failure_indicators(self, output: str) -> bool:
+        """Check if output contains failure indicators even if exit_code is 0.
+
+        WHY: Some tools return 0 exit code but still report failures in output
+        (e.g., test runners that catch exceptions).
+
+        Args:
+            output: Tool output
+
+        Returns:
+            True if failure indicators found
+        """
+        if not output:
+            return False
+
+        failure_keywords = [
+            "error:",
+            "exception:",
+            "failed",
+            "failure",
+            "traceback",
+            "✗",
+            "❌",
+        ]
+
+        output_lower = output.lower()
+        return any(keyword in output_lower for keyword in failure_keywords)
+
+    def _build_failure_context(self, context: HookContext) -> Dict[str, str]:
+        """Build context dictionary for failure event.
+
+        Args:
+            context: Hook context
+
+        Returns:
+            Context dictionary with agent, session, and other info
+        """
+        failure_context = {}
+
+        # Extract relevant context fields
+        if context.session_id:
+            failure_context["session_id"] = context.session_id
+
+        # Extract agent info from data or metadata
+        agent_type = (
+            context.data.get("agent_type")
+            or context.data.get("subagent_type")
+            or context.metadata.get("agent_type")
+        )
+        if agent_type:
+            failure_context["agent_type"] = agent_type
+
+        # Extract command/script info for Bash tool
+        if context.data.get("tool_name") == "Bash":
+            command = context.data.get("command") or context.data.get(
+                "tool_input", {}
+            ).get("command")
+            if command:
+                failure_context["command"] = command
+
+        # Extract working directory
+        working_dir = context.data.get("working_directory") or context.data.get("cwd")
+        if working_dir:
+            failure_context["working_dir"] = working_dir
+
+        return failure_context
+
+
+def get_failure_detection_hook() -> FailureDetectionHook:
+    """Factory function to create failure detection hook.
+
+    WHY: Provides consistent hook creation pattern used throughout the framework.
+
+    Returns:
+        Configured FailureDetectionHook instance
+    """
+    return FailureDetectionHook()

claude_mpm/hooks/failure_learning/fix_detection_hook.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+Fix Detection Hook
+==================
+
+Detects when previously failed tasks succeed, indicating a fix has been applied.
+
+WHY: Detecting fixes is the second step in the failure-learning cycle. When a
+task that previously failed now succeeds, we know a fix was applied. Matching
+fixes with failures creates the foundation for learning extraction.
+
+DESIGN DECISION: This hook runs after failure detection (priority=87) to check
+if successful tool executions resolve previous failures. Uses the FailureTracker
+to match fixes with failures.
+
+Integration points:
+- Monitors successful tool executions (exit_code=0)
+- Matches with previously detected failures by task type
+- Marks failures as fixed in FailureTracker
+- Triggers learning extraction for failure-fix pairs
+"""
+
+import logging
+from typing import Any, Dict
+
+from claude_mpm.hooks.base_hook import BaseHook, HookContext, HookResult, HookType
+from claude_mpm.services.memory.failure_tracker import get_failure_tracker
+
+logger = logging.getLogger(__name__)
+
+
+class FixDetectionHook(BaseHook):
+    """Hook that detects when failures are fixed.
+
+    WHY: Automatically matches successful executions with previous failures.
+    This enables automatic learning extraction without manual intervention.
+
+    DESIGN DECISION: Priority 87 ensures this runs after failure detection
+    but before learning extraction. The sequencing is critical:
+    1. Failure detection (85)
+    2. Fix detection (87)
+    3. Learning extraction (89)
+    """
+
+    # Tools to monitor for fixes
+    MONITORED_TOOLS = [
+        "Bash",  # Command execution
+        "NotebookEdit",  # Jupyter notebook execution
+        "Task",  # Subagent delegation
+    ]
+
+    def __init__(self):
+        """Initialize the fix detection hook."""
+        super().__init__(
+            name="fix_detection",
+            priority=87,  # After failure detection, before learning extraction
+        )
+        self.tracker = get_failure_tracker()
+
+    def execute(self, context: HookContext) -> HookResult:
+        """Execute fix detection on successful tool execution.
+
+        WHY: When a tool succeeds, check if it fixes a previous failure.
+        This creates failure-fix pairs that can be used for learning extraction.
+
+        Args:
+            context: Hook context containing tool execution data
+
+        Returns:
+            HookResult with detection results
+        """
+        try:
+            # Extract tool execution data
+            tool_name = context.data.get("tool_name")
+            exit_code = context.data.get("exit_code", 0)
+
+            # Only process monitored tools
+            if tool_name not in self.MONITORED_TOOLS:
+                return HookResult(success=True, modified=False)
+
+            # Only process successful executions
+            if exit_code != 0:
+                return HookResult(success=True, modified=False)
+
+            # Check if there are any unfixed failures to potentially match
+            unfixed_failures = self.tracker.get_unfixed_failures()
+            if not unfixed_failures:
+                # No failures to fix, skip
+                return HookResult(success=True, modified=False)
+
+            # Attempt to detect a fix
+            tool_output = self._extract_tool_output(context.data)
+            fix_context = self._build_fix_context(context)
+
+            fix_result = self.tracker.detect_fix(
+                tool_name=tool_name,
+                tool_output=tool_output,
+                exit_code=exit_code,
+                context=fix_context,
+            )
+
+            if fix_result:
+                fix_event, failure_event = fix_result
+                logger.info(
+                    f"Fix detected: {failure_event.task_type} - "
+                    f"resolved failure {failure_event.task_id}"
+                )
+
+                # Store fix info in metadata for learning extraction hook
+                return HookResult(
+                    success=True,
+                    modified=False,
+                    metadata={
+                        "fix_detected": True,
+                        "failure_id": failure_event.task_id,
+                        "fix_event": fix_event,
+                        "failure_event": failure_event,
+                    },
+                )
+
+            return HookResult(success=True, modified=False)
+
+        except Exception as e:
+            logger.error(f"Error in fix detection hook: {e}", exc_info=True)
+            return HookResult(success=False, error=str(e), modified=False)
+
+    def validate(self, context: HookContext) -> bool:
+        """Validate if this hook should run for the given context.
+
+        Args:
+            context: Hook context to validate
+
+        Returns:
+            True if hook should execute
+        """
+        if not super().validate(context):
+            return False
+
+        # Run for POST_DELEGATION events (after tool execution)
+        if context.hook_type != HookType.POST_DELEGATION:
+            return False
+
+        # Must have tool execution data
+        return "tool_name" in context.data
+
+    def _extract_tool_output(self, data: Dict[str, Any]) -> str:
+        """Extract tool output from event data.
+
+        Args:
+            data: Event data dictionary
+
+        Returns:
+            Tool output string
+        """
+        # Try various output fields
+        output = data.get("output") or data.get("result") or data.get("stdout") or ""
+
+        # Handle nested result structures
+        if isinstance(output, dict):
+            output = output.get("output") or output.get("content") or str(output)
+
+        return str(output) if output else ""
+
+    def _build_fix_context(self, context: HookContext) -> Dict[str, str]:
+        """Build context dictionary for fix event.
+
+        Args:
+            context: Hook context
+
+        Returns:
+            Context dictionary with agent, session, and other info
+        """
+        fix_context = {}
+
+        # Extract relevant context fields
+        if context.session_id:
+            fix_context["session_id"] = context.session_id
+
+        # Extract agent info
+        agent_type = (
+            context.data.get("agent_type")
+            or context.data.get("subagent_type")
+            or context.metadata.get("agent_type")
+        )
+        if agent_type:
+            fix_context["agent_type"] = agent_type
+
+        # Extract command/script info for Bash tool
+        if context.data.get("tool_name") == "Bash":
+            command = context.data.get("command") or context.data.get(
+                "tool_input", {}
+            ).get("command")
+            if command:
+                fix_context["command"] = command
+
+        # Extract working directory
+        working_dir = context.data.get("working_directory") or context.data.get("cwd")
+        if working_dir:
+            fix_context["working_dir"] = working_dir
+
+        return fix_context
+
+
+def get_fix_detection_hook() -> FixDetectionHook:
+    """Factory function to create fix detection hook.
+
+    WHY: Provides consistent hook creation pattern used throughout the framework.
+
+    Returns:
+        Configured FixDetectionHook instance
+    """
+    return FixDetectionHook()