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

claude_mpm/VERSION

@@ -1 +1 @@
-5.6.4
+5.6.5

claude_mpm/hooks/claude_hooks/auto_pause_handler.py

@@ -22,7 +22,7 @@ USAGE:
         threshold_crossed = auto_pause.on_usage_update(metadata["usage"])
         if threshold_crossed:
             warning = auto_pause.emit_threshold_warning(threshold_crossed)
-            print(f"\n⚠️  {warning}", file=sys.stderr)
+            _log(f"\n⚠️  {warning}")
 
     # Record actions during pause mode
     if auto_pause.is_pause_active():
@@ -34,7 +34,6 @@ USAGE:
 """
 
 import os
-import sys
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -45,6 +44,15 @@ from claude_mpm.services.infrastructure.context_usage_tracker import (
     ContextUsageTracker,
 )
 
+# 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
+
+
 logger = get_logger(__name__)
 
 # Debug mode
@@ -100,11 +108,10 @@ class AutoPauseHandler:
             self._previous_threshold = current_state.threshold_reached
 
             if DEBUG:
-                print(
+                _log(
                     f"AutoPauseHandler initialized: "
                     f"{current_state.percentage_used:.1f}% context used, "
-                    f"threshold: {current_state.threshold_reached}",
-                    file=sys.stderr,
+                    f"threshold: {current_state.threshold_reached}"
                 )
         except Exception as e:
             logger.error(f"Failed to initialize AutoPauseHandler: {e}")
@@ -169,10 +176,9 @@ class AutoPauseHandler:
                     self._previous_threshold = current_threshold
 
                     if DEBUG:
-                        print(
+                        _log(
                             f"Context threshold crossed: {current_threshold} "
-                            f"({state.percentage_used:.1f}%)",
-                            file=sys.stderr,
+                            f"({state.percentage_used:.1f}%)"
                         )
 
                     # Trigger auto-pause if threshold reached
@@ -184,7 +190,7 @@ class AutoPauseHandler:
         except Exception as e:
             logger.error(f"Failed to update usage: {e}")
             if DEBUG:
-                print(f"❌ Usage update failed: {e}", file=sys.stderr)
+                _log(f"❌ Usage update failed: {e}")
             # Don't propagate error - auto-pause is optional
             return None
 
@@ -220,12 +226,12 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(f"Recorded tool call during pause: {tool_name}", file=sys.stderr)
+                _log(f"Recorded tool call during pause: {tool_name}")
 
         except Exception as e:
             logger.error(f"Failed to record tool call: {e}")
             if DEBUG:
-                print(f"❌ Failed to record tool call: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record tool call: {e}")
 
     def on_assistant_response(self, response_summary: str) -> None:
         """Record an assistant response if auto-pause is active.
@@ -257,15 +263,14 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
-                    f"Recorded assistant response during pause (length: {len(summary)})",
-                    file=sys.stderr,
+                _log(
+                    f"Recorded assistant response during pause (length: {len(summary)})"
                 )
 
         except Exception as e:
             logger.error(f"Failed to record assistant response: {e}")
             if DEBUG:
-                print(f"❌ Failed to record assistant response: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record assistant response: {e}")
 
     def on_user_message(self, message_summary: str) -> None:
         """Record a user message if auto-pause is active.
@@ -297,15 +302,12 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
-                    f"Recorded user message during pause (length: {len(summary)})",
-                    file=sys.stderr,
-                )
+                _log(f"Recorded user message during pause (length: {len(summary)})")
 
         except Exception as e:
             logger.error(f"Failed to record user message: {e}")
             if DEBUG:
-                print(f"❌ Failed to record user message: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record user message: {e}")
 
     def on_session_end(self) -> Optional[Path]:
         """Called when session ends. Finalizes any active pause.
@@ -318,7 +320,7 @@ class AutoPauseHandler:
         """
         if not self.is_pause_active():
             if DEBUG:
-                print("No active pause to finalize", file=sys.stderr)
+                _log("No active pause to finalize")
             return None
 
         try:
@@ -326,14 +328,14 @@ class AutoPauseHandler:
             session_path = self.pause_manager.finalize_pause(create_full_snapshot=True)
 
             if session_path and DEBUG:
-                print(f"✅ Session finalized: {session_path.name}", file=sys.stderr)
+                _log(f"✅ Session finalized: {session_path.name}")
 
             return session_path
 
         except Exception as e:
             logger.error(f"Failed to finalize pause session: {e}")
             if DEBUG:
-                print(f"❌ Failed to finalize pause: {e}", file=sys.stderr)
+                _log(f"❌ Failed to finalize pause: {e}")
             raise
 
     def is_pause_active(self) -> bool:
@@ -417,9 +419,7 @@ class AutoPauseHandler:
             # Check if pause is already active
             if self.is_pause_active():
                 if DEBUG:
-                    print(
-                        "Auto-pause already active, skipping trigger", file=sys.stderr
-                    )
+                    _log("Auto-pause already active, skipping trigger")
                 return
 
             # Start incremental pause
@@ -429,16 +429,15 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
+                _log(
                     f"✅ Auto-pause triggered: {session_id} "
-                    f"({state.percentage_used:.1f}% context used)",
-                    file=sys.stderr,
+                    f"({state.percentage_used:.1f}% context used)"
                 )
 
         except Exception as e:
             logger.error(f"Failed to trigger auto-pause: {e}")
             if DEBUG:
-                print(f"❌ Failed to trigger auto-pause: {e}", file=sys.stderr)
+                _log(f"❌ Failed to trigger auto-pause: {e}")
             # Don't propagate - auto-pause is optional
 
     def _summarize_dict(

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -7,7 +7,16 @@ including pre and post delegation hooks.
 
 import logging
 import os
-import sys
+from pathlib import Path
+
+# 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
+
 
 # Install-type-aware logging configuration BEFORE kuzu-memory imports
 # This overrides kuzu-memory's WARNING-level basicConfig (fixes 1M-445)
@@ -28,11 +37,15 @@ try:
         DeploymentContext.DEVELOPMENT,
         DeploymentContext.EDITABLE_INSTALL,
     ):
+        # Write logs to file instead of stderr to avoid hook errors
+        log_dir = Path.home() / ".claude-mpm"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "hooks.log"
         logging.basicConfig(
             level=logging.INFO,
             format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
             force=True,  # Python 3.8+ - reconfigures root logger
-            stream=sys.stderr,
+            filename=str(log_file),
         )
 except ImportError:
     # Fallback: if unified_paths not available, check suppression before configuring
@@ -40,11 +53,15 @@ except ImportError:
     is_suppressed = root_logger.level > logging.CRITICAL
 
     if not is_suppressed:
+        # Write logs to file instead of stderr to avoid hook errors
+        log_dir = Path.home() / ".claude-mpm"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "hooks.log"
         logging.basicConfig(
             level=logging.INFO,
             format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
             force=True,
-            stream=sys.stderr,
+            filename=str(log_file),
         )
 from datetime import datetime, timezone
 from typing import Optional
@@ -71,7 +88,7 @@ try:
 except Exception as e:
     # Catch all exceptions to prevent any import errors from breaking the handler
     if DEBUG:
-        print(f"Memory hooks not available: {e}", file=sys.stderr)
+        _log(f"Memory hooks not available: {e}")
     MEMORY_HOOKS_AVAILABLE = False
 
 
@@ -105,10 +122,7 @@ class MemoryHookManager:
             # Only initialize if memory system is enabled
             if not config.get("memory.enabled", True):
                 if DEBUG:
-                    print(
-                        "Memory system disabled - skipping hook initialization",
-                        file=sys.stderr,
-                    )
+                    _log("Memory system disabled - skipping hook initialization")
                 return
 
             # Initialize pre-delegation hook for memory injection
@@ -126,14 +140,11 @@ class MemoryHookManager:
                     hooks_info.append("pre-delegation")
                 if self.post_delegation_hook:
                     hooks_info.append("post-delegation")
-                print(
-                    f"✅ Memory hooks initialized: {', '.join(hooks_info)}",
-                    file=sys.stderr,
-                )
+                _log(f"✅ Memory hooks initialized: {', '.join(hooks_info)}")
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to initialize memory hooks: {e}", file=sys.stderr)
+                _log(f"❌ Failed to initialize memory hooks: {e}")
             # Don't fail the entire handler - memory system is optional
 
     def trigger_pre_delegation_hook(
@@ -182,14 +193,13 @@ class MemoryHookManager:
 
                     if DEBUG:
                         memory_size = len(memory_section.encode("utf-8"))
-                        print(
-                            f"✅ Injected {memory_size} bytes of memory for agent '{agent_type}'",
-                            file=sys.stderr,
+                        _log(
+                            f"✅ Injected {memory_size} bytes of memory for agent '{agent_type}'"
                         )
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Memory pre-delegation hook failed: {e}", file=sys.stderr)
+                _log(f"❌ Memory pre-delegation hook failed: {e}")
             # Don't fail the delegation - memory is optional
 
     def trigger_post_delegation_hook(
@@ -249,12 +259,11 @@ class MemoryHookManager:
             if result.success and result.metadata:
                 learnings_extracted = result.metadata.get("learnings_extracted", 0)
                 if learnings_extracted > 0 and DEBUG:
-                    print(
-                        f"✅ Extracted {learnings_extracted} learnings for agent '{agent_type}'",
-                        file=sys.stderr,
+                    _log(
+                        f"✅ Extracted {learnings_extracted} learnings for agent '{agent_type}'"
                     )
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Memory post-delegation hook failed: {e}", file=sys.stderr)
+                _log(f"❌ Memory post-delegation hook failed: {e}")
             # Don't fail the delegation result - memory is optional

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}")