PyPI - claude-mpm - Versions diffs - 4.24.0__py3-none-any.whl → 5.4.41__py3-none-any.whl - Mend

claude-mpm 4.24.0py3-none-any.whl → 5.4.41py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of claude-mpm might be problematic. Click here for more details.

Files changed (623) hide show

claude_mpm/dashboard/static/svelte-build/index.html ADDED Viewed

@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+		<link rel="modulepreload" href="/_app/immutable/entry/start.DzuEhzqh.js">
+		<link rel="modulepreload" href="/_app/immutable/chunks/CIXEwuWe.js">
+		<link rel="modulepreload" href="/_app/immutable/chunks/DjhvlsAc.js">
+		<link rel="modulepreload" href="/_app/immutable/entry/app.DTL5mJO-.js">
+		<link rel="modulepreload" href="/_app/immutable/chunks/DMkZpdF2.js">
+		<link rel="modulepreload" href="/_app/immutable/chunks/CWc5urbQ.js">
+		<link rel="modulepreload" href="/_app/immutable/chunks/BgChzWQ1.js">
+	</head>
+	<body data-sveltekit-preload-data="hover">
+		<div style="display: contents">
+			<script>
+				{
+					__sveltekit_16ujgvz = {
+						base: ""
+					};
+					const element = document.currentScript.parentElement;
+					Promise.all([
+						import("/_app/immutable/entry/start.DzuEhzqh.js"),
+						import("/_app/immutable/entry/app.DTL5mJO-.js")
+					]).then(([kit, app]) => {
+						kit.start(app, element);
+					});
+				}
+			</script>
+		</div>
+	</body>
+</html>

claude_mpm/experimental/cli_enhancements.py CHANGED Viewed

@@ -31,11 +31,7 @@ import click
 from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.hooks.validation_hooks import ValidationHooks
-from claude_mpm.utils.error_handler import (
-    ErrorContext,
-    MPMError,
-    handle_errors,
-)
+from claude_mpm.utils.error_handler import ErrorContext, MPMError, handle_errors
 from claude_mpm.validation import AgentValidator, ValidationResult
 logger = get_logger(__name__)

claude_mpm/hooks/claude_hooks/__pycache__/__init__.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/__pycache__/correlation_manager.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/__pycache__/event_handlers.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/__pycache__/hook_handler.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/__pycache__/installer.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/__pycache__/memory_integration.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/__pycache__/response_tracking.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/__pycache__/tool_analysis.cpython-311.pyc ADDED Viewed

Binary file

claude_mpm/hooks/claude_hooks/correlation_manager.py ADDED Viewed

@@ -0,0 +1,60 @@
+"""Cross-process correlation storage using .claude-mpm directory."""
+import json
+import time
+from pathlib import Path
+def get_correlation_dir() -> Path:
+    """Get correlation directory in project's .claude-mpm folder."""
+    # Use CWD's .claude-mpm directory (where hooks run from)
+    cwd = Path.cwd()
+    return cwd / ".claude-mpm" / "correlations"
+TTL_SECONDS = 3600  # 1 hour
+class CorrelationManager:
+    """Manages correlation IDs across separate hook processes."""
+    @staticmethod
+    def store(session_id: str, tool_call_id: str, tool_name: str) -> None:
+        """Store correlation data for later retrieval by post_tool."""
+        correlation_dir = get_correlation_dir()
+        correlation_dir.mkdir(parents=True, exist_ok=True)
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        data = {
+            "tool_call_id": tool_call_id,
+            "tool_name": tool_name,
+            "timestamp": time.time(),
+        }
+        filepath.write_text(json.dumps(data))
+    @staticmethod
+    def retrieve(session_id: str) -> str | None:
+        """Retrieve and delete correlation data from temp file."""
+        correlation_dir = get_correlation_dir()
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        if not filepath.exists():
+            return None
+        try:
+            data = json.loads(filepath.read_text())
+            filepath.unlink()  # Delete after reading
+            return data.get("tool_call_id")
+        except (json.JSONDecodeError, OSError):
+            return None
+    @staticmethod
+    def cleanup_old() -> None:
+        """Remove correlation files older than TTL."""
+        correlation_dir = get_correlation_dir()
+        if not correlation_dir.exists():
+            return
+        now = time.time()
+        for filepath in correlation_dir.glob("correlation_*.json"):
+            try:
+                if now - filepath.stat().st_mtime > TTL_SECONDS:
+                    filepath.unlink()
+            except OSError:
+                pass

claude_mpm/hooks/claude_hooks/event_handlers.py CHANGED Viewed

@@ -9,6 +9,7 @@ import os
 import re
 import subprocess
 import sys
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
@@ -94,22 +95,29 @@ class EventHandlers:
         }
         # Store prompt for comprehensive response tracking if enabled
-        if (
-            self.hook_handler.response_tracking_manager.response_tracking_enabled
-            and self.hook_handler.response_tracking_manager.track_all_interactions
-        ):
-            session_id = event.get("session_id", "")
-            if session_id:
-                self.hook_handler.pending_prompts[session_id] = {
-                    "prompt": prompt,
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                    "working_directory": working_dir,
-                }
-                if DEBUG:
-                    print(
-                        f"Stored prompt for comprehensive tracking: session {session_id[:8]}...",
-                        file=sys.stderr,
-                    )
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if (
+                rtm
+                and getattr(rtm, "response_tracking_enabled", False)
+                and getattr(rtm, "track_all_interactions", False)
+            ):
+                session_id = event.get("session_id", "")
+                if session_id:
+                    pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+                    pending_prompts[session_id] = {
+                        "prompt": prompt,
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                        "working_directory": working_dir,
+                    }
+                    if DEBUG:
+                        print(
+                            f"Stored prompt for comprehensive tracking: session {session_id[:8]}...",
+                            file=sys.stderr,
+                        )
+        except Exception:
+            # Response tracking is optional - silently continue if it fails
+            pass
         # Emit normalized event (namespace no longer needed with normalized events)
         self.hook_handler._emit_socketio_event("", "user_prompt", prompt_data)
@@ -134,6 +142,9 @@ class EventHandlers:
         tool_name = event.get("tool_name", "")
         tool_input = event.get("tool_input", {})
+        # Generate unique tool call ID for correlation with post_tool event
+        tool_call_id = str(uuid.uuid4())
         # Extract key parameters based on tool type
         tool_params = extract_tool_parameters(tool_name, tool_input)
@@ -144,6 +155,8 @@ class EventHandlers:
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
+        timestamp = datetime.now(timezone.utc).isoformat()
         pre_tool_data = {
             "tool_name": tool_name,
             "operation_type": operation_type,
@@ -151,15 +164,27 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "timestamp": timestamp,
             "parameter_count": len(tool_input) if isinstance(tool_input, dict) else 0,
             "is_file_operation": tool_name
             in ["Write", "Edit", "MultiEdit", "Read", "LS", "Glob"],
             "is_execution": tool_name in ["Bash", "NotebookEdit"],
             "is_delegation": tool_name == "Task",
             "security_risk": assess_security_risk(tool_name, tool_input),
+            "correlation_id": tool_call_id,  # Add correlation_id for pre/post correlation
         }
+        # Store tool_call_id using CorrelationManager for cross-process retrieval
+        if session_id:
+            from .correlation_manager import CorrelationManager
+            CorrelationManager.store(session_id, tool_call_id, tool_name)
+            if DEBUG:
+                print(
+                    f"  - Generated tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
+                    file=sys.stderr,
+                )
         # Add delegation-specific data if this is a Task tool
         if tool_name == "Task" and isinstance(tool_input, dict):
             self._handle_task_delegation(tool_input, pre_tool_data, session_id)
@@ -226,8 +251,11 @@ class EventHandlers:
                     f"  - Request data keys: {list(request_data.keys())}",
                     file=sys.stderr,
                 )
+                delegation_requests = getattr(
+                    self.hook_handler, "delegation_requests", {}
+                )
                 print(
-                    f"  - delegation_requests size: {len(self.hook_handler.delegation_requests)}",
+                    f"  - delegation_requests size: {len(delegation_requests)}",
                     file=sys.stderr,
                 )
@@ -239,9 +267,13 @@ class EventHandlers:
                 )
         # Trigger memory pre-delegation hook
-        self.hook_handler.memory_hook_manager.trigger_pre_delegation_hook(
-            agent_type, tool_input, session_id
-        )
+        try:
+            mhm = getattr(self.hook_handler, "memory_hook_manager", None)
+            if mhm and hasattr(mhm, "trigger_pre_delegation_hook"):
+                mhm.trigger_pre_delegation_hook(agent_type, tool_input, session_id)
+        except Exception:
+            # Memory hooks are optional
+            pass
         # Emit a subagent_start event for better tracking
         subagent_start_data = {
@@ -375,6 +407,7 @@ class EventHandlers:
         """
         tool_name = event.get("tool_name", "")
         exit_code = event.get("exit_code", 0)
+        session_id = event.get("session_id", "")
         # Extract result data
         result_data = extract_tool_results(event)
@@ -386,6 +419,16 @@ class EventHandlers:
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
+        # Retrieve tool_call_id using CorrelationManager for cross-process correlation
+        from .correlation_manager import CorrelationManager
+        tool_call_id = CorrelationManager.retrieve(session_id) if session_id else None
+        if DEBUG and tool_call_id:
+            print(
+                f"  - Retrieved tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
+                file=sys.stderr,
+            )
         post_tool_data = {
             "tool_name": tool_name,
             "exit_code": exit_code,
@@ -393,11 +436,13 @@ class EventHandlers:
             "status": (
                 "success"
                 if exit_code == 0
-                else "blocked" if exit_code == 2 else "error"
+                else "blocked"
+                if exit_code == 2
+                else "error"
             ),
             "duration_ms": duration,
             "result_summary": result_data,
-            "session_id": event.get("session_id", ""),
+            "session_id": session_id,
             "working_directory": working_dir,
             "git_branch": git_branch,
             "timestamp": datetime.now(timezone.utc).isoformat(),
@@ -410,20 +455,42 @@ class EventHandlers:
             ),
         }
+        # Include full output for file operations (Read, Edit, Write)
+        # so frontend can display file content
+        if tool_name in ("Read", "Edit", "Write", "Grep", "Glob") and "output" in event:
+            post_tool_data["output"] = event["output"]
+        # Add correlation_id if available for correlation with pre_tool
+        if tool_call_id:
+            post_tool_data["correlation_id"] = tool_call_id
         # Handle Task delegation completion for memory hooks and response tracking
         if tool_name == "Task":
             session_id = event.get("session_id", "")
             agent_type = self.hook_handler._get_delegation_agent_type(session_id)
             # Trigger memory post-delegation hook
-            self.hook_handler.memory_hook_manager.trigger_post_delegation_hook(
-                agent_type, event, session_id
-            )
+            try:
+                mhm = getattr(self.hook_handler, "memory_hook_manager", None)
+                if mhm and hasattr(mhm, "trigger_post_delegation_hook"):
+                    mhm.trigger_post_delegation_hook(agent_type, event, session_id)
+            except Exception:
+                # Memory hooks are optional
+                pass
             # Track agent response if response tracking is enabled
-            self.hook_handler.response_tracking_manager.track_agent_response(
-                session_id, agent_type, event, self.hook_handler.delegation_requests
-            )
+            try:
+                rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+                if rtm and hasattr(rtm, "track_agent_response"):
+                    delegation_requests = getattr(
+                        self.hook_handler, "delegation_requests", {}
+                    )
+                    rtm.track_agent_response(
+                        session_id, agent_type, event, delegation_requests
+                    )
+            except Exception:
+                # Response tracking is optional
+                pass
         self.hook_handler._emit_socketio_event("", "post_tool", post_tool_data)
@@ -484,9 +551,14 @@ class EventHandlers:
             self._log_stop_event_debug(event, session_id, metadata)
         # Track response if enabled
-        self.hook_handler.response_tracking_manager.track_stop_response(
-            event, session_id, metadata, self.hook_handler.pending_prompts
-        )
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if rtm and hasattr(rtm, "track_stop_response"):
+                pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+                rtm.track_stop_response(event, session_id, metadata, pending_prompts)
+        except Exception:
+            # Response tracking is optional
+            pass
         # Emit stop event to Socket.IO
         self._emit_stop_event(event, session_id, metadata)
@@ -509,15 +581,27 @@ class EventHandlers:
         self, event: dict, session_id: str, metadata: dict
     ) -> None:
         """Log debug information for stop events."""
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            tracking_enabled = (
+                getattr(rtm, "response_tracking_enabled", False) if rtm else False
+            )
+            tracker_exists = (
+                getattr(rtm, "response_tracker", None) is not None if rtm else False
+            )
+            print(
+                f"  - response_tracking_enabled: {tracking_enabled}",
+                file=sys.stderr,
+            )
+            print(
+                f"  - response_tracker exists: {tracker_exists}",
+                file=sys.stderr,
+            )
+        except Exception:
+            # If debug logging fails, just skip it
+            pass
-        print(
-            f"  - response_tracking_enabled: {self.hook_handler.response_tracking_manager.response_tracking_enabled}",
-            file=sys.stderr,
-        )
-        print(
-            f"  - response_tracker exists: {self.hook_handler.response_tracking_manager.response_tracker is not None}",
-            file=sys.stderr,
-        )
         print(
             f"  - session_id: {session_id[:8] if session_id else 'None'}...",
             file=sys.stderr,
@@ -565,15 +649,22 @@ class EventHandlers:
         git_branch: str,
     ):
         """Handle response tracking for subagent stop events with fuzzy matching."""
-        if not (
-            self.hook_handler.response_tracking_manager.response_tracking_enabled
-            and self.hook_handler.response_tracking_manager.response_tracker
-        ):
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if not (
+                rtm
+                and getattr(rtm, "response_tracking_enabled", False)
+                and getattr(rtm, "response_tracker", None)
+            ):
+                return
+        except Exception:
+            # Response tracking is optional
             return
         try:
             # Get the original request data (with fuzzy matching fallback)
-            request_info = self.hook_handler.delegation_requests.get(session_id)
+            delegation_requests = getattr(self.hook_handler, "delegation_requests", {})
+            request_info = delegation_requests.get(session_id)
             # If exact match fails, try partial matching
             if not request_info and session_id:
@@ -583,7 +674,7 @@ class EventHandlers:
                         file=sys.stderr,
                     )
                 # Try to find a session that matches the first 8-16 characters
-                for stored_sid in list(self.hook_handler.delegation_requests.keys()):
+                for stored_sid in list(delegation_requests.keys()):
                     if (
                         stored_sid.startswith(session_id[:8])
                         or session_id.startswith(stored_sid[:8])
@@ -598,17 +689,13 @@ class EventHandlers:
                                 f"  - ✅ Fuzzy match found: {stored_sid[:16]}...",
                                 file=sys.stderr,
                             )
-                        request_info = self.hook_handler.delegation_requests.get(
-                            stored_sid
-                        )
+                        request_info = delegation_requests.get(stored_sid)
                         # Update the key to use the current session_id for consistency
                         if request_info:
-                            self.hook_handler.delegation_requests[session_id] = (
-                                request_info
-                            )
+                            delegation_requests[session_id] = request_info
                             # Optionally remove the old key to avoid duplicates
                             if stored_sid != session_id:
-                                del self.hook_handler.delegation_requests[stored_sid]
+                                del delegation_requests[stored_sid]
                         break
             if request_info:
@@ -656,23 +743,31 @@ class EventHandlers:
                     )
                 # Track the response
-                file_path = self.hook_handler.response_tracking_manager.response_tracker.track_response(
-                    agent_name=agent_type,
-                    request=full_request,
-                    response=response_text,
-                    session_id=session_id,
-                    metadata=metadata,
+                rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+                response_tracker = (
+                    getattr(rtm, "response_tracker", None) if rtm else None
                 )
-                if file_path and DEBUG:
-                    print(
-                        f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
-                        file=sys.stderr,
+                if response_tracker and hasattr(response_tracker, "track_response"):
+                    file_path = response_tracker.track_response(
+                        agent_name=agent_type,
+                        request=full_request,
+                        response=response_text,
+                        session_id=session_id,
+                        metadata=metadata,
                     )
+                    if file_path and DEBUG:
+                        print(
+                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
+                            file=sys.stderr,
+                        )
                 # Clean up the request data
-                if session_id in self.hook_handler.delegation_requests:
-                    del self.hook_handler.delegation_requests[session_id]
+                delegation_requests = getattr(
+                    self.hook_handler, "delegation_requests", {}
+                )
+                if session_id in delegation_requests:
+                    del delegation_requests[session_id]
             elif DEBUG:
                 print(
@@ -696,9 +791,14 @@ class EventHandlers:
         - Essential for comprehensive monitoring of Claude interactions
         """
         # Track the response for logging
-        self.hook_handler.response_tracking_manager.track_assistant_response(
-            event, self.hook_handler.pending_prompts
-        )
+        try:
+            rtm = getattr(self.hook_handler, "response_tracking_manager", None)
+            if rtm and hasattr(rtm, "track_assistant_response"):
+                pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+                rtm.track_assistant_response(event, pending_prompts)
+        except Exception:
+            # Response tracking is optional
+            pass
         # Get working directory and git branch
         working_dir = event.get("cwd", "")
@@ -728,16 +828,21 @@ class EventHandlers:
         }
         # Check if this is a response to a tracked prompt
-        if session_id in self.hook_handler.pending_prompts:
-            prompt_data = self.hook_handler.pending_prompts[session_id]
-            assistant_response_data["original_prompt"] = prompt_data.get("prompt", "")[
-                :200
-            ]
-            assistant_response_data["prompt_timestamp"] = prompt_data.get(
-                "timestamp", ""
-            )
-            assistant_response_data["is_tracked_response"] = True
-        else:
+        try:
+            pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
+            if session_id in pending_prompts:
+                prompt_data = pending_prompts[session_id]
+                assistant_response_data["original_prompt"] = prompt_data.get(
+                    "prompt", ""
+                )[:200]
+                assistant_response_data["prompt_timestamp"] = prompt_data.get(
+                    "timestamp", ""
+                )
+                assistant_response_data["is_tracked_response"] = True
+            else:
+                assistant_response_data["is_tracked_response"] = False
+        except Exception:
+            # If prompt lookup fails, just mark as not tracked
             assistant_response_data["is_tracked_response"] = False
         # Debug logging
@@ -751,3 +856,33 @@ class EventHandlers:
         self.hook_handler._emit_socketio_event(
             "", "assistant_response", assistant_response_data
         )
+    def handle_session_start_fast(self, event):
+        """Handle session start events for tracking conversation sessions.
+        WHY track session starts:
+        - Provides visibility into new conversation sessions
+        - Enables tracking of session lifecycle and duration
+        - Useful for monitoring concurrent sessions and resource usage
+        """
+        session_id = event.get("session_id", "")
+        working_dir = event.get("cwd", "")
+        git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
+        session_start_data = {
+            "session_id": session_id,
+            "working_directory": working_dir,
+            "git_branch": git_branch,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "hook_event_name": "SessionStart",
+        }
+        # Debug logging
+        if DEBUG:
+            print(
+                f"Hook handler: Processing SessionStart - session: '{session_id}'",
+                file=sys.stderr,
+            )
+        # Emit normalized event
+        self.hook_handler._emit_socketio_event("", "session_start", session_start_data)

claude-mpm 4.24.0__py3-none-any.whl → 5.4.41__py3-none-any.whl

Potentially problematic release.

claude-mpm 4.24.0py3-none-any.whl → 5.4.41py3-none-any.whl