claude-mpm 5.6.1__py3-none-any.whl → 5.6.76__py3-none-any.whl

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
@@ -24,8 +33,8 @@ except ImportError:
         QUICK_TIMEOUT = 2.0
 
 
-# Debug mode is enabled by default for better visibility into hook processing
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# Debug mode - disabled by default to prevent logging overhead in production
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 
 class StateManagerService:
@@ -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,12 +10,20 @@ This service handles:
 import json
 import os
 import re
-import sys
 from datetime import datetime, timezone
 from typing import Optional, Tuple
 
-# Debug mode is enabled by default for better visibility into hook processing
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# 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 - disabled by default to prevent logging overhead in production
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 
 class SubagentResponseProcessor:
@@ -45,26 +53,21 @@ 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, agent_type_inferred = self._extract_basic_info(
@@ -73,9 +76,8 @@ class SubagentResponseProcessor:
 
         # 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
@@ -115,9 +117,8 @@ class SubagentResponseProcessor:
 
         # 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 default namespace (consistent with subagent_start)
@@ -163,10 +164,7 @@ class SubagentResponseProcessor:
             agent_type = "pm"
             agent_type_inferred = True
             if DEBUG:
-                print(
-                    "  - Inferred agent_type='pm' (no explicit type found)",
-                    file=sys.stderr,
-                )
+                _log("  - Inferred agent_type='pm' (no explicit type found)")
 
         return agent_type, agent_id, reason, agent_type_inferred
 
@@ -182,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
@@ -214,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,
-            )
-            print(
-                f"  - response_tracker exists: {self.response_tracking_manager.response_tracker is not None}",
-                file=sys.stderr,
+            _log(
+                f"  - response_tracking_enabled: {self.response_tracking_manager.response_tracking_enabled}"
             )
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
+            _log(
+                f"  - response_tracker exists: {self.response_tracking_manager.response_tracker is not None}"
             )
-            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
@@ -238,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:
@@ -310,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
@@ -329,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,

claude_mpm/hooks/session_resume_hook.py

@@ -12,13 +12,21 @@ DESIGN DECISIONS:
 """
 
 import json
-import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.logger import get_logger
 from claude_mpm.services.cli.session_resume_helper import SessionResumeHelper
 
+# 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__)
 
 
@@ -86,23 +94,19 @@ class SessionResumeStartupHook:
         Args:
             pause_info: Pause session metadata from check_for_active_pause()
         """
-        print("\n" + "=" * 60, file=sys.stderr)
-        print("⚠️  ACTIVE AUTO-PAUSE SESSION DETECTED", file=sys.stderr)
-        print("=" * 60, file=sys.stderr)
-        print(f"Session ID: {pause_info['session_id']}", file=sys.stderr)
-        print(f"Started at: {pause_info['started_at']}", file=sys.stderr)
-        print(
-            f"Context at pause: {pause_info['context_at_start']:.1%}", file=sys.stderr
-        )
-        print(f"Actions recorded: {pause_info['action_count']}", file=sys.stderr)
-        print(
-            "\nThis session was auto-paused due to high context usage.", file=sys.stderr
-        )
-        print("Options:", file=sys.stderr)
-        print("  1. Continue (actions will be appended)", file=sys.stderr)
-        print("  2. Use /mpm-init pause --finalize to create snapshot", file=sys.stderr)
-        print("  3. Use /mpm-init pause --discard to abandon", file=sys.stderr)
-        print("=" * 60 + "\n", file=sys.stderr)
+        _log("=" * 60)
+        _log("⚠️  ACTIVE AUTO-PAUSE SESSION DETECTED")
+        _log("=" * 60)
+        _log(f"Session ID: {pause_info['session_id']}")
+        _log(f"Started at: {pause_info['started_at']}")
+        _log(f"Context at pause: {pause_info['context_at_start']:.1%}")
+        _log(f"Actions recorded: {pause_info['action_count']}")
+        _log("\nThis session was auto-paused due to high context usage.")
+        _log("Options:")
+        _log("  1. Continue (actions will be appended)")
+        _log("  2. Use /mpm-init pause --finalize to create snapshot")
+        _log("  3. Use /mpm-init pause --discard to abandon")
+        _log("=" * 60 + "\n")
 
     def on_pm_startup(self) -> Optional[Dict[str, Any]]:
         """Execute on PM startup to check for paused sessions.

claude_mpm/hooks/templates/pre_tool_use_simple.py

@@ -38,7 +38,7 @@ def main():
         # Read event from stdin
         event_data = sys.stdin.read()
         if not event_data.strip():
-            print(json.dumps({"action": "continue"}))
+            print(json.dumps({"continue": True}))
             return
 
         event = json.loads(event_data)
@@ -49,7 +49,7 @@ def main():
         if tool_name == "Grep" and "-n" not in tool_input:
             modified_input = tool_input.copy()
             modified_input["-n"] = True
-            print(json.dumps({"action": "continue", "tool_input": modified_input}))
+            print(json.dumps({"continue": True, "tool_input": modified_input}))
             return
 
         # Example: Block operations on .env files
@@ -59,19 +59,19 @@ def main():
                 print(
                     json.dumps(
                         {
-                            "action": "block",
-                            "message": "Access to .env file blocked for security",
+                            "continue": False,
+                            "stopReason": "Access to .env file blocked for security",
                         }
                     )
                 )
                 return
 
         # Default: continue without modification
-        print(json.dumps({"action": "continue"}))
+        print(json.dumps({"continue": True}))
 
     except Exception:
         # Always continue on error to avoid blocking Claude
-        print(json.dumps({"action": "continue"}))
+        print(json.dumps({"continue": True}))
 
 
 if __name__ == "__main__":

claude_mpm/hooks/templates/pre_tool_use_template.py

@@ -29,7 +29,7 @@ Input Format (stdin):
 
 Output Format (stdout):
 {
-  "action": "continue",
+  "continue": true,
   "tool_input": {
     "file_path": "/path/to/file.py",
     "old_string": "foo",
@@ -39,13 +39,13 @@ Output Format (stdout):
 
 Or to block execution:
 {
-  "action": "block",
-  "message": "Reason for blocking"
+  "continue": false,
+  "stopReason": "Reason for blocking"
 }
 
 Or to continue without modification:
 {
-  "action": "continue"
+  "continue": true
 }
 """
 
@@ -55,6 +55,14 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, 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
+
 
 class PreToolUseHook:
     """Base class for PreToolUse hooks with input modification support."""
@@ -64,9 +72,9 @@ class PreToolUseHook:
         self.debug = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
     def log_debug(self, message: str) -> None:
-        """Log debug message to stderr."""
+        """Log debug message using _log helper."""
         if self.debug:
-            print(f"[PreToolUse Hook] {message}", file=sys.stderr)
+            _log(f"[PreToolUse Hook] {message}")
 
     def read_event(self) -> Optional[Dict[str, Any]]:
         """Read and parse the hook event from stdin."""
@@ -86,14 +94,14 @@ class PreToolUseHook:
         self, modified_input: Optional[Dict[str, Any]] = None
     ) -> None:
         """Continue execution with optional modified input."""
-        response = {"action": "continue"}
+        response = {"continue": True}
         if modified_input is not None:
             response["tool_input"] = modified_input
         print(json.dumps(response))
 
     def block_execution(self, message: str) -> None:
         """Block execution with a message."""
-        response = {"action": "block", "message": message}
+        response = {"continue": False, "stopReason": message}
         print(json.dumps(response))
 
     def modify_input(

claude_mpm/init.py

@@ -147,9 +147,14 @@ class ProjectInitializer:
 
             # Print appropriate message to console for visibility during startup
             # BUT: Don't print to stdout when running MCP server (interferes with JSON-RPC)
+            # ALSO: Skip output for lightweight commands (oauth, version, help, doctor)
             is_mcp_mode = "mcp" in sys.argv and "start" in sys.argv
+            is_lightweight_command = any(
+                cmd in sys.argv
+                for cmd in ["oauth", "--version", "-v", "--help", "-h", "doctor"]
+            )
 
-            if not is_mcp_mode:
+            if not is_mcp_mode and not is_lightweight_command:
                 if directory_existed:
                     print(f"✓ Found existing .claude-mpm/ directory in {project_root}")
                 else:
@@ -164,13 +169,15 @@ class ProjectInitializer:
                     )
 
             # Verify and deploy PM skills (non-blocking)
-            self._verify_and_deploy_pm_skills(project_root, is_mcp_mode)
+            # Skip for lightweight commands that should run immediately
+            suppress_output = is_mcp_mode or is_lightweight_command
+            self._verify_and_deploy_pm_skills(project_root, suppress_output)
 
             # Setup security hooks (auto-install pre-commit, detect-secrets)
-            self._setup_security_hooks(project_root, is_mcp_mode)
+            self._setup_security_hooks(project_root, suppress_output)
 
             # Perform security checks (non-blocking)
-            self._check_security_risks(project_root, is_mcp_mode)
+            self._check_security_risks(project_root, suppress_output)
 
             return True
 
@@ -406,7 +413,7 @@ class ProjectInitializer:
             is_mcp_mode: Whether running in MCP mode (suppress console output)
         """
         try:
-            import subprocess
+            import subprocess  # nosec B404 - required for git/pre-commit operations
 
             # Only set up hooks if this is a git repository
             if not (project_root / ".git").exists():
@@ -415,7 +422,7 @@ class ProjectInitializer:
 
             # Check/install pre-commit
             try:
-                subprocess.run(
+                subprocess.run(  # nosec B603 B607 - trusted pre-commit command
                     ["pre-commit", "--version"],
                     capture_output=True,
                     text=True,
@@ -429,7 +436,7 @@ class ProjectInitializer:
             ):
                 self.logger.info("Installing pre-commit...")
                 try:
-                    subprocess.run(
+                    subprocess.run(  # nosec B603 B607 - trusted pip install command
                         [sys.executable, "-m", "pip", "install", "pre-commit"],
                         capture_output=True,
                         text=True,
@@ -443,7 +450,7 @@ class ProjectInitializer:
 
             # Check/install detect-secrets
             try:
-                subprocess.run(
+                subprocess.run(  # nosec B603 B607 - trusted detect-secrets command
                     ["detect-secrets", "--version"],
                     capture_output=True,
                     text=True,
@@ -457,7 +464,7 @@ class ProjectInitializer:
             ):
                 self.logger.info("Installing detect-secrets...")
                 try:
-                    subprocess.run(
+                    subprocess.run(  # nosec B603 B607 - trusted pip install command
                         [sys.executable, "-m", "pip", "install", "detect-secrets"],
                         capture_output=True,
                         text=True,
@@ -486,7 +493,7 @@ class ProjectInitializer:
             secrets_baseline = project_root / ".secrets.baseline"
             if not secrets_baseline.exists():
                 try:
-                    subprocess.run(
+                    subprocess.run(  # nosec B603 B607 - trusted detect-secrets command
                         ["detect-secrets", "scan", "--baseline", ".secrets.baseline"],
                         cwd=str(project_root),
                         capture_output=True,
@@ -500,7 +507,7 @@ class ProjectInitializer:
 
             # Install git hooks
             try:
-                subprocess.run(
+                subprocess.run(  # nosec B603 B607 - trusted pre-commit command
                     ["pre-commit", "install"],
                     cwd=str(project_root),
                     capture_output=True,
@@ -532,7 +539,7 @@ class ProjectInitializer:
             is_mcp_mode: Whether running in MCP mode (suppress console output)
         """
         try:
-            import subprocess
+            import subprocess  # nosec B404 - required for git operations
 
             security_issues = []
 
@@ -552,7 +559,7 @@ class ProjectInitializer:
                 if file_path.exists():
                     # Check if file is tracked by git
                     try:
-                        result = subprocess.run(
+                        result = subprocess.run(  # nosec B603 B607 - trusted git command
                             ["git", "ls-files", str(file_path)],
                             check=False,
                             cwd=str(project_root),
@@ -569,7 +576,7 @@ class ProjectInitializer:
 
                     # Check if file is ignored by .gitignore
                     try:
-                        result = subprocess.run(
+                        result = subprocess.run(  # nosec B603 B607 - trusted git command
                             ["git", "check-ignore", str(file_path)],
                             check=False,
                             cwd=str(project_root),

claude_mpm/mcp/__init__.py

@@ -0,0 +1,9 @@
+"""MCP servers for claude-mpm integration.
+
+This module provides MCP (Model Context Protocol) servers that integrate
+with claude-mpm's authentication and token management system.
+"""
+
+from claude_mpm.mcp.google_workspace_server import main
+
+__all__ = ["main"]