claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/cli/commands/configure_hook_manager.py

@@ -0,0 +1,225 @@
+"""Git hook installation and management for configure command.
+
+This module handles installation, verification, and removal of git hooks
+used by Claude MPM for automated workflows.
+
+Extracted from configure.py (Phase 7/9) to reduce God Object complexity.
+"""
+
+from rich.console import Console
+from rich.prompt import Confirm
+
+from ...utils.console import console as default_console
+from ..shared import CommandResult
+
+
+class HookManager:
+    """Manage git hook installation and verification.
+
+    Handles:
+    - Installing Claude Code integration hooks
+    - Verifying hook installation status
+    - Uninstalling hooks when requested
+    """
+
+    def __init__(self, console: Console = None):
+        """Initialize hook manager.
+
+        Args:
+            console: Rich console for output (optional, defaults to shared console)
+        """
+        self.console = console or default_console
+        self.logger = None  # Will be set from parent if needed
+
+    def install_hooks(self, force: bool = False) -> CommandResult:
+        """Install Claude MPM hooks for Claude Code integration.
+
+        Extracted from ConfigureCommand._install_hooks() (CC=11)
+
+        Args:
+            force: Force reinstallation even if hooks exist
+
+        Returns:
+            CommandResult with installation status
+        """
+        try:
+            from ...hooks.claude_hooks.installer import HookInstaller
+
+            installer = HookInstaller()
+
+            # Check Claude Code version compatibility first
+            is_compatible, version_message = installer.is_version_compatible()
+            self.console.print("[cyan]Checking Claude Code version...[/cyan]")
+            self.console.print(version_message)
+
+            if not is_compatible:
+                self.console.print(
+                    "\n[yellow]⚠ Hook monitoring is not available for your Claude Code version.[/yellow]"
+                )
+                self.console.print(
+                    "The dashboard and other features will work without real-time monitoring."
+                )
+                self.console.print(
+                    f"\n[dim]To enable monitoring, upgrade Claude Code to version {installer.MIN_CLAUDE_VERSION} or higher.[/dim]"
+                )
+                return CommandResult.success_result(
+                    "Version incompatible with hook monitoring",
+                    data={"compatible": False, "message": version_message},
+                )
+
+            # Check current status
+            status = installer.get_status()
+            if status["installed"] and not force:
+                self.console.print("[yellow]Hooks are already installed.[/yellow]")
+                self.console.print("Use --force to reinstall.")
+
+                if not status["valid"]:
+                    self.console.print("\n[red]However, there are issues:[/red]")
+                    for issue in status["issues"]:
+                        self.console.print(f"  - {issue}")
+
+                return CommandResult.success_result(
+                    "Hooks already installed", data=status
+                )
+
+            # Install hooks
+            self.console.print("[cyan]Installing Claude MPM hooks...[/cyan]")
+            success = installer.install_hooks(force=force)
+
+            if success:
+                self.console.print("[green]✓ Hooks installed successfully![/green]")
+                self.console.print("\nYou can now use /mpm commands in Claude Code:")
+                self.console.print("  /mpm         - Show help")
+                self.console.print("  /mpm status  - Show claude-mpm status")
+
+                # Verify installation
+                is_valid, issues = installer.verify_hooks()
+                if not is_valid:
+                    self.console.print(
+                        "\n[yellow]Warning: Installation completed but verification found issues:[/yellow]"
+                    )
+                    for issue in issues:
+                        self.console.print(f"  - {issue}")
+
+                return CommandResult.success_result("Hooks installed successfully")
+            self.console.print("[red]✗ Hook installation failed[/red]")
+            return CommandResult.error_result("Hook installation failed")
+
+        except ImportError:
+            self.console.print("[red]Error: HookInstaller module not found[/red]")
+            self.console.print("Please ensure claude-mpm is properly installed.")
+            return CommandResult.error_result("HookInstaller module not found")
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Hook installation error: {e}", exc_info=True)
+            return CommandResult.error_result(f"Hook installation failed: {e}")
+
+    def verify_hooks(self) -> CommandResult:
+        """Verify that Claude MPM hooks are properly installed.
+
+        Extracted from ConfigureCommand._verify_hooks() (CC=10)
+
+        Returns:
+            CommandResult with verification status
+        """
+        try:
+            from ...hooks.claude_hooks.installer import HookInstaller
+
+            installer = HookInstaller()
+            status = installer.get_status()
+
+            self.console.print("[bold]Hook Installation Status[/bold]\n")
+
+            # Show Claude Code version and compatibility
+            if status.get("claude_version"):
+                self.console.print(f"Claude Code Version: {status['claude_version']}")
+                if status.get("version_compatible"):
+                    self.console.print(
+                        "[green]✓[/green] Version compatible with hook monitoring"
+                    )
+                else:
+                    self.console.print(
+                        f"[yellow]⚠[/yellow] {status.get('version_message', 'Version incompatible')}"
+                    )
+                    self.console.print()
+            else:
+                self.console.print(
+                    "[yellow]Claude Code version could not be detected[/yellow]"
+                )
+            self.console.print()
+
+            if status["installed"]:
+                self.console.print(
+                    f"[green]✓[/green] Hooks installed at: {status['hook_script']}"
+                )
+            else:
+                self.console.print("[red]✗[/red] Hooks not installed")
+
+            if status["settings_file"]:
+                self.console.print(
+                    f"[green]✓[/green] Settings file: {status['settings_file']}"
+                )
+            else:
+                self.console.print("[red]✗[/red] Settings file not found")
+
+            if status.get("configured_events"):
+                self.console.print(
+                    f"[green]✓[/green] Configured events: {', '.join(status['configured_events'])}"
+                )
+            else:
+                self.console.print("[red]✗[/red] No events configured")
+
+            if status["valid"]:
+                self.console.print("\n[green]All checks passed![/green]")
+            else:
+                self.console.print("\n[red]Issues found:[/red]")
+                for issue in status["issues"]:
+                    self.console.print(f"  - {issue}")
+
+            return CommandResult.success_result(
+                "Hook verification complete", data=status
+            )
+
+        except ImportError:
+            self.console.print("[red]Error: HookInstaller module not found[/red]")
+            return CommandResult.error_result("HookInstaller module not found")
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Hook verification error: {e}", exc_info=True)
+            return CommandResult.error_result(f"Hook verification failed: {e}")
+
+    def uninstall_hooks(self) -> CommandResult:
+        """Uninstall Claude MPM hooks.
+
+        Extracted from ConfigureCommand._uninstall_hooks() (CC=5)
+
+        Returns:
+            CommandResult with uninstallation status
+        """
+        try:
+            from ...hooks.claude_hooks.installer import HookInstaller
+
+            installer = HookInstaller()
+
+            # Confirm uninstallation
+            if not Confirm.ask(
+                "[yellow]Are you sure you want to uninstall Claude MPM hooks?[/yellow]"
+            ):
+                return CommandResult.success_result("Uninstallation cancelled")
+
+            self.console.print("[cyan]Uninstalling Claude MPM hooks...[/cyan]")
+            success = installer.uninstall_hooks()
+
+            if success:
+                self.console.print("[green]✓ Hooks uninstalled successfully![/green]")
+                return CommandResult.success_result("Hooks uninstalled successfully")
+            self.console.print("[red]✗ Hook uninstallation failed[/red]")
+            return CommandResult.error_result("Hook uninstallation failed")
+
+        except ImportError:
+            self.console.print("[red]Error: HookInstaller module not found[/red]")
+            return CommandResult.error_result("HookInstaller module not found")
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Hook uninstallation error: {e}", exc_info=True)
+            return CommandResult.error_result(f"Hook uninstallation failed: {e}")

claude_mpm/cli/commands/configure_models.py

@@ -0,0 +1,18 @@
+"""Data models for configure command.
+
+This module contains data classes used by the configure command for
+agent metadata and configuration state management.
+"""
+
+from typing import List, Optional
+
+
+class AgentConfig:
+    """Simple agent configuration model."""
+
+    def __init__(
+        self, name: str, description: str = "", dependencies: Optional[List[str]] = None
+    ):
+        self.name = name
+        self.description = description
+        self.dependencies = dependencies or []

claude_mpm/cli/commands/configure_navigation.py

@@ -0,0 +1,184 @@
+"""Navigation and scope management for configure command.
+
+WHY: Separate navigation, scope switching, and menu display logic from main
+configure command to improve modularity. This handles the TUI interface
+elements that guide users through the configuration system.
+
+DESIGN DECISIONS:
+- Display header with version and scope info
+- Main menu with numbered options and descriptions
+- Scope switching between project and user configurations
+- Launch integration to transition to Claude MPM run
+"""
+
+import os
+from pathlib import Path
+
+import questionary
+from questionary import Style
+from rich.box import ROUNDED
+from rich.columns import Columns
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.text import Text
+
+
+class ConfigNavigation:
+    """Handle scope switching and navigation for configure command.
+
+    This class manages:
+    - Header display with version and scope information
+    - Main menu rendering with options
+    - Scope switching (project ↔ user)
+    - Claude MPM launch integration
+    """
+
+    # Questionary style matching Rich cyan theme
+    QUESTIONARY_STYLE = Style(
+        [
+            ("selected", "fg:cyan bold"),
+            ("pointer", "fg:cyan bold"),
+            ("highlighted", "fg:cyan"),
+            ("question", "fg:cyan bold"),
+        ]
+    )
+
+    def __init__(self, console: Console, project_dir: Path):
+        """Initialize navigation handler.
+
+        Args:
+            console: Rich console for output
+            project_dir: Current project directory
+        """
+        self.console = console
+        self.project_dir = project_dir
+        self.current_scope = "project"
+
+    def display_header(self) -> None:
+        """Display the TUI header with version and scope information.
+
+        Shows:
+        - Claude MPM branding and version
+        - Current configuration scope (project/user)
+        - Working directory
+        """
+        self.console.clear()
+
+        # Get version for display
+        from claude_mpm import __version__
+
+        # Create header panel
+        header_text = Text()
+        header_text.append("Claude MPM ", style="bold blue")
+        header_text.append("Configuration Interface", style="bold")
+        header_text.append(f"\nv{__version__}", style="dim blue")
+
+        scope_text = Text(f"Scope: {self.current_scope.upper()}", style="bold blue")
+        dir_text = Text(f"Directory: {self.project_dir}", style="dim")
+
+        header_content = Columns([header_text], align="center")
+        subtitle_content = f"{scope_text} | {dir_text}"
+
+        header_panel = Panel(
+            header_content,
+            subtitle=subtitle_content,
+            box=ROUNDED,
+            style="blue",
+            padding=(1, 2),
+        )
+
+        self.console.print(header_panel)
+        self.console.print()
+
+    def show_main_menu(self) -> str:
+        """Show the main menu and get user choice with arrow-key navigation.
+
+        Displays main configuration menu with options:
+        - Agent Management
+        - Skills Management
+        - Template Editing
+        - Behavior Files
+        - Startup Configuration
+        - Switch Scope
+        - Version Info
+        - Save & Launch
+        - Quit
+
+        Returns:
+            User's menu choice mapped to original key (1-7, l, q) for
+            backward compatibility with existing code
+        """
+        try:
+            choice = questionary.select(
+                "Main Menu:",
+                choices=[
+                    "Agent Management",
+                    "Skills Management",
+                    "Template Editing",
+                    "Behavior Files",
+                    "Startup Configuration",
+                    f"Switch Scope (Current: {self.current_scope})",
+                    "Version Info",
+                    questionary.Separator(),
+                    "Save & Launch Claude MPM",
+                    "Quit",
+                ],
+                style=self.QUESTIONARY_STYLE,
+            ).ask()
+
+            if choice is None:
+                return "q"
+
+            # Map natural language choices back to original key-based system
+            # for backward compatibility
+            choice_map = {
+                "Agent Management": "1",
+                "Skills Management": "2",
+                "Template Editing": "3",
+                "Behavior Files": "4",
+                "Startup Configuration": "5",
+                f"Switch Scope (Current: {self.current_scope})": "6",
+                "Version Info": "7",
+                "Save & Launch Claude MPM": "l",
+                "Quit": "q",
+            }
+
+            return choice_map.get(choice, "q")
+
+        except KeyboardInterrupt:
+            return "q"
+
+    def switch_scope(self) -> None:
+        """Switch between project and user scope.
+
+        Toggles current_scope between:
+        - "project": Project-level configuration (.claude-mpm in project dir)
+        - "user": User-level configuration (.claude-mpm in home dir)
+        """
+        self.current_scope = "user" if self.current_scope == "project" else "project"
+        self.console.print(f"[green]Switched to {self.current_scope} scope[/green]")
+        Prompt.ask("Press Enter to continue")
+
+    def launch_claude_mpm(self) -> None:
+        """Launch Claude MPM run command, replacing current process.
+
+        Uses os.execvp to replace the configure process with 'claude-mpm run',
+        providing a seamless transition from configuration to runtime.
+
+        If launch fails, displays instructions for manual launch.
+        """
+        self.console.print("\n[bold cyan]═══ Launching Claude MPM ═══[/bold cyan]\n")
+
+        try:
+            # Use execvp to replace the current process with claude-mpm run
+            # This ensures a clean transition from configurator to Claude MPM
+            os.execvp("claude-mpm", ["claude-mpm", "run"])
+        except Exception as e:
+            self.console.print(
+                f"[yellow]⚠ Could not launch Claude MPM automatically: {e}[/yellow]"
+            )
+            self.console.print(
+                "[cyan]→ Please run 'claude-mpm run' manually to start.[/cyan]"
+            )
+            Prompt.ask("\nPress Enter to exit")

claude_mpm/cli/commands/configure_paths.py

@@ -0,0 +1,104 @@
+"""Path resolution utilities for configure command.
+
+WHY: Centralizes path resolution logic for agent templates, configs, and system files.
+Separates file system concerns from business logic.
+
+DESIGN: Pure functions for path resolution without side effects (except mkdir).
+"""
+
+from pathlib import Path
+
+
+def get_agent_template_path(
+    agent_name: str,
+    scope: str,
+    project_dir: Path,
+    templates_dir: Path,
+) -> Path:
+    """Get the path to an agent's template file.
+
+    Args:
+        agent_name: Name of the agent
+        scope: Configuration scope ("project" or "user")
+        project_dir: Project directory path
+        templates_dir: System templates directory
+
+    Returns:
+        Path to the agent template file
+    """
+    # First check for custom template in project/user config
+    if scope == "project":
+        config_dir = project_dir / ".claude-mpm" / "agents"
+    else:
+        config_dir = Path.home() / ".claude-mpm" / "agents"
+
+    config_dir.mkdir(parents=True, exist_ok=True)
+    custom_template = config_dir / f"{agent_name}.json"
+
+    # If custom template exists, return it
+    if custom_template.exists():
+        return custom_template
+
+    # Otherwise, look for the system template
+    # Handle various naming conventions
+    possible_names = [
+        f"{agent_name}.json",
+        f"{agent_name.replace('-', '_')}.json",
+        f"{agent_name}-agent.json",
+        f"{agent_name.replace('-', '_')}_agent.json",
+    ]
+
+    for name in possible_names:
+        system_template = templates_dir / name
+        if system_template.exists():
+            return system_template
+
+    # Return the custom template path for new templates
+    return custom_template
+
+
+def get_config_directory(scope: str, project_dir: Path) -> Path:
+    """Get configuration directory based on scope.
+
+    Args:
+        scope: Configuration scope ("project" or "user")
+        project_dir: Project directory path
+
+    Returns:
+        Path to configuration directory
+    """
+    if scope == "project":
+        return project_dir / ".claude-mpm"
+    return Path.home() / ".claude-mpm"
+
+
+def get_agents_directory(scope: str, project_dir: Path) -> Path:
+    """Get agents directory based on scope.
+
+    Args:
+        scope: Configuration scope ("project" or "user")
+        project_dir: Project directory path
+
+    Returns:
+        Path to agents directory
+    """
+    config_dir = get_config_directory(scope, project_dir)
+    agents_dir = config_dir / "agents"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    return agents_dir
+
+
+def get_behaviors_directory(scope: str, project_dir: Path) -> Path:
+    """Get behaviors directory based on scope.
+
+    Args:
+        scope: Configuration scope ("project" or "user")
+        project_dir: Project directory path
+
+    Returns:
+        Path to behaviors directory
+    """
+    config_dir = get_config_directory(scope, project_dir)
+    behaviors_dir = config_dir / "behaviors"
+    behaviors_dir.mkdir(parents=True, exist_ok=True)
+    return behaviors_dir