claude-mpm 5.6.4__py3-none-any.whl → 5.6.16__py3-none-any.whl

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -8,11 +8,19 @@ with their original requests.
 import json
 import os
 import re
-import sys
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, 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
+
+
 # Debug mode
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
@@ -80,10 +88,7 @@ class ResponseTrackingManager:
 
             if not (response_tracking_enabled or response_logging_enabled):
                 if DEBUG:
-                    print(
-                        "Response tracking disabled - skipping initialization",
-                        file=sys.stderr,
-                    )
+                    _log("Response tracking disabled - skipping initialization")
                 return
 
             # Initialize response tracker with config
@@ -101,15 +106,11 @@ class ResponseTrackingManager:
                     if self.track_all_interactions
                     else "Task delegations only"
                 )
-                print(
-                    f"✅ Response tracking initialized (mode: {mode})", file=sys.stderr
-                )
+                _log(f"✅ Response tracking initialized (mode: {mode})")
 
         except Exception as e:
             if DEBUG:
-                print(
-                    f"❌ Failed to initialize response tracking: {e}", file=sys.stderr
-                )
+                _log(f"❌ Failed to initialize response tracking: {e}")
             # Don't fail the entire handler - response tracking is optional
 
     def track_agent_response(
@@ -133,9 +134,8 @@ class ResponseTrackingManager:
             request_info = delegation_requests.get(session_id)  # nosec B113 - False positive: dict.get(), not requests library
             if not request_info:
                 if DEBUG:
-                    print(
-                        f"No request data found for session {session_id}, skipping response tracking",
-                        file=sys.stderr,
+                    _log(
+                        f"No request data found for session {session_id}, skipping response tracking"
                     )
                 return
 
@@ -163,15 +163,11 @@ class ResponseTrackingManager:
                 if json_match:
                     structured_response = json.loads(json_match.group(1))
                     if DEBUG:
-                        print(
-                            f"Extracted structured response from {agent_type} agent",
-                            file=sys.stderr,
-                        )
+                        _log(f"Extracted structured response from {agent_type} agent")
             except (json.JSONDecodeError, AttributeError) as e:
                 if DEBUG:
-                    print(
-                        f"No structured JSON response found in {agent_type} agent output: {e}",
-                        file=sys.stderr,
+                    _log(
+                        f"No structured JSON response found in {agent_type} agent output: {e}"
                     )
 
             # Get the original request (prompt + description)
@@ -220,9 +216,8 @@ class ResponseTrackingManager:
                 if structured_response.get("MEMORIES"):
                     if 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"
                         )
 
                 # Check if task was completed for logging purposes
@@ -232,9 +227,7 @@ class ResponseTrackingManager:
                 # Log files modified for debugging
                 if DEBUG and structured_response.get("files_modified"):
                     files = [f["file"] for f in structured_response["files_modified"]]
-                    print(
-                        f"Agent {agent_type} modified files: {files}", file=sys.stderr
-                    )
+                    _log(f"Agent {agent_type} modified files: {files}")
 
             # Track the response
             file_path = self.response_tracker.track_response(
@@ -246,14 +239,12 @@ class ResponseTrackingManager:
             )
 
             if file_path and DEBUG:
-                print(
-                    f"✅ Tracked response for {agent_type} agent in session {session_id}: {file_path.name}",
-                    file=sys.stderr,
+                _log(
+                    f"✅ Tracked response for {agent_type} agent in session {session_id}: {file_path.name}"
                 )
             elif DEBUG and not file_path:
-                print(
-                    f"Response tracking returned None for {agent_type} agent (might be excluded or disabled)",
-                    file=sys.stderr,
+                _log(
+                    f"Response tracking returned None for {agent_type} agent (might be excluded or disabled)"
                 )
 
             # Clean up the request data after successful tracking
@@ -261,7 +252,7 @@ class ResponseTrackingManager:
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to track agent response: {e}", file=sys.stderr)
+                _log(f"❌ Failed to track agent response: {e}")
             # Don't fail the hook processing - response tracking is optional
 
     def track_stop_response(
@@ -286,11 +277,10 @@ class ResponseTrackingManager:
             prompt_data = pending_prompts.get(session_id)
 
             if DEBUG:
-                print(
-                    f"  - output present: {bool(output)} (length: {len(str(output)) if output else 0})",
-                    file=sys.stderr,
+                _log(
+                    f"  - output present: {bool(output)} (length: {len(str(output)) if output else 0})"
                 )
-                print(f"  - prompt_data present: {bool(prompt_data)}", file=sys.stderr)
+                _log(f"  - prompt_data present: {bool(prompt_data)}")
 
             if output and prompt_data:
                 # Add prompt timestamp to metadata
@@ -300,10 +290,7 @@ class ResponseTrackingManager:
                 if "stop_reason" in event:
                     metadata["stop_reason"] = event["stop_reason"]
                     if DEBUG:
-                        print(
-                            f"  - Captured stop_reason: {event['stop_reason']}",
-                            file=sys.stderr,
-                        )
+                        _log(f"  - Captured stop_reason: {event['stop_reason']}")
 
                 # Capture Claude API usage data if available
                 # NOTE: Usage data is already captured in metadata by handle_stop_fast()
@@ -324,10 +311,7 @@ class ResponseTrackingManager:
                         total_tokens = usage_data.get(
                             "input_tokens", 0
                         ) + usage_data.get("output_tokens", 0)
-                        print(
-                            f"  - Captured usage: {total_tokens} total tokens",
-                            file=sys.stderr,
-                        )
+                        _log(f"  - Captured usage: {total_tokens} total tokens")
 
                 # Track the main Claude response
                 file_path = self.response_tracker.track_response(
@@ -339,14 +323,14 @@ class ResponseTrackingManager:
                 )
 
                 if file_path and DEBUG:
-                    print(f"  - Response tracked to: {file_path}", file=sys.stderr)
+                    _log(f"  - Response tracked to: {file_path}")
 
                 # Clean up pending prompt
                 del pending_prompts[session_id]
 
         except Exception as e:
             if DEBUG:
-                print(f"Error tracking stop response: {e}", file=sys.stderr)
+                _log(f"Error tracking stop response: {e}")
 
     def track_assistant_response(self, event: dict, pending_prompts: dict):
         """Handle assistant response events for comprehensive response tracking."""
@@ -361,9 +345,8 @@ class ResponseTrackingManager:
         prompt_data = pending_prompts.get(session_id)
         if not prompt_data:
             if DEBUG:
-                print(
-                    f"No stored prompt for session {session_id[:8]}..., skipping response tracking",
-                    file=sys.stderr,
+                _log(
+                    f"No stored prompt for session {session_id[:8]}..., skipping response tracking"
                 )
             return
 
@@ -377,9 +360,8 @@ class ResponseTrackingManager:
 
             if not response_content:
                 if DEBUG:
-                    print(
-                        f"No response content in event for session {session_id[:8]}...",
-                        file=sys.stderr,
+                    _log(
+                        f"No response content in event for session {session_id[:8]}..."
                     )
                 return
 
@@ -401,9 +383,8 @@ class ResponseTrackingManager:
             )
 
             if file_path and DEBUG:
-                print(
-                    f"✅ Tracked Claude response for session {session_id[:8]}...: {file_path.name}",
-                    file=sys.stderr,
+                _log(
+                    f"✅ Tracked Claude response for session {session_id[:8]}...: {file_path.name}"
                 )
 
             # Clean up the stored prompt
@@ -411,4 +392,4 @@ class ResponseTrackingManager:
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to track assistant response: {e}", file=sys.stderr)
+                _log(f"❌ Failed to track assistant response: {e}")

claude_mpm/hooks/claude_hooks/services/connection_manager.py

@@ -20,6 +20,15 @@ import os
 import sys
 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"
 
@@ -94,13 +103,10 @@ class ConnectionManagerService:
         try:
             self.connection_pool = get_connection_pool()
             if DEBUG:
-                print("✅ Modern SocketIO connection pool initialized", file=sys.stderr)
+                _log("✅ Modern SocketIO connection pool initialized")
         except Exception as e:
             if DEBUG:
-                print(
-                    f"⚠️ Failed to initialize SocketIO connection pool: {e}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ Failed to initialize SocketIO connection pool: {e}")
             self.connection_pool = None
 
     def emit_event(self, namespace: str, event: str, data: dict):
@@ -149,10 +155,7 @@ class ConnectionManagerService:
 
                 # Debug log when we detect invalid hook_type for troubleshooting
                 if DEBUG:
-                    print(
-                        f"⚠️ Invalid hook_type detected, using fallback: {hook_type}",
-                        file=sys.stderr,
-                    )
+                    _log(f"⚠️ Invalid hook_type detected, using fallback: {hook_type}")
 
             event_type = hook_type
         else:
@@ -177,16 +180,12 @@ 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}'"
                 )
 
         # Emit through direct Socket.IO connection pool (primary path)
@@ -196,11 +195,11 @@ class ConnectionManagerService:
                 # Emit to Socket.IO server directly
                 self.connection_pool.emit("mpm_event", claude_event_data)
                 if DEBUG:
-                    print(f"✅ Emitted via connection pool: {event}", file=sys.stderr)
+                    _log(f"✅ Emitted via connection pool: {event}")
                 return  # Success - no need for fallback
             except Exception as e:
                 if DEBUG:
-                    print(f"⚠️ Failed to emit via connection pool: {e}", file=sys.stderr)
+                    _log(f"⚠️ Failed to emit via connection pool: {e}")
 
         # HTTP fallback for cross-process communication (when direct calls fail)
         # This replaces EventBus for reliability without the complexity
@@ -221,22 +220,18 @@ class ConnectionManagerService:
 
             if response.status_code in [200, 204]:
                 if DEBUG:
-                    print("✅ HTTP fallback successful", file=sys.stderr)
+                    _log("✅ HTTP fallback successful")
             elif DEBUG:
-                print(
-                    f"⚠️ HTTP fallback failed: {response.status_code}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ HTTP fallback failed: {response.status_code}")
 
         except Exception as e:
             if DEBUG:
-                print(f"⚠️ HTTP fallback error: {e}", file=sys.stderr)
+                _log(f"⚠️ HTTP fallback error: {e}")
 
         # Warn if no emission method is available
         if not self.connection_pool and DEBUG:
-            print(
-                f"⚠️ No event emission method available for: {claude_event_data.get('event', 'unknown')}",
-                file=sys.stderr,
+            _log(
+                f"⚠️ No event emission method available for: {claude_event_data.get('event', 'unknown')}"
             )
 
     def cleanup(self):
@@ -245,5 +240,5 @@ class ConnectionManagerService:
         if self.connection_pool:
             try:
                 self.connection_pool.cleanup()
-            except Exception:
+            except Exception:  # nosec B110
                 pass  # Ignore cleanup errors during destruction

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -16,10 +16,18 @@ is simpler and more reliable for ephemeral processes.
 """
 
 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"
 
@@ -78,9 +86,8 @@ class ConnectionManagerService:
         )
 
         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):
@@ -110,16 +117,12 @@ 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}'"
                 )
 
         # Emit via HTTP POST (non-blocking, runs in thread pool)
@@ -133,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)
@@ -162,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."""
@@ -188,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