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

claude_mpm/hooks/claude_hooks/installer.py

@@ -10,12 +10,10 @@ import os
 import re
 import shutil
 import stat
-import subprocess
+import subprocess  # nosec B404 - Safe: only uses hardcoded 'claude' CLI command, no user input
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-from ...core.logger import get_logger
-
 
 class HookInstaller:
     """Manages installation and configuration of Claude MPM hooks."""
@@ -194,16 +192,24 @@ main "$@"
     MIN_CLAUDE_VERSION = "1.0.92"
     # Minimum version for PreToolUse input modification support
     MIN_PRETOOL_MODIFY_VERSION = "2.0.30"
+    # Minimum version for user-invocable skills support
+    MIN_SKILLS_VERSION = "2.1.3"
 
     def __init__(self):
         """Initialize the hook installer."""
-        self.logger = get_logger(__name__)
+        # Use __name__ directly to avoid double prefix
+        # __name__ is already 'claude_mpm.hooks.claude_hooks.installer'
+        # get_logger() adds 'claude_mpm.' prefix, causing duplicate
+        import logging
+
+        self.logger = logging.getLogger(__name__)
         self.claude_dir = Path.home() / ".claude"
         self.hooks_dir = self.claude_dir / "hooks"  # Kept for backward compatibility
         # Use settings.json for hooks (Claude Code reads from this file)
         self.settings_file = self.claude_dir / "settings.json"
-        # Keep reference to old file for migration
-        self.old_settings_file = self.claude_dir / "settings.json"
+        # There is no legacy settings file - this was a bug where both pointed to same file
+        # Setting to None to disable cleanup that was deleting freshly installed hooks
+        self.old_settings_file = None
         self._claude_version: Optional[str] = None
         self._hook_script_path: Optional[Path] = None
 
@@ -219,7 +225,7 @@ main "$@"
 
         try:
             # Run claude --version command
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B607 B603 - Safe: hardcoded command, no user input
                 ["claude", "--version"],
                 capture_output=True,
                 text=True,
@@ -330,6 +336,53 @@ main "$@"
 
         return True
 
+    def _version_meets_minimum(self, version: str, min_version: str) -> bool:
+        """Check if a version meets minimum requirements.
+
+        Args:
+            version: Current version string (e.g., "2.1.3")
+            min_version: Minimum required version string (e.g., "2.1.3")
+
+        Returns:
+            True if version meets or exceeds minimum, False otherwise
+        """
+
+        def parse_version(v: str) -> List[int]:
+            """Parse semantic version string to list of integers."""
+            try:
+                return [int(x) for x in v.split(".")]
+            except (ValueError, AttributeError):
+                return [0]
+
+        current = parse_version(version)
+        required = parse_version(min_version)
+
+        # Compare versions
+        for i in range(max(len(current), len(required))):
+            curr_part = current[i] if i < len(current) else 0
+            req_part = required[i] if i < len(required) else 0
+
+            if curr_part < req_part:
+                return False
+            if curr_part > req_part:
+                return True
+
+        return True
+
+    def supports_user_invocable_skills(self) -> bool:
+        """Check if Claude Code version supports user-invocable skills.
+
+        User-invocable skills were added in Claude Code v2.1.3.
+        This feature allows users to invoke skills via slash commands.
+
+        Returns:
+            True if version supports user-invocable skills, False otherwise
+        """
+        version = self.get_claude_version()
+        if not version:
+            return False
+        return self._version_meets_minimum(version, self.MIN_SKILLS_VERSION)
+
     def get_hook_script_path(self) -> Path:
         """Get the path to the hook handler script based on installation method.
 
@@ -462,7 +515,9 @@ main "$@"
 
     def _cleanup_old_settings(self) -> None:
         """Remove hooks from old settings.json file if present."""
-        if not self.old_settings_file.exists():
+        # No-op: old_settings_file was pointing to same file as settings_file (bug)
+        # This was causing freshly installed hooks to be immediately deleted
+        if self.old_settings_file is None or not self.old_settings_file.exists():
             return
 
         try:
@@ -482,6 +537,44 @@ main "$@"
         except Exception as e:
             self.logger.warning(f"Could not clean up old settings file: {e}")
 
+    def _fix_status_line(self, settings: Dict) -> None:
+        """Fix statusLine command to handle both output style schema formats.
+
+        The statusLine command receives input in different formats:
+        - Newer format: {"activeOutputStyle": "Claude MPM", ...}
+        - Older format: {"output_style": {"name": "Claude MPM"}, ...}
+
+        This method ensures the jq expression checks both locations.
+
+        Args:
+            settings: The settings dictionary to update
+        """
+        if "statusLine" not in settings:
+            return
+
+        status_line = settings.get("statusLine", {})
+        if "command" not in status_line:
+            return
+
+        command = status_line["command"]
+
+        # Pattern to match: '.output_style.name // "default"'
+        # We need to update it to: '.output_style.name // .activeOutputStyle // "default"'
+        old_pattern = r'\.output_style\.name\s*//\s*"default"'
+        new_pattern = '.output_style.name // .activeOutputStyle // "default"'
+
+        # Check if the command needs updating
+        if re.search(old_pattern, command) and ".activeOutputStyle" not in command:
+            updated_command = re.sub(old_pattern, new_pattern, command)
+            settings["statusLine"]["command"] = updated_command
+            self.logger.info(
+                "Fixed statusLine command to handle both output style schemas"
+            )
+        else:
+            self.logger.debug(
+                "StatusLine command already supports both schemas or not present"
+            )
+
     def _update_claude_settings(self, hook_script_path: Path) -> None:
         """Update Claude settings to use the installed hook."""
         self.logger.info("Updating Claude settings...")
@@ -518,15 +611,34 @@ main "$@"
                 }
             ]
 
-        # Non-tool events don't need a matcher
-        non_tool_events = ["UserPromptSubmit", "Stop", "SubagentStop", "SubagentStart"]
-        for event_type in non_tool_events:
+        # Simple events (no subtypes, no matcher needed)
+        simple_events = ["Stop", "SubagentStop", "SubagentStart"]
+        for event_type in simple_events:
             settings["hooks"][event_type] = [
                 {
                     "hooks": [hook_command],
                 }
             ]
 
+        # SessionStart needs matcher for subtypes (startup, resume)
+        settings["hooks"]["SessionStart"] = [
+            {
+                "matcher": "*",  # Match all SessionStart subtypes
+                "hooks": [hook_command],
+            }
+        ]
+
+        # UserPromptSubmit needs matcher for potential subtypes
+        settings["hooks"]["UserPromptSubmit"] = [
+            {
+                "matcher": "*",
+                "hooks": [hook_command],
+            }
+        ]
+
+        # Fix statusLine command to handle both output style schemas
+        self._fix_status_line(settings)
+
         # Write settings to settings.json
         with self.settings_file.open("w") as f:
             json.dump(settings, f, indent=2)
@@ -537,7 +649,22 @@ main "$@"
         self._cleanup_old_settings()
 
     def _install_commands(self) -> None:
-        """Install custom commands for Claude Code."""
+        """Install custom commands for Claude Code.
+
+        For Claude Code >= 2.1.3, commands are deployed as skills via PMSkillsDeployerService.
+        This method provides backward compatibility for older versions.
+        """
+        # Check if skills-based commands are supported
+        if self.supports_user_invocable_skills():
+            self.logger.info(
+                "Claude Code >= 2.1.3 detected. Commands deployed as skills - "
+                "skipping legacy command installation."
+            )
+            return
+
+        # Legacy installation for older Claude Code versions
+        self.logger.info("Installing legacy commands for Claude Code < 2.1.3")
+
         # Find commands directory using proper resource resolution
         try:
             from ...core.unified_paths import get_package_resource_path
@@ -650,9 +777,13 @@ main "$@"
                 old_script.unlink()
                 self.logger.info(f"Removed old deployed script: {old_script}")
 
-            # Remove from Claude settings (both old and new locations)
-            for settings_path in [self.settings_file, self.old_settings_file]:
-                if settings_path.exists():
+            # Remove from Claude settings
+            settings_paths = [self.settings_file]
+            if self.old_settings_file is not None:
+                settings_paths.append(self.old_settings_file)
+
+            for settings_path in settings_paths:
+                if settings_path and settings_path.exists():
                     with settings_path.open() as f:
                         settings = json.load(f)
 
@@ -759,11 +890,11 @@ main "$@"
                     if "hooks" in settings:
                         status["configured_events"] = list(settings["hooks"].keys())
                         configured_in_local = True
-            except Exception:
+            except Exception:  # nosec B110 - Intentional: ignore errors reading settings file
                 pass
 
         # Also check old settings file
-        if self.old_settings_file.exists():
+        if self.old_settings_file is not None and self.old_settings_file.exists():
             try:
                 with self.old_settings_file.open() as f:
                     old_settings = json.load(f)
@@ -773,7 +904,7 @@ main "$@"
                             status["warning"] = (
                                 "Hooks found in settings.local.json but Claude Code reads from settings.json"
                             )
-            except Exception:
+            except Exception:  # nosec B110 - Intentional: ignore errors reading old settings file
                 pass
 
         status["settings_location"] = (

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -5,8 +5,64 @@ This module provides utilities for integrating with the memory system,
 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)
+# but respects production install silence AND startup suppression
+try:
+    from claude_mpm.core.unified_paths import DeploymentContext, PathContext
+
+    context = PathContext.detect_deployment_context()
+
+    # CRITICAL: Check if root logger is already suppressed (CRITICAL+1 from startup.py)
+    # If so, don't call basicConfig as it will reset the level to INFO
+    root_logger = logging.getLogger()
+    is_suppressed = root_logger.level > logging.CRITICAL  # CRITICAL+1 = 51
+
+    # Only configure verbose logging for development/editable installs
+    # AND if logging isn't already suppressed by startup.py
+    if not is_suppressed and context in (
+        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
+            filename=str(log_file),
+        )
+except ImportError:
+    # Fallback: if unified_paths not available, check suppression before configuring
+    root_logger = logging.getLogger()
+    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,
+            filename=str(log_file),
+        )
 from datetime import datetime, timezone
 from typing import Optional
 
@@ -32,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
 
 
@@ -66,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
@@ -87,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(
@@ -143,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(
@@ -210,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,18 +8,25 @@ 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"
 
 # Response tracking integration
 # NOTE: ResponseTracker import moved to _initialize_response_tracking() for lazy loading
-# This prevents unnecessary import of base_agent_loader and other heavy dependencies
-# when hooks don't need response tracking
+# This prevents unnecessary import of heavy dependencies when hooks don't need response tracking
 RESPONSE_TRACKING_AVAILABLE = (
     True  # Assume available, will check on actual initialization
 )
@@ -51,7 +58,7 @@ class ResponseTrackingManager:
         response tracking without code changes.
 
         NOTE: ResponseTracker is imported lazily here to avoid loading
-        base_agent_loader and other heavy dependencies unless actually needed.
+        heavy dependencies unless actually needed.
         """
         try:
             # Lazy import of ResponseTracker to avoid unnecessary dependency loading
@@ -81,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
@@ -102,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(
@@ -131,12 +131,11 @@ class ResponseTrackingManager:
 
         try:
             # Get the original request data stored during pre-tool
-            request_info = delegation_requests.get(session_id)
+            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
 
@@ -164,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)
@@ -221,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
@@ -233,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(
@@ -247,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
@@ -262,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(
@@ -287,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
@@ -301,12 +290,11 @@ 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()
+                # which also handles auto-pause triggering (even when response tracking disabled)
                 if "usage" in event:
                     usage_data = event["usage"]
                     metadata["usage"] = {
@@ -323,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(
@@ -338,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."""
@@ -360,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
 
@@ -376,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
 
@@ -400,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
@@ -410,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}")