claude-mpm 4.1.7__py3-none-any.whl → 4.1.10__py3-none-any.whl

claude_mpm/cli/commands/configure.py

@@ -35,7 +35,7 @@ class AgentConfig:
     """Simple agent configuration model."""
 
     def __init__(
-        self, name: str, description: str = "", dependencies: List[str] = None
+        self, name: str, description: str = "", dependencies: Optional[List[str]] = None
     ):
         self.name = name
         self.description = description
@@ -107,7 +107,7 @@ class SimpleAgentManager:
 
                     # Get metadata for display info
                     metadata = template_data.get("metadata", {})
-                    name = metadata.get("name", agent_id)
+                    metadata.get("name", agent_id)
                     description = metadata.get(
                         "description", "No description available"
                     )
@@ -222,6 +222,16 @@ class ConfigureCommand(BaseCommand):
         if getattr(args, "version_info", False):
             return self._show_version_info()
 
+        # Handle hook installation
+        if getattr(args, "install_hooks", False):
+            return self._install_hooks(force=getattr(args, "force", False))
+
+        if getattr(args, "verify_hooks", False):
+            return self._verify_hooks()
+
+        if getattr(args, "uninstall_hooks", False):
+            return self._uninstall_hooks()
+
         # Handle direct navigation options
         if getattr(args, "agents", False):
             return self._run_agent_management()
@@ -566,16 +576,15 @@ class ConfigureCommand(BaseCommand):
         display_template = template.copy()
         if "instructions" in display_template and isinstance(
             display_template["instructions"], dict
+        ) and (
+            "custom_instructions" in display_template["instructions"]
+            and len(str(display_template["instructions"]["custom_instructions"]))
+            > 200
         ):
-            if (
-                "custom_instructions" in display_template["instructions"]
-                and len(str(display_template["instructions"]["custom_instructions"]))
-                > 200
-            ):
-                display_template["instructions"]["custom_instructions"] = (
-                    display_template["instructions"]["custom_instructions"][:200]
-                    + "..."
-                )
+            display_template["instructions"]["custom_instructions"] = (
+                display_template["instructions"]["custom_instructions"][:200]
+                + "..."
+            )
 
         json_str = json.dumps(display_template, indent=2)
         # Limit display to first 50 lines for readability
@@ -774,11 +783,10 @@ class ConfigureCommand(BaseCommand):
         config_dir.mkdir(parents=True, exist_ok=True)
         custom_path = config_dir / f"{agent.name}.json"
 
-        if custom_path.exists():
-            if not Confirm.ask(
-                "[yellow]Custom template already exists. Overwrite?[/yellow]"
-            ):
-                return
+        if custom_path.exists() and not Confirm.ask(
+            "[yellow]Custom template already exists. Overwrite?[/yellow]"
+        ):
+            return
 
         # Save the template copy
         with open(custom_path, "w") as f:
@@ -1012,16 +1020,33 @@ class ConfigureCommand(BaseCommand):
         mpm_version = self.version_service.get_version()
         build_number = self.version_service.get_build_number()
 
-        # Try to get Claude Code version
+        # Try to get Claude Code version using the installer's method
         claude_version = "Unknown"
         try:
-            import subprocess
-
-            result = subprocess.run(
-                ["claude", "--version"], capture_output=True, text=True, timeout=5, check=False
-            )
-            if result.returncode == 0:
-                claude_version = result.stdout.strip()
+            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
+                import subprocess
+
+                result = subprocess.run(
+                    ["claude", "--version"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                    check=False,
+                )
+                if result.returncode == 0:
+                    claude_version = result.stdout.strip()
         except:
             pass
 
@@ -1157,7 +1182,11 @@ Directory: {self.project_dir}
             import subprocess
 
             result = subprocess.run(
-                ["claude", "--version"], capture_output=True, text=True, timeout=5, check=False
+                ["claude", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
             )
             if result.returncode == 0:
                 data["claude_version"] = result.stdout.strip()
@@ -1175,6 +1204,175 @@ Directory: {self.project_dir}
 
         return CommandResult.success_result("Version information displayed", data=data)
 
+    def _install_hooks(self, force: bool = False) -> CommandResult:
+        """Install Claude MPM hooks for Claude Code integration."""
+        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:
+            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."""
+        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:
+            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."""
+        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:
+            self.logger.error(f"Hook uninstallation error: {e}", exc_info=True)
+            return CommandResult.error_result(f"Hook uninstallation failed: {e}")
+
     def _run_agent_management(self) -> CommandResult:
         """Jump directly to agent management."""
         try: