claude-mpm 4.16.0__py3-none-any.whl → 4.25.10__py3-none-any.whl

claude_mpm/cli/commands/hook_errors.py

@@ -0,0 +1,277 @@
+"""CLI commands for managing hook error memory.
+
+WHY this command is needed:
+- Users need visibility into what hooks are failing
+- Must be able to clear error memory to retry failed hooks
+- Provides diagnostics for troubleshooting
+- Makes error memory accessible without manual file editing
+"""
+
+import json
+from pathlib import Path
+
+import click
+
+from claude_mpm.core.hook_error_memory import get_hook_error_memory
+
+
+@click.group(name="hook-errors")
+def hook_errors_group():
+    """Manage hook error memory and diagnostics.
+
+    The hook error memory system tracks failing hooks to prevent
+    repeated execution of known-failing operations.
+    """
+
+
+@hook_errors_group.command(name="list")
+@click.option(
+    "--format",
+    type=click.Choice(["table", "json"], case_sensitive=False),
+    default="table",
+    help="Output format (table or json)",
+)
+@click.option(
+    "--hook-type",
+    help="Filter by hook type (e.g., PreToolUse, PostToolUse)",
+)
+def list_errors(format, hook_type):
+    """List all recorded hook errors.
+
+    Shows errors that have been detected during hook execution,
+    including failure counts and last seen timestamps.
+
+    Examples:
+        claude-mpm hook-errors list
+        claude-mpm hook-errors list --format json
+        claude-mpm hook-errors list --hook-type PreToolUse
+    """
+    error_memory = get_hook_error_memory()
+
+    # Filter errors if hook type specified
+    errors = error_memory.errors
+    if hook_type:
+        errors = {
+            key: data for key, data in errors.items() if data["hook_type"] == hook_type
+        }
+
+    if not errors:
+        if hook_type:
+            click.echo(f"No errors recorded for hook type: {hook_type}")
+        else:
+            click.echo("No errors recorded. Hook system is healthy! ✅")
+        return
+
+    if format == "json":
+        # JSON output
+        click.echo(json.dumps(errors, indent=2))
+    else:
+        # Table output
+        click.echo("\n" + "=" * 80)
+        click.echo("Hook Error Memory Report")
+        click.echo("=" * 80)
+
+        for key, data in errors.items():
+            click.echo(f"\n🔴 Error: {data['type']}")
+            click.echo(f"   Hook Type: {data['hook_type']}")
+            click.echo(f"   Details: {data['details']}")
+            click.echo(f"   Match: {data['match']}")
+            click.echo(f"   Count: {data['count']} occurrences")
+            click.echo(f"   First Seen: {data['first_seen']}")
+            click.echo(f"   Last Seen: {data['last_seen']}")
+
+        click.echo("\n" + "=" * 80)
+        click.echo(f"Total unique errors: {len(errors)}")
+        click.echo(f"Memory file: {error_memory.memory_file}")
+        click.echo("\nTo clear errors: claude-mpm hook-errors clear")
+
+
+@hook_errors_group.command(name="summary")
+def show_summary():
+    """Show summary statistics of hook errors.
+
+    Provides overview of error counts by type and hook type.
+
+    Example:
+        claude-mpm hook-errors summary
+    """
+    error_memory = get_hook_error_memory()
+    summary = error_memory.get_error_summary()
+
+    if summary["total_errors"] == 0:
+        click.echo("No errors recorded. Hook system is healthy! ✅")
+        return
+
+    click.echo("\n" + "=" * 80)
+    click.echo("Hook Error Summary")
+    click.echo("=" * 80)
+    click.echo("\n📊 Statistics:")
+    click.echo(f"   Total Errors: {summary['total_errors']}")
+    click.echo(f"   Unique Errors: {summary['unique_errors']}")
+
+    if summary["errors_by_type"]:
+        click.echo("\n🔍 Errors by Type:")
+        for error_type, count in summary["errors_by_type"].items():
+            click.echo(f"   {error_type}: {count}")
+
+    if summary["errors_by_hook"]:
+        click.echo("\n🎣 Errors by Hook Type:")
+        for hook_type, count in summary["errors_by_hook"].items():
+            click.echo(f"   {hook_type}: {count}")
+
+    click.echo(f"\n📁 Memory File: {summary['memory_file']}")
+    click.echo("\nFor detailed list: claude-mpm hook-errors list")
+
+
+@hook_errors_group.command(name="clear")
+@click.option(
+    "--hook-type",
+    help="Clear errors only for specific hook type",
+)
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    help="Skip confirmation prompt",
+)
+def clear_errors(hook_type, yes):
+    """Clear hook error memory to allow retry.
+
+    This removes error records, allowing previously failing hooks
+    to be executed again. Use this after fixing the underlying issue.
+
+    Examples:
+        claude-mpm hook-errors clear
+        claude-mpm hook-errors clear --hook-type PreToolUse
+        claude-mpm hook-errors clear -y  # Skip confirmation
+    """
+    error_memory = get_hook_error_memory()
+
+    # Count errors to be cleared
+    if hook_type:
+        count = sum(
+            1 for data in error_memory.errors.values() if data["hook_type"] == hook_type
+        )
+        scope = f"for hook type '{hook_type}'"
+    else:
+        count = len(error_memory.errors)
+        scope = "all hook types"
+
+    if count == 0:
+        click.echo(f"No errors to clear {scope}.")
+        return
+
+    # Confirm if not using -y flag
+    if not yes:
+        message = f"Clear {count} error(s) {scope}?"
+        if not click.confirm(message):
+            click.echo("Cancelled.")
+            return
+
+    # Clear errors
+    error_memory.clear_errors(hook_type)
+
+    click.echo(f"✅ Cleared {count} error(s) {scope}.")
+    click.echo("\nHooks will be retried on next execution.")
+
+
+@hook_errors_group.command(name="diagnose")
+@click.argument("hook_type", required=False)
+def diagnose_errors(hook_type):
+    """Diagnose hook errors and suggest fixes.
+
+    Provides detailed diagnostics and actionable suggestions for
+    resolving hook errors.
+
+    Arguments:
+        HOOK_TYPE: Optional hook type to diagnose (e.g., PreToolUse)
+
+    Examples:
+        claude-mpm hook-errors diagnose
+        claude-mpm hook-errors diagnose PreToolUse
+    """
+    error_memory = get_hook_error_memory()
+
+    # Filter errors if hook type specified
+    errors = error_memory.errors
+    if hook_type:
+        errors = {
+            key: data for key, data in errors.items() if data["hook_type"] == hook_type
+        }
+
+    if not errors:
+        if hook_type:
+            click.echo(f"No errors to diagnose for hook type: {hook_type}")
+        else:
+            click.echo("No errors to diagnose. Hook system is healthy! ✅")
+        return
+
+    click.echo("\n" + "=" * 80)
+    click.echo("Hook Error Diagnostics")
+    click.echo("=" * 80)
+
+    for key, data in errors.items():
+        click.echo(f"\n🔴 Error: {data['type']}")
+        click.echo(f"   Hook: {data['hook_type']}")
+        click.echo(f"   Count: {data['count']} failures")
+
+        # Generate and show fix suggestion
+        error_info = {
+            "type": data["type"],
+            "details": data["details"],
+            "match": data["match"],
+        }
+        suggestion = error_memory.suggest_fix(error_info)
+
+        click.echo("\n" + "-" * 80)
+        click.echo(suggestion)
+        click.echo("-" * 80)
+
+    click.echo("\n" + "=" * 80)
+    click.echo("After fixing issues, clear errors to retry:")
+    click.echo("  claude-mpm hook-errors clear")
+
+
+@hook_errors_group.command(name="status")
+def show_status():
+    """Show hook error memory status.
+
+    Quick overview of hook error system state.
+
+    Example:
+        claude-mpm hook-errors status
+    """
+    error_memory = get_hook_error_memory()
+    summary = error_memory.get_error_summary()
+
+    click.echo("\n📊 Hook Error Memory Status")
+    click.echo("=" * 80)
+
+    if summary["total_errors"] == 0:
+        click.echo("✅ Status: Healthy (no errors recorded)")
+    else:
+        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded")
+        click.echo(f"   Unique errors: {summary['unique_errors']}")
+
+        # Show which hooks are affected
+        if summary["errors_by_hook"]:
+            affected_hooks = list(summary["errors_by_hook"].keys())
+            click.echo(f"   Affected hooks: {', '.join(affected_hooks)}")
+
+    click.echo(f"\n📁 Memory file: {summary['memory_file']}")
+    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}")
+
+    click.echo("\nCommands:")
+    click.echo("  claude-mpm hook-errors list      # View detailed errors")
+    click.echo("  claude-mpm hook-errors diagnose  # Get fix suggestions")
+    click.echo("  claude-mpm hook-errors clear     # Clear and retry")
+
+
+# Register the command group
+def register_commands(cli):
+    """Register hook error commands with CLI.
+
+    Args:
+        cli: Click CLI group to register commands with
+    """
+    cli.add_command(hook_errors_group)

claude_mpm/cli/commands/mcp_install_commands.py

@@ -295,7 +295,7 @@ class MCPInstallCommands:
 
                     # Create backup
                     backup_path = config_path.with_suffix(
-                        f'.backup.{datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")}.json'
+                        f".backup.{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
                     )
                     try:
                         config_path.rename(backup_path)

claude_mpm/cli/commands/mcp_install_commands.py.backup

@@ -0,0 +1,284 @@
+"""MCP install command implementations.
+
+This module provides MCP installation and configuration commands.
+Extracted from mcp.py to reduce complexity and improve maintainability.
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+class MCPInstallCommands:
+    """Handles MCP install commands."""
+
+    def __init__(self, logger):
+        """Initialize the MCP install commands handler."""
+        self.logger = logger
+
+    def install_gateway(self, args):
+        """Install and configure MCP gateway.
+
+        WHY: This command installs the MCP package dependencies and configures
+        Claude Code to use the MCP gateway server directly via the CLI command.
+
+        DESIGN DECISION: We handle both package installation and configuration
+        in one command for user convenience, using the new direct CLI approach.
+        """
+        self.logger.info("MCP gateway installation command called")
+        print("📦 Installing and Configuring MCP Gateway")
+        print("=" * 50)
+
+        # Step 1: Install MCP package if needed
+        print("\n1️⃣  Checking MCP package installation...")
+        try:
+            import mcp
+            print("✅ MCP package already installed")
+        except ImportError:
+            print("📦 Installing MCP package...")
+            try:
+                subprocess.check_call([sys.executable, "-m", "pip", "install", "mcp"])
+                print("✅ MCP package installed successfully")
+            except subprocess.CalledProcessError as e:
+                print(f"❌ Error installing MCP package: {e}")
+                print("\nPlease install manually with: pip install mcp")
+                return 1
+
+        # Step 2: Configure Claude Code with the new CLI command
+        print("\n2️⃣  Configuring Claude Code...")
+        try:
+            success = self._configure_claude_desktop(args.force)
+            if success:
+                print("✅ Configuration completed successfully")
+                print("\n🎉 MCP Gateway is ready to use!")
+                print("\nNext steps:")
+                print("1. Restart Claude Code")
+                print("2. Test the server: claude-mpm mcp server --test")
+                print("3. Check status: claude-mpm mcp status")
+                return 0
+            else:
+                print("❌ Configuration failed")
+                return 1
+
+        except Exception as e:
+            print(f"❌ Error during configuration: {e}")
+            return 1
+
+    def _configure_claude_desktop(self, force=False):
+        """Configure Claude Code to use the MCP gateway via CLI command.
+
+        Args:
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            bool: True if configuration was successful
+        """
+        import json
+        import platform
+        from pathlib import Path
+        from datetime import datetime
+
+        # Determine Claude Code config path
+        config_path = self._get_claude_config_path()
+        if not config_path:
+            print("❌ Could not determine Claude Code configuration path")
+            return False
+
+        print(f"   Configuration path: {config_path}")
+
+        # Load existing configuration or create new one
+        config = self._load_or_create_config(config_path, force)
+        if config is None:
+            return False
+
+        # Configure the claude-mpm-gateway server using the CLI command
+        claude_mpm_path = self._find_claude_mpm_executable()
+        if not claude_mpm_path:
+            print("❌ Could not find claude-mpm executable")
+            return False
+
+        # Determine if we need to use -m claude_mpm or direct command
+        if claude_mpm_path.endswith(('python', 'python3', 'python.exe', 'python3.exe')):
+            # Using Python interpreter directly
+            mcp_config = {
+                "command": claude_mpm_path,
+                "args": ["-m", "claude_mpm", "mcp", "server"],
+                "env": {
+                    "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                    "MCP_MODE": "production"
+                }
+            }
+        else:
+            # Using installed claude-mpm command
+            mcp_config = {
+                "command": claude_mpm_path,
+                "args": ["mcp", "server"],
+                "env": {
+                    "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                    "MCP_MODE": "production"
+                }
+            }
+
+        # Update configuration
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        config["mcpServers"]["claude-mpm-gateway"] = mcp_config
+
+        print("\n✅ Configured claude-mpm-gateway server:")
+        print(f"   Command: {mcp_config['command']}")
+        print(f"   Args: {mcp_config['args']}")
+        print(f"   Environment variables: {list(mcp_config['env'].keys())}")
+
+        # Save configuration
+        return self._save_config(config, config_path)
+
+    def _get_claude_config_path(self):
+        """Get the Claude Code configuration file path.
+
+        Returns:
+            Path or None: Path to Claude Code config file
+        """
+        from pathlib import Path
+
+        # Claude Code uses ~/.claude/settings.local.json regardless of platform
+        return Path.home() / ".claude" / "settings.local.json"
+
+    def _find_claude_mpm_executable(self):
+        """Find the claude-mpm executable path.
+
+        WHY: We need to find the installed claude-mpm command to use as the
+        MCP server command. This ensures we're using the properly installed
+        version with all dependencies, not a raw Python script.
+
+        DESIGN DECISION: We prioritize in this order:
+        1. System-installed claude-mpm (most reliable)
+        2. Virtual environment claude-mpm (development)
+        3. Python module invocation (fallback)
+
+        Returns:
+            str or None: Path to claude-mpm executable
+        """
+        import shutil
+        import sys
+        import os
+
+        # 1. Try to find claude-mpm in PATH (system-wide or venv)
+        claude_mpm_path = shutil.which("claude-mpm")
+        if claude_mpm_path:
+            print(f"   Found claude-mpm: {claude_mpm_path}")
+            return claude_mpm_path
+
+        # 2. Check if we're in a virtual environment
+        if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+            # We're in a virtual environment
+            venv_bin = Path(sys.prefix) / ("Scripts" if sys.platform == "win32" else "bin")
+            venv_claude_mpm = venv_bin / "claude-mpm"
+            if venv_claude_mpm.exists():
+                print(f"   Found claude-mpm in venv: {venv_claude_mpm}")
+                return str(venv_claude_mpm)
+
+        # 3. Check if claude_mpm module is installed and use Python to run it
+        try:
+            import claude_mpm
+            # Return the Python executable - we'll handle the -m args separately
+            print(f"   Using Python module: {sys.executable} -m claude_mpm")
+            return sys.executable
+        except ImportError:
+            pass
+
+        # 4. Last resort: check project's local venv (development mode)
+        project_root = Path(__file__).parent.parent.parent.parent.parent
+        local_venv_bin = project_root / "venv" / ("Scripts" if sys.platform == "win32" else "bin")
+        local_claude_mpm = local_venv_bin / "claude-mpm"
+        if local_claude_mpm.exists():
+            print(f"   Found claude-mpm in project venv: {local_claude_mpm}")
+            return str(local_claude_mpm)
+
+        return None
+
+    def _load_or_create_config(self, config_path, force=False):
+        """Load existing configuration or create a new one.
+
+        Args:
+            config_path: Path to configuration file
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            dict or None: Configuration dictionary
+        """
+        import json
+        from datetime import datetime
+
+        config = {}
+
+        if config_path.exists():
+            if not force:
+                # Check if claude-mpm-gateway already exists
+                try:
+                    with open(config_path, 'r') as f:
+                        existing_config = json.load(f)
+
+                    if (existing_config.get("mcpServers", {}).get("claude-mpm-gateway") and
+                        not force):
+                        print("⚠️  claude-mpm-gateway is already configured")
+                        response = input("Do you want to overwrite it? (y/N): ").strip().lower()
+                        if response not in ['y', 'yes']:
+                            print("❌ Configuration cancelled")
+                            return None
+
+                    config = existing_config
+
+                except (json.JSONDecodeError, IOError) as e:
+                    print(f"⚠️  Error reading existing config: {e}")
+                    print("Creating backup and starting fresh...")
+
+                    # Create backup
+                    backup_path = config_path.with_suffix(f'.backup.{datetime.now().strftime("%Y%m%d_%H%M%S")}.json')
+                    try:
+                        config_path.rename(backup_path)
+                        print(f"   Backup created: {backup_path}")
+                    except Exception as backup_error:
+                        print(f"   Warning: Could not create backup: {backup_error}")
+            else:
+                # Force mode - create backup but proceed
+                try:
+                    with open(config_path, 'r') as f:
+                        existing_config = json.load(f)
+                    config = existing_config
+                    print("   Force mode: Overwriting existing configuration")
+                except:
+                    pass  # File doesn't exist or is invalid, start fresh
+
+        # Ensure mcpServers section exists
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        return config
+
+    def _save_config(self, config, config_path):
+        """Save configuration to file.
+
+        Args:
+            config: Configuration dictionary
+            config_path: Path to save configuration
+
+        Returns:
+            bool: True if successful
+        """
+        import json
+
+        try:
+            # Ensure directory exists
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write configuration with nice formatting
+            with open(config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+
+            print(f"\n✅ Configuration saved to {config_path}")
+            return True
+
+        except Exception as e:
+            print(f"❌ Error saving configuration: {e}")
+            return False