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

claude_mpm/services/command_deployment_service.py

@@ -1,10 +1,14 @@
-"""Service for deploying MPM slash commands to user's Claude configuration.
+"""Service for managing MPM slash commands in user's Claude configuration.
 
-This service handles:
-1. Copying command markdown files from source to user's ~/.claude/commands directory
-2. Creating the commands directory if it doesn't exist
-3. Overwriting existing commands to ensure they're up-to-date
-4. Parsing and validating YAML frontmatter for namespace metadata (Phase 1 - 1M-400)
+DEPRECATED: User-level commands in ~/.claude/commands/ are deprecated.
+Project-level skills (.claude/skills/) are now the only source for commands.
+
+This service now only handles:
+1. Cleanup of deprecated commands from previous versions
+2. Cleanup of stale commands that no longer exist in source
+3. Parsing and validating YAML frontmatter (for internal use)
+
+New command deployment is intentionally disabled - see deploy_commands_on_startup().
 """
 
 from pathlib import Path
@@ -17,20 +21,34 @@ from claude_mpm.core.logger import get_logger
 
 
 class CommandDeploymentService(BaseService):
-    """Service for deploying MPM slash commands."""
+    """Service for managing MPM slash commands (cleanup only - deployment deprecated)."""
 
-    # Deprecated commands that have been replaced (cleanup on startup)
+    # Deprecated commands that should be removed from ~/.claude/commands/
+    # ALL user-level commands are now deprecated - project-level skills are the only source
     DEPRECATED_COMMANDS = [
+        # Legacy deprecated commands (historical)
         "mpm-agents.md",  # Replaced by mpm-agents-list.md
         "mpm-auto-configure.md",  # Replaced by mpm-agents-auto-configure.md
         "mpm-config-view.md",  # Replaced by mpm-config.md
         "mpm-resume.md",  # Replaced by mpm-session-resume.md
         "mpm-ticket.md",  # Replaced by mpm-ticket-view.md
-        # Removed - consolidated into /mpm-configure
         "mpm-agents-list.md",  # Consolidated into /mpm-configure
         "mpm-agents-detect.md",  # Consolidated into /mpm-configure
         "mpm-agents-auto-configure.md",  # Consolidated into /mpm-configure
         "mpm-agents-recommend.md",  # Consolidated into /mpm-configure
+        # ALL user-level commands are now deprecated (use project-level skills)
+        "mpm.md",
+        "mpm-config.md",
+        "mpm-doctor.md",
+        "mpm-help.md",
+        "mpm-init.md",
+        "mpm-monitor.md",
+        "mpm-organize.md",
+        "mpm-postmortem.md",
+        "mpm-session-resume.md",
+        "mpm-status.md",
+        "mpm-ticket-view.md",
+        "mpm-version.md",
     ]
 
     def __init__(self):
@@ -414,33 +432,33 @@ class CommandDeploymentService(BaseService):
 def deploy_commands_on_startup(force: bool = False) -> None:
     """Convenience function to deploy commands during startup.
 
-    This function:
-    1. Removes deprecated commands that have been replaced
-    2. Removes stale commands that no longer exist in source
-    3. Deploys current command files
+    DEPRECATED: User-level commands in ~/.claude/commands/ are deprecated.
+    Project-level skills should be the only source for commands.
+
+    This function now only cleans up any existing deprecated/stale commands
+    without deploying new ones.
 
     Args:
-        force: Force deployment even if files exist
+        force: Force deployment even if files exist (ignored - deployment disabled)
     """
-    service = CommandDeploymentService()
     logger = get_logger("startup")
+    logger.debug(
+        "User-level command deployment is deprecated - "
+        "project-level skills are the only command source"
+    )
 
-    # Clean up deprecated commands FIRST (known old commands)
+    # Still clean up any lingering deprecated/stale commands from previous versions
+    service = CommandDeploymentService()
+
+    # Clean up deprecated commands
     deprecated_count = service.remove_deprecated_commands()
     if deprecated_count > 0:
         logger.info(f"Cleaned up {deprecated_count} deprecated command(s)")
 
-    # Clean up stale commands SECOND (deployed but not in source anymore)
+    # Clean up stale commands
     stale_count = service.remove_stale_commands()
     if stale_count > 0:
         logger.info(f"Cleaned up {stale_count} stale command(s)")
 
-    # Deploy current commands LAST
-    result = service.deploy_commands(force=force)
-
-    if result["deployed"]:
-        logger.info(f"MPM commands deployed: {', '.join(result['deployed'])}")
-
-    if result["errors"]:
-        for error in result["errors"]:
-            logger.warning(f"Command deployment issue: {error}")
+    # NOTE: Deployment of new commands is intentionally disabled.
+    # Project-level skills (.claude/skills/) are the only source for commands.

claude_mpm/services/hook_installer_service.py

@@ -20,8 +20,13 @@ class HookInstallerService:
     def __init__(self):
         """Initialize the hook installer service."""
         self.logger = get_logger(__name__)
-        self.claude_dir = Path.home() / ".claude"
-        self.settings_file = self.claude_dir / "settings.json"
+        # Use project-level paths, NEVER global ~/.claude/settings.json
+        # This ensures hooks are scoped to the current project only
+        self.project_root = Path.cwd()
+        self.claude_dir = self.project_root / ".claude"
+        # Use settings.local.json for project-level hook settings
+        # Claude Code reads project-level settings from .claude/settings.local.json
+        self.settings_file = self.claude_dir / "settings.local.json"
 
     def is_hooks_configured(self) -> bool:
         """Check if hooks are configured in Claude settings.
@@ -299,16 +304,77 @@ class HookInstallerService:
                 self.logger.debug("Creating new Claude settings")
 
             # Configure hooks
-            hook_config = {
-                "matcher": "*",
-                "hooks": [{"type": "command", "command": hook_script_path}],
-            }
+            new_hook_command = {"type": "command", "command": hook_script_path}
 
             # Update settings
             if "hooks" not in settings:
                 settings["hooks"] = {}
 
-            # Add hooks for all event types
+            def is_our_hook(cmd: Dict[str, Any]) -> bool:
+                """Check if a hook command belongs to claude-mpm."""
+                if cmd.get("type") != "command":
+                    return False
+                command = cmd.get("command", "")
+                return (
+                    "hook_wrapper.sh" in command
+                    or "claude-hook-handler.sh" in command
+                    or "claude-mpm" in command
+                )
+
+            def merge_hooks_for_event(
+                existing_hooks: list, hook_command: Dict[str, Any]
+            ) -> list:
+                """Merge new hook command into existing hooks without duplication.
+
+                Args:
+                    existing_hooks: Current hooks configuration for an event type
+                    hook_command: The claude-mpm hook command to add
+
+                Returns:
+                    Updated hooks list with our hook merged in
+                """
+                # Check if our hook already exists in any existing hook config
+                our_hook_exists = False
+
+                for hook_config in existing_hooks:
+                    if "hooks" in hook_config and isinstance(
+                        hook_config["hooks"], list
+                    ):
+                        for hook in hook_config["hooks"]:
+                            if is_our_hook(hook):
+                                # Update existing hook command path (in case it changed)
+                                hook["command"] = hook_command["command"]
+                                our_hook_exists = True
+                                break
+                    if our_hook_exists:
+                        break
+
+                if our_hook_exists:
+                    # Our hook already exists, just return the updated list
+                    return existing_hooks
+
+                # Our hook doesn't exist - need to add it
+                # Strategy: Add our hook to the first "*" matcher config, or create new
+                added = False
+
+                for hook_config in existing_hooks:
+                    # Check if this config has matcher: "*"
+                    if hook_config.get("matcher") == "*":
+                        # Add our hook to this config's hooks array
+                        if "hooks" not in hook_config:
+                            hook_config["hooks"] = []
+                        hook_config["hooks"].append(hook_command)
+                        added = True
+                        break
+
+                if not added:
+                    # No suitable config found, create a new one
+                    new_config = {"matcher": "*", "hooks": [hook_command]}
+                    existing_hooks.append(new_config)
+
+                return existing_hooks
+
+            # Add hooks for all event types - MERGE instead of overwrite
             for event_type in [
                 "UserPromptSubmit",
                 "PreToolUse",
@@ -316,7 +382,10 @@ class HookInstallerService:
                 "Stop",
                 "SubagentStop",
             ]:
-                settings["hooks"][event_type] = [hook_config]
+                existing = settings["hooks"].get(event_type, [])
+                settings["hooks"][event_type] = merge_hooks_for_event(
+                    existing, new_hook_command
+                )
 
             # Write settings
             with self.settings_file.open("w") as f:

claude_mpm/services/mcp_config_manager.py

@@ -10,7 +10,7 @@ MCP service installations.
 """
 
 import json
-import subprocess
+import subprocess  # nosec B404 - Required for MCP service management
 import sys
 from enum import Enum
 from pathlib import Path
@@ -150,6 +150,86 @@ class MCPConfigManager:
 
         return is_enabled
 
+    def get_registry_service_config(
+        self, service_name: str, env_overrides: Optional[Dict[str, str]] = None
+    ) -> Optional[Dict]:
+        """
+        Get configuration for a service from the MCP Service Registry.
+
+        Args:
+            service_name: Name of the service
+            env_overrides: Optional environment variable overrides
+
+        Returns:
+            Service configuration dict or None if service not in registry
+        """
+        try:
+            from .mcp_service_registry import MCPServiceRegistry
+
+            service = MCPServiceRegistry.get(service_name)
+            if not service:
+                return None
+
+            return MCPServiceRegistry.generate_config(service, env_overrides)
+        except ImportError:
+            self.logger.debug("MCP Service Registry not available")
+            return None
+
+    def filter_services_by_mcp_flag(
+        self, mcp_flag: Optional[str], all_services: Dict[str, Dict]
+    ) -> Dict[str, Dict]:
+        """
+        Filter MCP services based on the --mcp command line flag.
+
+        Args:
+            mcp_flag: Comma-separated list of service names, or None for all
+            all_services: Dict of all available service configurations
+
+        Returns:
+            Filtered dict of service configurations
+        """
+        if not mcp_flag:
+            return all_services
+
+        # Parse comma-separated service names
+        requested_services = {s.strip() for s in mcp_flag.split(",") if s.strip()}
+
+        # Filter services
+        filtered = {}
+        for name, config in all_services.items():
+            if name in requested_services:
+                filtered[name] = config
+            else:
+                self.logger.debug(f"MCP service '{name}' excluded by --mcp flag")
+
+        # Warn about requested services that don't exist
+        available = set(all_services.keys())
+        missing = requested_services - available
+        if missing:
+            self.logger.warning(
+                f"Requested MCP services not available: {', '.join(missing)}"
+            )
+
+        return filtered
+
+    def list_available_services(self) -> list[str]:
+        """
+        List all available MCP services from registry and static configs.
+
+        Returns:
+            List of service names
+        """
+        services = set(self.STATIC_MCP_CONFIGS.keys())
+
+        try:
+            from .mcp_service_registry import MCPServiceRegistry
+
+            services.update(MCPServiceRegistry.list_names())
+        except ImportError:
+            pass
+
+        return sorted(services)
+
     def detect_service_path(self, service_name: str) -> Optional[str]:
         """
         Detect the best path for an MCP service.
@@ -185,7 +265,7 @@ class MCPConfigManager:
             # Choose the best candidate (prefer v1.1.0+ with MCP support)
             for path in candidates:
                 try:
-                    result = subprocess.run(
+                    result = subprocess.run(  # nosec B603 B607 - Controlled service help check
                         [path, "--help"],
                         capture_output=True,
                         text=True,
@@ -258,7 +338,7 @@ class MCPConfigManager:
     def _check_system_path(self, service_name: str) -> Optional[str]:
         """Check if service is available in system PATH."""
         try:
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607 - Controlled which command
                 ["which", service_name],
                 capture_output=True,
                 text=True,
@@ -356,7 +436,7 @@ class MCPConfigManager:
                 cmd.append("--help")
 
             # Run test command with timeout
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 - Controlled service test command
                 cmd,
                 capture_output=True,
                 text=True,
@@ -560,7 +640,7 @@ class MCPConfigManager:
         # Try pipx run test
         if shutil.which("pipx"):
             try:
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 B607 - Controlled pipx run command
                     ["pipx", "run", service_name, "--version"],
                     capture_output=True,
                     text=True,
@@ -576,7 +656,7 @@ class MCPConfigManager:
         # Try uvx if pipx run not available
         if not use_pipx_run and shutil.which("uvx"):
             try:
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 B607 - Controlled uvx command
                     ["uvx", service_name, "--version"],
                     capture_output=True,
                     text=True,
@@ -876,7 +956,7 @@ class MCPConfigManager:
                             command_path = service_config.get("command", "")
                             results[service_name] = Path(command_path).exists()
                         return results
-                except Exception:
+                except Exception:  # nosec B110 - Graceful fallback to empty dict
                     pass
             return {}
 
@@ -946,7 +1026,7 @@ class MCPConfigManager:
         if shutil.which("pipx"):
             try:
                 self.logger.debug(f"Attempting to install {service_name} via pipx...")
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 B607 - Controlled pipx install
                     ["pipx", "install", service_name],
                     capture_output=True,
                     text=True,
@@ -980,7 +1060,7 @@ class MCPConfigManager:
         if shutil.which("uvx"):
             try:
                 self.logger.debug(f"Attempting to install {service_name} via uvx...")
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 B607 - Controlled uvx install
                     ["uvx", "install", service_name],
                     capture_output=True,
                     text=True,
@@ -997,7 +1077,7 @@ class MCPConfigManager:
         # Method 3: Try pip install --user
         try:
             self.logger.debug(f"Attempting to install {service_name} via pip --user...")
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607 - Controlled pip install
                 [sys.executable, "-m", "pip", "install", "--user", service_name],
                 capture_output=True,
                 text=True,
@@ -1093,7 +1173,7 @@ class MCPConfigManager:
                 self.logger.debug(
                     f"    Testing {service_name} from installed pipx venv: {pipx_venv_bin}"
                 )
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 - Controlled service help check
                     [str(pipx_venv_bin), "--help"],
                     capture_output=True,
                     text=True,
@@ -1145,7 +1225,7 @@ class MCPConfigManager:
             self.logger.debug(
                 f"    Testing {service_name} via pipx run (not installed in venv)"
             )
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607 - Controlled pipx run command
                 ["pipx", "run", service_name, "--help"],
                 capture_output=True,
                 text=True,
@@ -1216,7 +1296,7 @@ class MCPConfigManager:
             self.logger.debug(f"Uninstalling {service_name}...")
 
             # First uninstall the corrupted version
-            uninstall_result = subprocess.run(
+            uninstall_result = subprocess.run(  # nosec B603 B607 - Controlled pipx uninstall
                 ["pipx", "uninstall", service_name],
                 capture_output=True,
                 text=True,
@@ -1229,7 +1309,7 @@ class MCPConfigManager:
 
             # Now reinstall
             self.logger.debug(f"Installing fresh {service_name}...")
-            install_result = subprocess.run(
+            install_result = subprocess.run(  # nosec B603 B607 - Controlled pipx install
                 ["pipx", "install", service_name],
                 capture_output=True,
                 text=True,
@@ -1294,7 +1374,7 @@ class MCPConfigManager:
         for dep in missing_deps:
             try:
                 self.logger.debug(f"    Injecting {dep} into {service_name}...")
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 B607 - Controlled pipx inject
                     ["pipx", "inject", service_name, dep],
                     capture_output=True,
                     text=True,
@@ -1348,7 +1428,7 @@ class MCPConfigManager:
                 return False
 
             self.logger.info(f"  → Uninstalling {service_name}...")
-            uninstall_result = subprocess.run(
+            uninstall_result = subprocess.run(  # nosec B603 B607 - Controlled pipx uninstall
                 ["pipx", "uninstall", service_name],
                 capture_output=True,
                 text=True,
@@ -1363,7 +1443,7 @@ class MCPConfigManager:
                 )
 
             self.logger.info(f"  → Installing fresh {service_name}...")
-            install_result = subprocess.run(
+            install_result = subprocess.run(  # nosec B603 B607 - Controlled pipx install
                 ["pipx", "install", service_name],
                 capture_output=True,
                 text=True,
@@ -1439,7 +1519,7 @@ class MCPConfigManager:
             # Try pipx run as fallback for pipx installations
             if method == "pipx":
                 try:
-                    result = subprocess.run(
+                    result = subprocess.run(  # nosec B603 B607 - Controlled pipx command
                         ["pipx", "run", service_name, "--version"],
                         capture_output=True,
                         text=True,
@@ -1462,7 +1542,7 @@ class MCPConfigManager:
             ]
 
             for cmd in test_commands:
-                result = subprocess.run(
+                result = subprocess.run(  # nosec B603 - Controlled service verification
                     cmd,
                     capture_output=True,
                     text=True,