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

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -7,14 +7,27 @@ This service manages:
 DESIGN DECISION: Use stateless HTTP POST instead of persistent SocketIO
 connections because hook handlers are ephemeral processes (< 1 second lifetime).
 This eliminates disconnection issues and matches the process lifecycle.
+
+DESIGN DECISION: Synchronous HTTP POST only (no async)
+Hook handlers are too short-lived (~25ms lifecycle) to benefit from async.
+Using asyncio.run() creates event loops that close before HTTP operations complete,
+causing "Event loop is closed" errors. Synchronous HTTP POST in a thread pool
+is simpler and more reliable for ephemeral processes.
 """
 
-import asyncio
 import os
-import sys
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
 # Debug mode is enabled by default for better visibility into hook processing
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
@@ -27,9 +40,6 @@ except ImportError:
     REQUESTS_AVAILABLE = False
     requests = None
 
-# Import high-performance event emitter - lazy loaded in _async_emit()
-# to reduce hook handler initialization time by ~85% (792ms -> minimal)
-
 # Import EventNormalizer for consistent event formatting
 try:
     from claude_mpm.services.socketio.event_normalizer import EventNormalizer
@@ -55,10 +65,6 @@ except ImportError:
             )
 
 
-# EventBus removed - using direct HTTP POST only
-# This eliminates duplicate events and simplifies the architecture
-
-
 class ConnectionManagerService:
     """Manages connections for the Claude hook handler using HTTP POST."""
 
@@ -72,35 +78,26 @@ class ConnectionManagerService:
         self.server_port = int(os.environ.get("CLAUDE_MPM_SERVER_PORT", "8765"))
         self.http_endpoint = f"http://{self.server_host}:{self.server_port}/api/events"
 
-        # EventBus removed - using direct HTTP POST only
-
-        # For backward compatibility with tests
-        self.connection_pool = None  # No longer used
-
-        # Track async emit tasks to prevent garbage collection
-        self._emit_tasks: set = set()
-
         # Thread pool for non-blocking HTTP requests
         # WHY: Prevents HTTP POST from blocking hook processing (2s timeout → 0ms blocking)
-        # max_workers=2: Sufficient for low-frequency HTTP fallback events
+        # max_workers=2: Sufficient for low-frequency hook events
         self._http_executor = ThreadPoolExecutor(
             max_workers=2, thread_name_prefix="http-emit"
         )
 
         if DEBUG:
-            print(
-                f"✅ HTTP connection manager initialized - endpoint: {self.http_endpoint}",
-                file=sys.stderr,
+            _log(
+                f"✅ HTTP connection manager initialized - endpoint: {self.http_endpoint}"
             )
 
     def emit_event(self, namespace: str, event: str, data: dict):
-        """Emit event using high-performance async emitter with HTTP fallback.
+        """Emit event using HTTP POST.
 
-        WHY Hybrid approach:
-        - Direct async calls for ultra-low latency in-process events
-        - HTTP POST fallback for cross-process communication
-        - Connection pooling for memory protection
-        - Automatic routing based on availability
+        WHY HTTP POST only:
+        - Hook handlers are ephemeral (~25ms lifecycle)
+        - Async emission causes "Event loop is closed" errors
+        - HTTP POST in thread pool is simpler and more reliable
+        - Completes in 20-50ms, which is acceptable for hook handlers
         """
         # Create event data for normalization
         raw_event = {
@@ -120,74 +117,17 @@ class ConnectionManagerService:
         if DEBUG and event in ["subagent_stop", "pre_tool"]:
             if event == "subagent_stop":
                 agent_type = data.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing SubagentStop for agent '{agent_type}'",
-                    file=sys.stderr,
-                )
+                _log(f"Hook handler: Publishing SubagentStop for agent '{agent_type}'")
             elif event == "pre_tool" and data.get("tool_name") == "Task":
                 delegation = data.get("delegation_details", {})
                 agent_type = delegation.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'",
-                    file=sys.stderr,
+                _log(
+                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'"
                 )
 
-        # Try high-performance async emitter first (direct calls)
-        success = self._try_async_emit(namespace, event, claude_event_data)
-        if success:
-            return
-
-        # Fallback to HTTP POST for cross-process communication
+        # Emit via HTTP POST (non-blocking, runs in thread pool)
         self._try_http_emit(namespace, event, claude_event_data)
 
-    def _try_async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Try to emit event using high-performance async emitter."""
-        try:
-            # Run async emission in the current event loop or create one
-            loop = None
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                # No running loop, create a new one
-                pass
-
-            if loop:
-                # We're in an async context, create a task with tracking
-                task = loop.create_task(self._async_emit(namespace, event, data))
-                self._emit_tasks.add(task)
-                task.add_done_callback(self._emit_tasks.discard)
-                # Don't wait for completion to maintain low latency
-                if DEBUG:
-                    print(f"✅ Async emit scheduled: {event}", file=sys.stderr)
-                return True
-            # No event loop, run synchronously
-            success = asyncio.run(self._async_emit(namespace, event, data))
-            if DEBUG and success:
-                print(f"✅ Async emit successful: {event}", file=sys.stderr)
-            return success
-
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emit failed: {e}", file=sys.stderr)
-            return False
-
-    async def _async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Async helper for event emission."""
-        try:
-            # Lazy load event emitter to reduce initialization overhead
-            from claude_mpm.services.monitor.event_emitter import get_event_emitter
-
-            emitter = await get_event_emitter()
-            return await emitter.emit_event(namespace, "claude_event", data)
-        except ImportError:
-            if DEBUG:
-                print("⚠️ Event emitter not available", file=sys.stderr)
-            return False
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emitter error: {e}", file=sys.stderr)
-            return False
-
     def _try_http_emit(self, namespace: str, event: str, data: dict):
         """Try to emit event using HTTP POST fallback (non-blocking).
 
@@ -196,10 +136,7 @@ class ConnectionManagerService:
         """
         if not REQUESTS_AVAILABLE:
             if DEBUG:
-                print(
-                    "⚠️ requests module not available - cannot emit via HTTP",
-                    file=sys.stderr,
-                )
+                _log("⚠️ requests module not available - cannot emit via HTTP")
             return
 
         # Submit to thread pool - don't wait for result (fire-and-forget)
@@ -225,25 +162,21 @@ class ConnectionManagerService:
 
             if response.status_code in [200, 204]:
                 if DEBUG:
-                    print(f"✅ HTTP POST successful: {event}", file=sys.stderr)
+                    _log(f"✅ HTTP POST successful: {event}")
             elif DEBUG:
-                print(
-                    f"⚠️ HTTP POST failed with status {response.status_code}: {event}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ HTTP POST failed with status {response.status_code}: {event}")
 
         except requests.exceptions.Timeout:
             if DEBUG:
-                print(f"⚠️ HTTP POST timeout for: {event}", file=sys.stderr)
+                _log(f"⚠️ HTTP POST timeout for: {event}")
         except requests.exceptions.ConnectionError:
             if DEBUG:
-                print(
-                    f"⚠️ HTTP POST connection failed for: {event} (server not running?)",
-                    file=sys.stderr,
+                _log(
+                    f"⚠️ HTTP POST connection failed for: {event} (server not running?)"
                 )
         except Exception as e:
             if DEBUG:
-                print(f"⚠️ HTTP POST error for {event}: {e}", file=sys.stderr)
+                _log(f"⚠️ HTTP POST error for {event}: {e}")
 
     def cleanup(self):
         """Cleanup connections on service destruction."""
@@ -251,4 +184,4 @@ class ConnectionManagerService:
         if hasattr(self, "_http_executor"):
             self._http_executor.shutdown(wait=False)
             if DEBUG:
-                print("✅ HTTP executor shutdown", file=sys.stderr)
+                _log("✅ HTTP executor shutdown")

claude_mpm/hooks/claude_hooks/services/state_manager.py

@@ -8,13 +8,22 @@ This service manages:
 """
 
 import os
-import subprocess
+import subprocess  # nosec B404
 import time
 from collections import deque
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
 # Import constants for configuration
 try:
     from claude_mpm.core.constants import TimeoutConfig
@@ -63,17 +72,11 @@ class StateManagerService:
     ):
         """Track a new agent delegation with optional request data for response correlation."""
         if DEBUG:
-            import sys
-
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - agent_type: {agent_type}", file=sys.stderr)
-            print(f"  - request_data provided: {bool(request_data)}", file=sys.stderr)
-            print(
-                f"  - delegation_requests size before: {len(self.delegation_requests)}",
-                file=sys.stderr,
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - agent_type: {agent_type}")
+            _log(f"  - request_data provided: {bool(request_data)}")
+            _log(
+                f"  - delegation_requests size before: {len(self.delegation_requests)}"
             )
 
         if session_id and agent_type and agent_type != "unknown":
@@ -89,15 +92,9 @@ class StateManagerService:
                     "timestamp": datetime.now(timezone.utc).isoformat(),
                 }
                 if DEBUG:
-                    import sys
-
-                    print(
-                        f"  - ✅ Stored in delegation_requests[{session_id[:16]}...]",
-                        file=sys.stderr,
-                    )
-                    print(
-                        f"  - delegation_requests size after: {len(self.delegation_requests)}",
-                        file=sys.stderr,
+                    _log(f"  - ✅ Stored in delegation_requests[{session_id[:16]}...]")
+                    _log(
+                        f"  - delegation_requests size after: {len(self.delegation_requests)}"
                     )
 
             # Clean up old delegations (older than 5 minutes)
@@ -197,7 +194,7 @@ class StateManagerService:
             os.chdir(working_dir)
 
             # Run git command to get current branch
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["git", "branch", "--show-current"],
                 capture_output=True,
                 text=True,
@@ -233,17 +230,12 @@ class StateManagerService:
     def find_matching_request(self, session_id: str) -> Optional[dict]:
         """Find matching request data for a session, with fuzzy matching fallback."""
         # First try exact match
-        request_info = self.delegation_requests.get(session_id)
+        request_info = self.delegation_requests.get(session_id)  # nosec B113
 
         # If exact match fails, try partial matching
         if not request_info and session_id:
             if DEBUG:
-                import sys
-
-                print(
-                    f"  - Trying fuzzy match for session {session_id[:16]}...",
-                    file=sys.stderr,
-                )
+                _log(f"  - Trying fuzzy match for session {session_id[:16]}...")
             # Try to find a session that matches the first 8-16 characters
             for stored_sid in list(self.delegation_requests.keys()):
                 if (
@@ -256,13 +248,8 @@ class StateManagerService:
                     )
                 ):
                     if DEBUG:
-                        import sys
-
-                        print(
-                            f"  - ✅ Fuzzy match found: {stored_sid[:16]}...",
-                            file=sys.stderr,
-                        )
-                    request_info = self.delegation_requests.get(stored_sid)
+                        _log(f"  - ✅ Fuzzy match found: {stored_sid[:16]}...")
+                    request_info = self.delegation_requests.get(stored_sid)  # nosec B113
                     # Update the key to use the current session_id for consistency
                     if request_info:
                         self.delegation_requests[session_id] = request_info

claude_mpm/hooks/claude_hooks/services/subagent_processor.py

@@ -10,10 +10,18 @@ This service handles:
 import json
 import os
 import re
-import sys
 from datetime import datetime, timezone
 from typing import Optional, Tuple
 
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
 # Debug mode is enabled by default for better visibility into hook processing
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
@@ -45,35 +53,31 @@ class SubagentResponseProcessor:
         # Enhanced debug logging for session correlation
         session_id = event.get("session_id", "")
         if DEBUG:
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - event keys: {list(event.keys())}", file=sys.stderr)
-            print(
-                f"  - delegation_requests size: {len(self.state_manager.delegation_requests)}",
-                file=sys.stderr,
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - event keys: {list(event.keys())}")
+            _log(
+                f"  - delegation_requests size: {len(self.state_manager.delegation_requests)}"
             )
             # Show all stored session IDs for comparison
             all_sessions = list(self.state_manager.delegation_requests.keys())
             if all_sessions:
-                print("  - Stored sessions (first 16 chars):", file=sys.stderr)
+                _log("  - Stored sessions (first 16 chars):")
                 for sid in all_sessions[:10]:  # Show up to 10
-                    print(
-                        f"    - {sid[:16]}... (agent: {self.state_manager.delegation_requests[sid].get('agent_type', 'unknown')})",
-                        file=sys.stderr,
+                    _log(
+                        f"    - {sid[:16]}... (agent: {self.state_manager.delegation_requests[sid].get('agent_type', 'unknown')})"
                     )
             else:
-                print("  - No stored sessions in delegation_requests!", file=sys.stderr)
+                _log("  - No stored sessions in delegation_requests!")
 
         # Get agent type and other basic info
-        agent_type, agent_id, reason = self._extract_basic_info(event, session_id)
+        agent_type, agent_id, reason, agent_type_inferred = self._extract_basic_info(
+            event, session_id
+        )
 
         # Always log SubagentStop events for debugging
         if DEBUG or agent_type != "unknown":
-            print(
-                f"Hook handler: Processing SubagentStop - agent: '{agent_type}', session: '{session_id}', reason: '{reason}'",
-                file=sys.stderr,
+            _log(
+                f"Hook handler: Processing SubagentStop - agent: '{agent_type}', session: '{session_id}', reason: '{reason}'"
             )
 
         # Get working directory and git branch
@@ -108,20 +112,29 @@ class SubagentResponseProcessor:
             working_dir,
             git_branch,
             structured_response,
+            agent_type_inferred,
         )
 
         # Debug log the processed data
         if DEBUG:
-            print(
-                f"SubagentStop processed data: agent_type='{agent_type}', session_id='{session_id}'",
-                file=sys.stderr,
+            _log(
+                f"SubagentStop processed data: agent_type='{agent_type}', session_id='{session_id}'"
             )
 
-        # Emit to /hook namespace with high priority
-        self.connection_manager.emit_event("/hook", "subagent_stop", subagent_stop_data)
+        # Emit to default namespace (consistent with subagent_start)
+        self.connection_manager.emit_event("", "subagent_stop", subagent_stop_data)
+
+    def _extract_basic_info(
+        self, event: dict, session_id: str
+    ) -> Tuple[str, str, str, bool]:
+        """Extract basic info from the event.
+
+        Returns:
+            Tuple of (agent_type, agent_id, reason, agent_type_inferred)
+            - agent_type_inferred is True when defaulted to "pm"
+        """
+        agent_type_inferred = False
 
-    def _extract_basic_info(self, event: dict, session_id: str) -> Tuple[str, str, str]:
-        """Extract basic info from the event."""
         # First try to get agent type from our tracking
         agent_type = (
             self.state_manager.get_delegation_agent_type(session_id)
@@ -146,7 +159,14 @@ class SubagentResponseProcessor:
             elif "pm" in task_desc or "project" in task_desc:
                 agent_type = "pm"
 
-        return agent_type, agent_id, reason
+        # Default to "pm" if still unknown (main conversation doesn't use Task tool)
+        if agent_type == "unknown":
+            agent_type = "pm"
+            agent_type_inferred = True
+            if DEBUG:
+                _log("  - Inferred agent_type='pm' (no explicit type found)")
+
+        return agent_type, agent_id, reason, agent_type_inferred
 
     def _extract_structured_response(
         self, output: str, agent_type: str
@@ -160,17 +180,15 @@ class SubagentResponseProcessor:
             if json_match:
                 structured_response = json.loads(json_match.group(1))
                 if DEBUG:
-                    print(
-                        f"Extracted structured response from {agent_type} agent in SubagentStop",
-                        file=sys.stderr,
+                    _log(
+                        f"Extracted structured response from {agent_type} agent in SubagentStop"
                     )
 
                 # Log if MEMORIES field is present
                 if structured_response.get("MEMORIES") and DEBUG:
                     memories_count = len(structured_response["MEMORIES"])
-                    print(
-                        f"Agent {agent_type} returned MEMORIES field with {memories_count} items",
-                        file=sys.stderr,
+                    _log(
+                        f"Agent {agent_type} returned MEMORIES field with {memories_count} items"
                     )
 
                 return structured_response
@@ -192,20 +210,15 @@ class SubagentResponseProcessor:
     ):
         """Track the agent response if response tracking is enabled."""
         if DEBUG:
-            print(
-                f"  - response_tracking_enabled: {self.response_tracking_manager.response_tracking_enabled}",
-                file=sys.stderr,
+            _log(
+                f"  - response_tracking_enabled: {self.response_tracking_manager.response_tracking_enabled}"
             )
-            print(
-                f"  - response_tracker exists: {self.response_tracking_manager.response_tracker is not None}",
-                file=sys.stderr,
+            _log(
+                f"  - response_tracker exists: {self.response_tracking_manager.response_tracker is not None}"
             )
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - agent_type: {agent_type}", file=sys.stderr)
-            print(f"  - reason: {reason}", file=sys.stderr)
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - agent_type: {agent_type}")
+            _log(f"  - reason: {reason}")
 
         if (
             self.response_tracking_manager.response_tracking_enabled
@@ -216,27 +229,16 @@ class SubagentResponseProcessor:
                 request_info = self.state_manager.find_matching_request(session_id)
 
                 if DEBUG:
-                    print(
-                        f"  - request_info present: {bool(request_info)}",
-                        file=sys.stderr,
-                    )
+                    _log(f"  - request_info present: {bool(request_info)}")
                     if request_info:
-                        print(
-                            "  - ✅ Found request data for response tracking",
-                            file=sys.stderr,
-                        )
-                        print(
-                            f"  - stored agent_type: {request_info.get('agent_type')}",
-                            file=sys.stderr,
-                        )
-                        print(
-                            f"  - request keys: {list(request_info.get('request', {}).keys())}",
-                            file=sys.stderr,
+                        _log("  - ✅ Found request data for response tracking")
+                        _log(f"  - stored agent_type: {request_info.get('agent_type')}")
+                        _log(
+                            f"  - request keys: {list(request_info.get('request', {}).keys())}"
                         )
                     else:
-                        print(
-                            f"  - ❌ No request data found for session {session_id[:16]}...",
-                            file=sys.stderr,
+                        _log(
+                            f"  - ❌ No request data found for session {session_id[:16]}..."
                         )
 
                 if request_info:
@@ -288,9 +290,8 @@ class SubagentResponseProcessor:
                         # Check for MEMORIES field and process if present
                         if structured_response.get("MEMORIES") and DEBUG:
                             memories = structured_response["MEMORIES"]
-                            print(
-                                f"Found MEMORIES field in {agent_type} response with {len(memories)} items",
-                                file=sys.stderr,
+                            _log(
+                                f"Found MEMORIES field in {agent_type} response with {len(memories)} items"
                             )
                             # The memory will be processed by extract_and_update_memory
                             # which is called by the memory hook service
@@ -307,26 +308,21 @@ class SubagentResponseProcessor:
                     )
 
                     if file_path and DEBUG:
-                        print(
-                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
-                            file=sys.stderr,
+                        _log(
+                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}"
                         )
 
                     # Clean up the request data
                     self.state_manager.remove_request(session_id)
 
                 elif DEBUG:
-                    print(
-                        f"No request data for SubagentStop session {session_id[:8]}..., agent: {agent_type}",
-                        file=sys.stderr,
+                    _log(
+                        f"No request data for SubagentStop session {session_id[:8]}..., agent: {agent_type}"
                     )
 
             except Exception as e:
                 if DEBUG:
-                    print(
-                        f"❌ Failed to track response on SubagentStop: {e}",
-                        file=sys.stderr,
-                    )
+                    _log(f"❌ Failed to track response on SubagentStop: {e}")
 
     def _build_subagent_stop_data(
         self,
@@ -338,10 +334,12 @@ class SubagentResponseProcessor:
         working_dir: str,
         git_branch: str,
         structured_response: Optional[dict],
+        agent_type_inferred: bool,
     ) -> dict:
         """Build the subagent stop data for event emission."""
         subagent_stop_data = {
             "agent_type": agent_type,
+            "agent_type_inferred": agent_type_inferred,
             "agent_id": agent_id,
             "reason": reason,
             "session_id": session_id,

claude_mpm/hooks/kuzu_memory_hook.py

@@ -13,9 +13,9 @@ for structured memory storage with semantic search capabilities.
 DESIGN DECISIONS:
 - Priority 10 for early execution to enrich prompts before other hooks
 - Uses subprocess to call kuzu-memory directly for maximum compatibility
-- Graceful degradation if kuzu-memory is not in PATH (though it's now required)
+- Graceful degradation if kuzu-memory is not installed
 - Automatic extraction and storage of important information
-- kuzu-memory>=1.1.5 is now a REQUIRED dependency (moved from optional in v4.8.6)
+- kuzu-memory is an OPTIONAL dependency (install with: pip install claude-mpm[memory])
 """
 
 import json
@@ -51,9 +51,9 @@ class KuzuMemoryHook(SubmitHook):
         self.enabled = self.kuzu_memory_cmd is not None
 
         if not self.enabled:
-            logger.warning(
-                "Kuzu-memory not found in PATH. As of v4.8.6, it's a required dependency. "
-                "Install with: pip install kuzu-memory>=1.1.5 or pipx install kuzu-memory"
+            logger.debug(
+                "Kuzu-memory not found. Graph-based memory disabled. "
+                "To enable: pip install claude-mpm[memory] (requires cmake)"
             )
         else:
             logger.info(f"Kuzu-memory integration enabled: {self.kuzu_memory_cmd}")