claude-mpm 5.4.96__py3-none-any.whl → 5.6.3__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,10 +192,17 @@ 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)
@@ -220,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,
@@ -331,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.
 
@@ -556,7 +608,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
@@ -782,7 +849,7 @@ 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
@@ -796,7 +863,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

@@ -11,15 +11,23 @@ import sys
 
 # 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
+# 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
-    # Production installs remain silent by default
-    if context in (DeploymentContext.DEVELOPMENT, DeploymentContext.EDITABLE_INSTALL):
+    # AND if logging isn't already suppressed by startup.py
+    if not is_suppressed and context in (
+        DeploymentContext.DEVELOPMENT,
+        DeploymentContext.EDITABLE_INSTALL,
+    ):
         logging.basicConfig(
             level=logging.INFO,
             format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
@@ -27,14 +35,17 @@ try:
             stream=sys.stderr,
         )
 except ImportError:
-    # Fallback: if unified_paths not available, configure logging
-    # This maintains backward compatibility
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-        force=True,
-        stream=sys.stderr,
-    )
+    # 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:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            force=True,
+            stream=sys.stderr,
+        )
 from datetime import datetime, timezone
 from typing import Optional
 

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -7,9 +7,14 @@ This service manages:
 DESIGN DECISION: Use stateless HTTP POST instead of persistent SocketIO
 connections because hook handlers are ephemeral processes (< 1 second lifetime).
 This eliminates disconnection issues and matches the process lifecycle.
+
+DESIGN DECISION: Synchronous HTTP POST only (no async)
+Hook handlers are too short-lived (~25ms lifecycle) to benefit from async.
+Using asyncio.run() creates event loops that close before HTTP operations complete,
+causing "Event loop is closed" errors. Synchronous HTTP POST in a thread pool
+is simpler and more reliable for ephemeral processes.
 """
 
-import asyncio
 import os
 import sys
 from concurrent.futures import ThreadPoolExecutor
@@ -27,9 +32,6 @@ except ImportError:
     REQUESTS_AVAILABLE = False
     requests = None
 
-# Import high-performance event emitter - lazy loaded in _async_emit()
-# to reduce hook handler initialization time by ~85% (792ms -> minimal)
-
 # Import EventNormalizer for consistent event formatting
 try:
     from claude_mpm.services.socketio.event_normalizer import EventNormalizer
@@ -55,10 +57,6 @@ except ImportError:
             )
 
 
-# EventBus removed - using direct HTTP POST only
-# This eliminates duplicate events and simplifies the architecture
-
-
 class ConnectionManagerService:
     """Manages connections for the Claude hook handler using HTTP POST."""
 
@@ -72,17 +70,9 @@ class ConnectionManagerService:
         self.server_port = int(os.environ.get("CLAUDE_MPM_SERVER_PORT", "8765"))
         self.http_endpoint = f"http://{self.server_host}:{self.server_port}/api/events"
 
-        # EventBus removed - using direct HTTP POST only
-
-        # For backward compatibility with tests
-        self.connection_pool = None  # No longer used
-
-        # Track async emit tasks to prevent garbage collection
-        self._emit_tasks: set = set()
-
         # Thread pool for non-blocking HTTP requests
         # WHY: Prevents HTTP POST from blocking hook processing (2s timeout → 0ms blocking)
-        # max_workers=2: Sufficient for low-frequency HTTP fallback events
+        # max_workers=2: Sufficient for low-frequency hook events
         self._http_executor = ThreadPoolExecutor(
             max_workers=2, thread_name_prefix="http-emit"
         )
@@ -94,13 +84,13 @@ class ConnectionManagerService:
             )
 
     def emit_event(self, namespace: str, event: str, data: dict):
-        """Emit event using high-performance async emitter with HTTP fallback.
+        """Emit event using HTTP POST.
 
-        WHY Hybrid approach:
-        - Direct async calls for ultra-low latency in-process events
-        - HTTP POST fallback for cross-process communication
-        - Connection pooling for memory protection
-        - Automatic routing based on availability
+        WHY HTTP POST only:
+        - Hook handlers are ephemeral (~25ms lifecycle)
+        - Async emission causes "Event loop is closed" errors
+        - HTTP POST in thread pool is simpler and more reliable
+        - Completes in 20-50ms, which is acceptable for hook handlers
         """
         # Create event data for normalization
         raw_event = {
@@ -132,62 +122,9 @@ class ConnectionManagerService:
                     file=sys.stderr,
                 )
 
-        # Try high-performance async emitter first (direct calls)
-        success = self._try_async_emit(namespace, event, claude_event_data)
-        if success:
-            return
-
-        # Fallback to HTTP POST for cross-process communication
+        # Emit via HTTP POST (non-blocking, runs in thread pool)
         self._try_http_emit(namespace, event, claude_event_data)
 
-    def _try_async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Try to emit event using high-performance async emitter."""
-        try:
-            # Run async emission in the current event loop or create one
-            loop = None
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                # No running loop, create a new one
-                pass
-
-            if loop:
-                # We're in an async context, create a task with tracking
-                task = loop.create_task(self._async_emit(namespace, event, data))
-                self._emit_tasks.add(task)
-                task.add_done_callback(self._emit_tasks.discard)
-                # Don't wait for completion to maintain low latency
-                if DEBUG:
-                    print(f"✅ Async emit scheduled: {event}", file=sys.stderr)
-                return True
-            # No event loop, run synchronously
-            success = asyncio.run(self._async_emit(namespace, event, data))
-            if DEBUG and success:
-                print(f"✅ Async emit successful: {event}", file=sys.stderr)
-            return success
-
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emit failed: {e}", file=sys.stderr)
-            return False
-
-    async def _async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Async helper for event emission."""
-        try:
-            # Lazy load event emitter to reduce initialization overhead
-            from claude_mpm.services.monitor.event_emitter import get_event_emitter
-
-            emitter = await get_event_emitter()
-            return await emitter.emit_event(namespace, "claude_event", data)
-        except ImportError:
-            if DEBUG:
-                print("⚠️ Event emitter not available", file=sys.stderr)
-            return False
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emitter error: {e}", file=sys.stderr)
-            return False
-
     def _try_http_emit(self, namespace: str, event: str, data: dict):
         """Try to emit event using HTTP POST fallback (non-blocking).
 

claude_mpm/scripts/claude-hook-handler.sh

@@ -62,8 +62,13 @@ set -e
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # Determine the claude-mpm root based on installation type
+# Check if we're in a UV tools installation
+if [[ "$SCRIPT_DIR" == *"/.local/share/uv/tools/"* ]]; then
+    # UV tools installation - script is at lib/python*/site-packages/claude_mpm/scripts/
+    # The tool root is what we need for Python detection
+    CLAUDE_MPM_ROOT="$(echo "$SCRIPT_DIR" | sed 's|/lib/python.*/site-packages.*||')"
 # Check if we're in a pipx installation
-if [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
+elif [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
     # pipx installation - script is at lib/python*/site-packages/claude_mpm/scripts/
     # The venv root is what we need for Python detection
     CLAUDE_MPM_ROOT="$(echo "$SCRIPT_DIR" | sed 's|/lib/python.*/site-packages/.*||')"
@@ -89,11 +94,12 @@ fi
 # STRATEGY:
 # This function implements a fallback chain to find Python with claude-mpm dependencies:
 # 1. UV-managed projects (uv.lock detected) - uses "uv run python"
-# 2. pipx installations - uses pipx venv Python
-# 3. Project-specific virtual environments (venv, .venv)
-# 4. Currently active virtual environment ($VIRTUAL_ENV)
-# 5. System python3 (may lack dependencies)
-# 6. System python (last resort)
+# 2. UV tools installations (~/.local/share/uv/tools/) - uses tool's venv Python
+# 3. pipx installations - uses pipx venv Python
+# 4. Project-specific virtual environments (venv, .venv)
+# 5. Currently active virtual environment ($VIRTUAL_ENV)
+# 6. System python3 (may lack dependencies)
+# 7. System python (last resort)
 #
 # WHY THIS APPROACH:
 # - Claude MPM requires specific packages (socketio, eventlet) not in system Python
@@ -124,7 +130,21 @@ find_python_command() {
         fi
     fi
 
-    # 2. Check if we're in a pipx installation
+    # 2. Check if we're in a UV tools installation
+    if [[ "$SCRIPT_DIR" == *"/.local/share/uv/tools/"* ]]; then
+        # UV tools installation - extract the tool root directory
+        CLAUDE_MPM_ROOT="$(echo "$SCRIPT_DIR" | sed 's|/lib/python.*/site-packages.*||')"
+        local uv_python="$CLAUDE_MPM_ROOT/bin/python"
+        if [ -x "$uv_python" ]; then
+            if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
+                echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] UV tools Python found: $uv_python" >> /tmp/claude-mpm-hook.log
+            fi
+            echo "$uv_python"
+            return
+        fi
+    fi
+
+    # 3. Check if we're in a pipx installation
     if [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
         # pipx installation - use the pipx venv's Python directly
         if [ -f "$CLAUDE_MPM_ROOT/bin/python" ]; then
@@ -133,7 +153,7 @@ find_python_command() {
         fi
     fi
 
-    # 3. Check for project-local virtual environment (common in development)
+    # 4. Check for project-local virtual environment (common in development)
     if [ -f "$CLAUDE_MPM_ROOT/venv/bin/activate" ]; then
         source "$CLAUDE_MPM_ROOT/venv/bin/activate"
         echo "$CLAUDE_MPM_ROOT/venv/bin/python"
@@ -154,7 +174,13 @@ find_python_command() {
 PYTHON_CMD=$(find_python_command)
 
 # Check installation type and set PYTHONPATH accordingly
-if [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
+if [[ "$SCRIPT_DIR" == *"/.local/share/uv/tools/"* ]]; then
+    # UV tools installation - claude_mpm is already in the tool's site-packages
+    # No need to modify PYTHONPATH
+    if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
+        echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] UV tools installation detected" >> /tmp/claude-mpm-hook.log
+    fi
+elif [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
     # pipx installation - claude_mpm is already in the venv's site-packages
     # No need to modify PYTHONPATH
     if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
@@ -210,10 +236,11 @@ fi
 # Run the Python hook handler with all input
 # Use exec to replace the shell process with Python
 # Handle UV's multi-word command specially
+# Suppress RuntimeWarning to prevent stderr output (which causes hook errors)
 if [[ "$PYTHON_CMD" == "uv run python" ]]; then
-    exec uv run python -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log
+    exec uv run python -W ignore::RuntimeWarning -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log
 else
-    exec "$PYTHON_CMD" -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log
+    exec "$PYTHON_CMD" -W ignore::RuntimeWarning -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log
 fi
 
 # Note: exec replaces the shell process, so code below only runs if exec fails
@@ -224,4 +251,4 @@ if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
 fi
 # Return continue action to prevent blocking Claude Code
 echo '{"action": "continue"}'
-exit 0
+exit 0

claude_mpm/services/agents/agent_recommendation_service.py

@@ -30,16 +30,16 @@ class AgentRecommendationService:
     Can be used by CLI, API, or future auto-configuration features.
     """
 
-    # Core agents always included - matches ToolchainDetector.CORE_AGENTS
+    # Core agents always included - Standard 6 core agents for essential PM workflow
+    # These agents are auto-deployed when no configuration exists
     # Uses exact agent IDs from repository for consistency
     CORE_AGENTS = {
-        "engineer",
-        "qa-agent",
-        "memory-manager-agent",
-        "local-ops-agent",
-        "research-agent",
-        "documentation-agent",
-        "security-agent",
+        "engineer",  # General-purpose implementation
+        "research",  # Codebase exploration and analysis
+        "qa",  # Testing and quality assurance
+        "documentation",  # Documentation generation
+        "ops",  # Basic deployment operations
+        "ticketing",  # Ticket tracking (essential for PM workflow)
     }
 
     # Map detected languages to recommended engineer agents

claude_mpm/services/agents/loading/framework_agent_loader.py

@@ -10,10 +10,19 @@ Loading precedence: Project → User → System
 
 This service integrates with the main agent_loader.py to provide
 markdown-based agent profiles alongside JSON-based templates.
+
+Auto-Deployment: When no agents are configured, the standard 6 core agents
+are automatically deployed:
+- engineer: General-purpose implementation
+- research: Codebase exploration and analysis
+- qa: Testing and quality assurance
+- documentation: Documentation generation
+- ops: Basic deployment operations
+- ticketing: Ticket tracking (essential for PM workflow)
 """
 
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.agents.agent_loader import AgentTier, list_agents_by_tier
 from claude_mpm.core.logging_utils import get_logger
@@ -21,6 +30,17 @@ from claude_mpm.core.unified_paths import get_path_manager
 
 logger = get_logger(__name__)
 
+# Standard 6 core agents that are auto-deployed when no agents are specified
+# This list is the canonical source - other modules should import from here
+CORE_AGENTS: List[str] = [
+    "engineer",  # General-purpose implementation
+    "research",  # Codebase exploration and analysis
+    "qa",  # Testing and quality assurance
+    "documentation",  # Documentation generation
+    "ops",  # Basic deployment operations
+    "ticketing",  # Ticket tracking (essential for PM workflow)
+]
+
 
 class FrameworkAgentLoader:
     """Loads agent profiles from project, user, and system directories with proper precedence"""
@@ -86,7 +106,7 @@ class FrameworkAgentLoader:
                 data_claude = package_path / "data" / "agents" / "CLAUDE.md"
                 if data_instructions.exists() or data_claude.exists():
                     return package_path / "data"
-        except Exception:
+        except Exception:  # nosec B110 - intentional fallthrough to next location
             pass
 
         current = Path.cwd()
@@ -431,3 +451,56 @@ Please operate according to your profile specifications and maintain quality sta
 """
 
         return instruction.strip()
+
+    def get_core_agents(self) -> List[str]:
+        """
+        Get the standard 6 core agents for auto-deployment.
+
+        These agents are automatically deployed when no agents are specified
+        in the configuration. They provide essential PM workflow functionality.
+
+        Returns:
+            List of core agent IDs
+
+        Example:
+            >>> loader = FrameworkAgentLoader()
+            >>> core = loader.get_core_agents()
+            >>> 'engineer' in core
+            True
+            >>> len(core)
+            6
+        """
+        return CORE_AGENTS.copy()
+
+    def get_agents_with_fallback(self) -> Dict[str, list]:
+        """
+        Get available agents, falling back to core agents if none found.
+
+        This method implements the auto-deployment logic: when no agents
+        are found in any tier (project, user, system), it returns the
+        standard 6 core agents as a fallback.
+
+        Returns:
+            Dictionary with agent lists by tier. If no agents found in any tier,
+            returns core agents under 'fallback' key.
+
+        Example:
+            >>> loader = FrameworkAgentLoader()
+            >>> loader.initialize()
+            >>> agents = loader.get_agents_with_fallback()
+            >>> if 'fallback' in agents:
+            ...     print("Using core agents as fallback")
+        """
+        available = self.get_available_agents()
+
+        # Check if any agents are found
+        total_agents = sum(len(agents) for agents in available.values())
+
+        if total_agents == 0:
+            logger.info(
+                "No agents found in configuration. "
+                "Auto-deploying standard 6 core agents."
+            )
+            return {"fallback": CORE_AGENTS.copy()}
+
+        return available

claude_mpm/services/event_log.py

@@ -310,8 +310,16 @@ def get_event_log(log_file: Optional[Path] = None) -> EventLog:
 
     Returns:
         EventLog instance
+
+    Note:
+        If log_file is provided and differs from the current instance,
+        a new EventLog is created and replaces the global instance.
+        This allows hooks to use project-specific event logs.
     """
     global _event_log
     if _event_log is None:
         _event_log = EventLog(log_file)
+    elif log_file is not None and _event_log.log_file != log_file:
+        # Create new instance if log file differs from current
+        _event_log = EventLog(log_file)
     return _event_log