claude-mpm 4.13.2__py3-none-any.whl → 4.18.2__py3-none-any.whl

claude_mpm/cli/commands/configure_agent_display.py

@@ -0,0 +1,261 @@
+"""Agent display and table rendering for configure command.
+
+WHY: Separate agent display logic from main configure command to improve
+modularity and reduce complexity. Agent display includes table rendering,
+status indicators, and detailed agent information views.
+
+DESIGN DECISIONS:
+- Use Rich library for modern table formatting
+- Support pending state visualization (enable/disable arrows)
+- Show truncated descriptions in tables, full details in views
+- Display template metadata when available
+"""
+
+import json
+from typing import List
+
+from rich.box import ROUNDED
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+
+from .configure_models import AgentConfig
+
+
+class AgentDisplay:
+    """Handle agent display and table rendering.
+
+    This class manages the visual presentation of agents in various formats:
+    - Summary tables with status indicators
+    - Pending state visualization with arrows
+    - Detailed agent information panels
+    """
+
+    def __init__(
+        self,
+        console: Console,
+        agent_manager,  # SimpleAgentManager instance
+        get_template_path_fn,  # Function to get template path for an agent
+        display_header_fn,  # Function to display configure header
+    ):
+        """Initialize agent display handler.
+
+        Args:
+            console: Rich console for output
+            agent_manager: SimpleAgentManager instance for state queries
+            get_template_path_fn: Function(agent_name) -> Path to get template path
+            display_header_fn: Function() -> None to display configure header
+        """
+        self.console = console
+        self.agent_manager = agent_manager
+        self._get_agent_template_path = get_template_path_fn
+        self._display_header = display_header_fn
+
+    def display_agents_table(self, agents: List[AgentConfig]) -> None:
+        """Display a table of available agents with status and metadata.
+
+        Shows:
+        - Agent ID (for selection)
+        - Name and description
+        - Enable/disable status
+        - Model or tools information
+
+        Args:
+            agents: List of agent configurations to display
+        """
+        table = Table(
+            title=f"Available Agents ({len(agents)} total)",
+            box=ROUNDED,
+            show_lines=True,
+        )
+
+        table.add_column("ID", style="dim", width=3)
+        table.add_column("Name", style="bold blue", width=22)
+        table.add_column("Status", width=12)
+        table.add_column("Description", style="bold", width=45)
+        table.add_column("Model/Tools", style="dim", width=20)
+
+        for idx, agent in enumerate(agents, 1):
+            # Check if agent is enabled
+            is_enabled = self.agent_manager.is_agent_enabled(agent.name)
+            status = (
+                "[green]✓ Enabled[/green]" if is_enabled else "[red]✗ Disabled[/red]"
+            )
+
+            # Format tools/dependencies - show first 2 tools
+            tools_display = ""
+            if agent.dependencies:
+                if len(agent.dependencies) > 2:
+                    tools_display = f"{', '.join(agent.dependencies[:2])}..."
+                else:
+                    tools_display = ", ".join(agent.dependencies)
+            else:
+                # Try to get model from template
+                try:
+                    template_path = self._get_agent_template_path(agent.name)
+                    if template_path.exists():
+                        with template_path.open() as f:
+                            template = json.load(f)
+                        model = template.get("capabilities", {}).get("model", "default")
+                        tools_display = f"Model: {model}"
+                    else:
+                        tools_display = "Default"
+                except Exception:
+                    tools_display = "Default"
+
+            # Truncate description for table display with bright styling
+            if len(agent.description) > 42:
+                desc_display = f"[cyan]{agent.description[:42]}[/cyan][dim]...[/dim]"
+            else:
+                desc_display = f"[cyan]{agent.description}[/cyan]"
+
+            table.add_row(str(idx), agent.name, status, desc_display, tools_display)
+
+        self.console.print(table)
+
+    def display_agents_with_pending_states(self, agents: List[AgentConfig]) -> None:
+        """Display agents table with pending state indicators.
+
+        Shows arrows (→) for agents with pending state changes:
+        - "✗ Disabled → ✓ Enabled" for pending enable
+        - "✓ Enabled → ✗ Disabled" for pending disable
+
+        Useful for batch operations where changes are deferred until save.
+
+        Args:
+            agents: List of agent configurations to display
+        """
+        has_pending = self.agent_manager.has_pending_changes()
+        pending_count = len(self.agent_manager.deferred_changes) if has_pending else 0
+
+        title = f"Available Agents ({len(agents)} total)"
+        if has_pending:
+            title += f" [yellow]({pending_count} change{'s' if pending_count != 1 else ''} pending)[/yellow]"
+
+        table = Table(title=title, box=ROUNDED, show_lines=True, expand=True)
+        table.add_column("ID", justify="right", style="bold blue", width=5)
+        table.add_column("Name", style="bold", width=22)
+        table.add_column("Status", width=20)
+        table.add_column("Description", style="bold", width=45)
+
+        for idx, agent in enumerate(agents, 1):
+            current_state = self.agent_manager.is_agent_enabled(agent.name)
+            pending_state = self.agent_manager.get_pending_state(agent.name)
+
+            # Show pending status with arrow
+            if current_state != pending_state:
+                if pending_state:
+                    status = "[yellow]✗ Disabled → ✓ Enabled[/yellow]"
+                else:
+                    status = "[yellow]✓ Enabled → ✗ Disabled[/yellow]"
+            else:
+                status = (
+                    "[green]✓ Enabled[/green]"
+                    if current_state
+                    else "[dim]✗ Disabled[/dim]"
+                )
+
+            desc_display = Text()
+            desc_display.append(
+                (
+                    agent.description[:42] + "..."
+                    if len(agent.description) > 42
+                    else agent.description
+                ),
+                style="",
+            )
+
+            table.add_row(str(idx), agent.name, status, desc_display)
+
+        self.console.print(table)
+
+    def view_agent_details(self, agents: List[AgentConfig]) -> None:
+        """View detailed information about a selected agent.
+
+        Displays comprehensive agent information in a panel:
+        - Name, status, template path
+        - Full description (not truncated)
+        - Model and version information
+        - Tags and tools
+        - Whether it's a system or custom template
+
+        Args:
+            agents: List of available agents for selection
+        """
+        agent_id = Prompt.ask("Enter agent ID to view")
+
+        try:
+            idx = int(agent_id) - 1
+            if 0 <= idx < len(agents):
+                agent = agents[idx]
+
+                self.console.clear()
+                self._display_header()
+
+                # Try to load full template for more details
+                template_path = self._get_agent_template_path(agent.name)
+                extra_info = ""
+
+                if template_path.exists():
+                    try:
+                        with template_path.open() as f:
+                            template = json.load(f)
+
+                        # Extract additional information
+                        metadata = template.get("metadata", {})
+                        capabilities = template.get("capabilities", {})
+
+                        # Get full description if available
+                        full_desc = metadata.get("description", agent.description)
+
+                        # Get model and tools
+                        model = capabilities.get("model", "default")
+                        tools = capabilities.get("tools", [])
+
+                        # Get tags
+                        tags = metadata.get("tags", [])
+
+                        # Get version info
+                        agent_version = template.get("agent_version", "N/A")
+                        schema_version = template.get("schema_version", "N/A")
+
+                        extra_info = f"""
+[bold]Full Description:[/bold]
+{full_desc}
+
+[bold]Model:[/bold] {model}
+[bold]Agent Version:[/bold] {agent_version}
+[bold]Schema Version:[/bold] {schema_version}
+[bold]Tags:[/bold] {', '.join(tags) if tags else 'None'}
+[bold]Tools:[/bold] {', '.join(tools[:5]) if tools else 'None'}{'...' if len(tools) > 5 else ''}
+"""
+                    except Exception:
+                        pass
+
+                # Create detail panel
+                detail_text = f"""
+[bold]Name:[/bold] {agent.name}
+[bold]Status:[/bold] {'[green]Enabled[/green]' if self.agent_manager.is_agent_enabled(agent.name) else '[red]Disabled[/red]'}
+[bold]Template Path:[/bold] {template_path}
+[bold]Is System Template:[/bold] {'Yes' if str(template_path).startswith(str(self.agent_manager.templates_dir)) else 'No (Custom)'}
+{extra_info}
+                """
+
+                panel = Panel(
+                    detail_text.strip(),
+                    title=f"[bold]{agent.name} Details[/bold]",
+                    box=ROUNDED,
+                    style="blue",
+                )
+
+                self.console.print(panel)
+
+            else:
+                self.console.print("[red]Invalid agent ID.[/red]")
+
+        except ValueError:
+            self.console.print("[red]Invalid input. Please enter a number.[/red]")
+
+        Prompt.ask("\nPress Enter to continue")

claude_mpm/cli/commands/configure_behavior_manager.py

@@ -0,0 +1,204 @@
+"""Behavior file management for configure command.
+
+This module handles operations on behavior configuration files including
+identity and workflow configurations.
+
+Extracted from configure.py (Phase 5/9) to reduce God Object complexity.
+"""
+
+import shutil
+from pathlib import Path
+from typing import Optional
+
+from rich.box import ROUNDED
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+
+from ...utils.console import console as default_console
+from ..shared import CommandResult
+
+
+class BehaviorManager:
+    """Manage behavior configuration files.
+
+    Handles:
+    - Displaying available behavior files
+    - Editing identity and workflow configs
+    - Importing/exporting behavior files
+    """
+
+    def __init__(
+        self,
+        config_dir: Path,
+        current_scope: str = "project",
+        console: Optional[Console] = None,
+    ):
+        """Initialize behavior manager.
+
+        Args:
+            config_dir: Path to configuration directory
+            current_scope: Current scope (project or user)
+            console: Rich console for output (optional)
+        """
+        self.config_dir = config_dir
+        self.current_scope = current_scope
+        self.behaviors_dir = config_dir / "behaviors"
+        self.console = console or default_console
+
+        # Ensure behaviors directory exists
+        self.behaviors_dir.mkdir(parents=True, exist_ok=True)
+
+    def manage_behaviors(self) -> None:
+        """Interactive behavior file management interface.
+
+        Extracted from ConfigureCommand._manage_behaviors()
+        """
+        while True:
+            self.console.clear()
+            # Note: _display_header() is called from parent
+            # We skip it here since it's a parent responsibility
+
+            self.console.print("[bold]Behavior File Management[/bold]\n")
+
+            # Display current behavior files
+            self.display_behavior_files()
+
+            # Show behavior menu
+            self.console.print("\n[bold]Options:[/bold]")
+
+            text_1 = Text("  ")
+            text_1.append("[1]", style="bold blue")
+            text_1.append(" Edit identity configuration")
+            self.console.print(text_1)
+
+            text_2 = Text("  ")
+            text_2.append("[2]", style="bold blue")
+            text_2.append(" Edit workflow configuration")
+            self.console.print(text_2)
+
+            text_3 = Text("  ")
+            text_3.append("[3]", style="bold blue")
+            text_3.append(" Import behavior file")
+            self.console.print(text_3)
+
+            text_4 = Text("  ")
+            text_4.append("[4]", style="bold blue")
+            text_4.append(" Export behavior file")
+            self.console.print(text_4)
+
+            text_b = Text("  ")
+            text_b.append("[b]", style="bold blue")
+            text_b.append(" Back to main menu")
+            self.console.print(text_b)
+
+            self.console.print()
+
+            choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
+
+            if choice == "b":
+                break
+            if choice == "1":
+                self.edit_identity_config()
+            elif choice == "2":
+                self.edit_workflow_config()
+            elif choice == "3":
+                self.import_behavior_file()
+            elif choice == "4":
+                self.export_behavior_file()
+            else:
+                self.console.print("[red]Invalid choice.[/red]")
+                Prompt.ask("Press Enter to continue")
+
+    def display_behavior_files(self) -> None:
+        """Display current behavior files.
+
+        Extracted from ConfigureCommand._display_behavior_files()
+        """
+        table = Table(title="Behavior Files", box=ROUNDED)
+        table.add_column("File", style="bold blue", width=30)
+        table.add_column("Size", style="dim", width=10)
+        table.add_column("Modified", style="", width=20)
+
+        identity_file = self.behaviors_dir / "identity.yaml"
+        workflow_file = self.behaviors_dir / "workflow.yaml"
+
+        for file_path in [identity_file, workflow_file]:
+            if file_path.exists():
+                stat = file_path.stat()
+                size = f"{stat.st_size} bytes"
+                modified = f"{stat.st_mtime:.0f}"  # Simplified timestamp
+                table.add_row(file_path.name, size, modified)
+            else:
+                table.add_row(file_path.name, "[dim]Not found[/dim]", "-")
+
+        self.console.print(table)
+
+    def edit_identity_config(self) -> None:
+        """Edit identity configuration.
+
+        Extracted from ConfigureCommand._edit_identity_config()
+        """
+        self.console.print(
+            "[yellow]Identity configuration editor - Coming soon![/yellow]"
+        )
+        Prompt.ask("Press Enter to continue")
+
+    def edit_workflow_config(self) -> None:
+        """Edit workflow configuration.
+
+        Extracted from ConfigureCommand._edit_workflow_config()
+        """
+        self.console.print(
+            "[yellow]Workflow configuration editor - Coming soon![/yellow]"
+        )
+        Prompt.ask("Press Enter to continue")
+
+    def import_behavior_file(self) -> None:
+        """Import a behavior file.
+
+        Extracted from ConfigureCommand._import_behavior_file()
+        """
+        file_path = Prompt.ask("Enter path to behavior file to import")
+
+        try:
+            source = Path(file_path)
+            if not source.exists():
+                self.console.print(f"[red]File not found: {file_path}[/red]")
+                return
+
+            # Copy file
+            target = self.behaviors_dir / source.name
+            shutil.copy2(source, target)
+
+            self.console.print(f"[green]Successfully imported {source.name}![/green]")
+
+        except Exception as e:
+            self.console.print(f"[red]Error importing file: {e}[/red]")
+
+        Prompt.ask("Press Enter to continue")
+
+    def export_behavior_file(self) -> None:
+        """Export a behavior file.
+
+        Extracted from ConfigureCommand._export_behavior_file()
+        """
+        self.console.print("[yellow]Behavior file export - Coming soon![/yellow]")
+        Prompt.ask("Press Enter to continue")
+
+    def run_behavior_management(self) -> CommandResult:
+        """Run behavior management interface.
+
+        Extracted from ConfigureCommand._run_behavior_management()
+
+        Returns:
+            CommandResult with status
+        """
+        try:
+            self.manage_behaviors()
+            return CommandResult.success_result("Behavior management completed")
+        except KeyboardInterrupt:
+            return CommandResult.success_result("Behavior management cancelled")
+        except Exception as e:
+            return CommandResult.error_result(f"Behavior management failed: {e}")

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}")