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

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

claude_mpm/cli/commands/configure_persistence.py

@@ -0,0 +1,254 @@
+"""Configuration persistence and version management for configure command.
+
+WHY: Separate configuration import/export and version display logic from main
+configure command to improve modularity. This handles all file I/O for
+configuration backups and version information display.
+
+DESIGN DECISIONS:
+- Export/import configuration as JSON for portability
+- Display version info for both MPM and Claude Code
+- Support interactive and non-interactive modes
+- Include validation for import operations
+"""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.box import ROUNDED
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+from ..shared import CommandResult
+
+
+class ConfigPersistence:
+    """Handle configuration import/export and version information display.
+
+    This class manages:
+    - Exporting configuration to JSON files
+    - Importing configuration from JSON files
+    - Displaying version information (MPM, Claude Code, Python)
+    - Both interactive and non-interactive display modes
+    """
+
+    def __init__(
+        self,
+        console: Console,
+        version_service,  # VersionService instance
+        agent_manager,  # SimpleAgentManager instance (can be None for version operations)
+        get_template_path_fn,  # Function to get template path
+        display_header_fn,  # Function to display header
+        current_scope: str,
+        project_dir: Path,
+    ):
+        """Initialize persistence handler.
+
+        Args:
+            console: Rich console for output
+            version_service: VersionService for version info
+            agent_manager: SimpleAgentManager for agent states (can be None for version operations)
+            get_template_path_fn: Function(agent_name) -> Path
+            display_header_fn: Function() -> None to display header
+            current_scope: Current configuration scope (project/user)
+            project_dir: Current project directory
+        """
+        self.console = console
+        self.version_service = version_service
+        self.agent_manager = agent_manager
+        self._get_agent_template_path = get_template_path_fn
+        self._display_header = display_header_fn
+        self.current_scope = current_scope
+        self.project_dir = project_dir
+
+    def export_config(self, file_path: str) -> CommandResult:
+        """Export configuration to a JSON file.
+
+        Exports:
+        - Current scope (project/user)
+        - Agent enabled/disabled states
+        - Template paths for each agent
+
+        Args:
+            file_path: Path to export configuration to
+
+        Returns:
+            CommandResult indicating success or failure
+        """
+        try:
+            # Gather all configuration
+            config_data = {"scope": self.current_scope, "agents": {}, "behaviors": {}}
+
+            # Get agent states
+            agents = self.agent_manager.discover_agents()
+            for agent in agents:
+                config_data["agents"][agent.name] = {
+                    "enabled": self.agent_manager.is_agent_enabled(agent.name),
+                    "template_path": str(self._get_agent_template_path(agent.name)),
+                }
+
+            # Write to file
+            output_path = Path(file_path)
+            with output_path.open("w") as f:
+                json.dump(config_data, f, indent=2)
+
+            return CommandResult.success_result(
+                f"Configuration exported to {output_path}"
+            )
+
+        except Exception as e:
+            return CommandResult.error_result(f"Failed to export configuration: {e}")
+
+    def import_config(self, file_path: str) -> CommandResult:
+        """Import configuration from a JSON file.
+
+        Imports and applies:
+        - Agent enabled/disabled states
+        - (Future: behavior configurations)
+
+        Args:
+            file_path: Path to import configuration from
+
+        Returns:
+            CommandResult indicating success or failure
+        """
+        try:
+            input_path = Path(file_path)
+            if not input_path.exists():
+                return CommandResult.error_result(f"File not found: {file_path}")
+
+            with input_path.open() as f:
+                config_data = json.load(f)
+
+            # Apply agent states
+            if "agents" in config_data:
+                for agent_name, agent_config in config_data["agents"].items():
+                    if "enabled" in agent_config:
+                        self.agent_manager.set_agent_enabled(
+                            agent_name, agent_config["enabled"]
+                        )
+
+            return CommandResult.success_result(
+                f"Configuration imported from {input_path}"
+            )
+
+        except Exception as e:
+            return CommandResult.error_result(f"Failed to import configuration: {e}")
+
+    def show_version_info(self) -> CommandResult:
+        """Show version information in non-interactive mode.
+
+        Displays:
+        - Claude MPM version and build number
+        - Claude Code version (if available)
+        - Python version
+
+        Returns:
+            CommandResult with version data
+        """
+        mpm_version = self.version_service.get_version()
+        build_number = self.version_service.get_build_number()
+
+        data = {
+            "mpm_version": mpm_version,
+            "build_number": build_number,
+            "python_version": sys.version.split()[0],
+        }
+
+        # Try to get Claude version
+        try:
+            result = subprocess.run(
+                ["claude", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0:
+                data["claude_version"] = result.stdout.strip()
+        except Exception:
+            data["claude_version"] = "Unknown"
+
+        # Print formatted output
+        self.console.print(
+            f"[bold]Claude MPM:[/bold] {mpm_version} (build {build_number})"
+        )
+        self.console.print(
+            f"[bold]Claude Code:[/bold] {data.get('claude_version', 'Unknown')}"
+        )
+        self.console.print(f"[bold]Python:[/bold] {data['python_version']}")
+
+        return CommandResult.success_result("Version information displayed", data=data)
+
+    def show_version_info_interactive(self) -> None:
+        """Show version information in interactive mode with panel display.
+
+        Displays comprehensive version information in a formatted panel:
+        - Claude MPM version and build number
+        - Claude Code version with compatibility info
+        - Python version
+        - Current configuration scope and directory
+        """
+        self.console.clear()
+        self._display_header()
+
+        # Get version information
+        mpm_version = self.version_service.get_version()
+        build_number = self.version_service.get_build_number()
+
+        # Try to get Claude Code version using the installer's method
+        claude_version = "Unknown"
+        try:
+            from ...hooks.claude_hooks.installer import HookInstaller
+
+            installer = HookInstaller()
+            detected_version = installer.get_claude_version()
+            if detected_version:
+                is_compatible, _ = installer.is_version_compatible()
+                claude_version = f"{detected_version} (Claude Code)"
+                if not is_compatible:
+                    claude_version += (
+                        f" - Monitoring requires {installer.MIN_CLAUDE_VERSION}+"
+                    )
+            else:
+                # Fallback to direct subprocess call
+                result = subprocess.run(
+                    ["claude", "--version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                    check=False,
+                )
+                if result.returncode == 0:
+                    claude_version = result.stdout.strip()
+        except Exception:
+            pass
+
+        # Create version panel
+        version_text = f"""
+[bold cyan]Claude MPM[/bold cyan]
+Version: {mpm_version}
+Build: {build_number}
+
+[bold cyan]Claude Code[/bold cyan]
+Version: {claude_version}
+
+[bold cyan]Python[/bold cyan]
+Version: {sys.version.split()[0]}
+
+[bold cyan]Configuration[/bold cyan]
+Scope: {self.current_scope}
+Directory: {self.project_dir}
+        """
+
+        panel = Panel(
+            version_text.strip(),
+            title="[bold]Version Information[/bold]",
+            box=ROUNDED,
+            style="green",
+        )
+
+        self.console.print(panel)
+        Prompt.ask("\nPress Enter to continue")