claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/cli/commands/agents.py

@@ -12,8 +12,10 @@ DESIGN DECISIONS:
 """
 
 import json
+from pathlib import Path
 
 from ...constants import AgentCommands
+from ...core.enums import OutputFormat
 from ...services.cli.agent_cleanup_service import AgentCleanupService
 from ...services.cli.agent_dependency_service import AgentDependencyService
 from ...services.cli.agent_listing_service import AgentListingService
@@ -26,6 +28,14 @@ from ..shared import (
 from ..utils import get_agent_versions_display
 
 
+def _is_structured_output(args) -> bool:
+    """Check if args specify structured output format (JSON/YAML)."""
+    if hasattr(args, "format"):
+        fmt = str(args.format).lower()
+        return fmt in (OutputFormat.JSON, OutputFormat.YAML)
+    return False
+
+
 class AgentsCommand(AgentCommand):
     """Agent management command using shared utilities."""
 
@@ -50,8 +60,8 @@ class AgentsCommand(AgentCommand):
 
                 base_service = AgentDeploymentService()
                 self._deployment_service = DeploymentServiceWrapper(base_service)
-            except ImportError:
-                raise ImportError("Agent deployment service not available")
+            except ImportError as e:
+                raise ImportError("Agent deployment service not available") from e
         return self._deployment_service
 
     @property
@@ -86,6 +96,31 @@ class AgentsCommand(AgentCommand):
             )
         return self._cleanup_service
 
+    def _get_output_format(self, args) -> str:
+        """
+        Get output format from args with enum default.
+
+        Args:
+            args: Command arguments
+
+        Returns:
+            Output format string (compatible with both enum and string usage)
+        """
+        return getattr(args, "format", OutputFormat.TEXT)
+
+    def _is_structured_format(self, format_str: str) -> bool:
+        """
+        Check if format is structured (JSON/YAML).
+
+        Args:
+            format_str: Format string to check
+
+        Returns:
+            True if format is JSON or YAML
+        """
+        fmt = str(format_str).lower()
+        return fmt in (OutputFormat.JSON, OutputFormat.YAML)
+
     def validate_args(self, args) -> str:
         """Validate command arguments."""
         # Most agent commands are optional, so basic validation
@@ -115,6 +150,15 @@ class AgentsCommand(AgentCommand):
                 "deps-list": self._list_agent_dependencies,
                 "deps-fix": self._fix_agent_dependencies,
                 "cleanup-orphaned": self._cleanup_orphaned_agents,
+                # Local agent management commands
+                "create": self._create_local_agent,
+                "edit": self._edit_local_agent,
+                "delete": self._delete_local_agent,
+                "manage": self._manage_local_agents,
+                "configure": self._configure_deployment,
+                # Auto-configuration commands (TSK-0054 Phase 5)
+                "detect": self._detect_toolchain,
+                "recommend": self._recommend_agents,
             }
 
             if args.agents_command in command_map:
@@ -135,14 +179,14 @@ class AgentsCommand(AgentCommand):
         try:
             agent_versions = get_agent_versions_display()
 
-            output_format = getattr(args, "format", "text")
-            if output_format in ["json", "yaml"]:
+            output_format = self._get_output_format(args)
+            if self._is_structured_format(output_format):
                 # Parse the agent versions display into structured data
                 if agent_versions:
                     data = {"agent_versions": agent_versions, "has_agents": True}
                     formatted = (
                         self._formatter.format_as_json(data)
-                        if output_format == "json"
+                        if str(output_format).lower() == OutputFormat.JSON
                         else self._formatter.format_as_yaml(data)
                     )
                     print(formatted)
@@ -156,7 +200,7 @@ class AgentsCommand(AgentCommand):
                 }
                 formatted = (
                     self._formatter.format_as_json(data)
-                    if output_format == "json"
+                    if str(output_format).lower() == OutputFormat.JSON
                     else self._formatter.format_as_yaml(data)
                 )
                 print(formatted)
@@ -178,7 +222,7 @@ class AgentsCommand(AgentCommand):
     def _list_agents(self, args) -> CommandResult:
         """List available or deployed agents."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
             if hasattr(args, "by_tier") and args.by_tier:
                 return self._list_agents_by_tier(args)
@@ -189,7 +233,7 @@ class AgentsCommand(AgentCommand):
             # Default: show usage
             usage_msg = "Use --system to list system agents, --deployed to list deployed agents, or --by-tier to group by precedence"
 
-            if output_format in ["json", "yaml"]:
+            if self._is_structured_format(output_format):
                 return CommandResult.error_result(
                     "No list option specified",
                     data={
@@ -210,7 +254,7 @@ class AgentsCommand(AgentCommand):
             verbose = getattr(args, "verbose", False)
             agents = self.listing_service.list_system_agents(verbose=verbose)
 
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             quiet = getattr(args, "quiet", False)
 
             # Convert AgentInfo objects to dicts for formatter
@@ -219,6 +263,7 @@ class AgentsCommand(AgentCommand):
                     "name": agent.name,
                     "type": agent.type,
                     "path": agent.path,
+                    "file": Path(agent.path).name if agent.path else "Unknown",
                     "description": agent.description,
                     "specializations": agent.specializations,
                     "version": agent.version,
@@ -248,7 +293,7 @@ class AgentsCommand(AgentCommand):
                 verbose=verbose
             )
 
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             quiet = getattr(args, "quiet", False)
 
             # Convert AgentInfo objects to dicts for formatter
@@ -258,6 +303,7 @@ class AgentsCommand(AgentCommand):
                     "type": agent.type,
                     "tier": agent.tier,
                     "path": agent.path,
+                    "file": Path(agent.path).name if agent.path else "Unknown",
                     "description": agent.description,
                     "specializations": agent.specializations,
                     "version": agent.version,
@@ -272,7 +318,7 @@ class AgentsCommand(AgentCommand):
             print(formatted)
 
             # Add warnings for text output
-            if output_format == "text" and warnings:
+            if str(output_format).lower() == OutputFormat.TEXT and warnings:
                 print("\nWarnings:")
                 for warning in warnings:
                     print(f"  ⚠️  {warning}")
@@ -294,7 +340,7 @@ class AgentsCommand(AgentCommand):
         """List agents grouped by tier/precedence."""
         try:
             tier_info = self.listing_service.list_agents_by_tier()
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
             # Convert to format expected by formatter
             agents_by_tier = {
@@ -377,7 +423,7 @@ class AgentsCommand(AgentCommand):
                 or project_result.get("target_dir"),
             }
 
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             verbose = getattr(args, "verbose", False)
 
             formatted = self._formatter.format_deployment_result(
@@ -403,7 +449,7 @@ class AgentsCommand(AgentCommand):
         try:
             result = self.cleanup_service.clean_deployed_agents()
 
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             dry_run = False  # Regular clean is not a dry run
 
             formatted = self._formatter.format_cleanup_result(
@@ -441,7 +487,7 @@ class AgentsCommand(AgentCommand):
                     f"Could not retrieve details for agent '{agent_name}'"
                 )
 
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             verbose = getattr(args, "verbose", False)
 
             formatted = self._formatter.format_agent_details(
@@ -463,148 +509,170 @@ class AgentsCommand(AgentCommand):
             dry_run = getattr(args, "dry_run", False)
             agent_name = getattr(args, "agent_name", None)
             fix_all = getattr(args, "all", False)
+            output_format = self._get_output_format(args)
 
-            output_format = getattr(args, "format", "text")
-
-            # Determine what to fix
+            # Route to appropriate handler based on input
             if fix_all:
-                # Fix all agents
-                result = self.validation_service.fix_all_agents(dry_run=dry_run)
-
-                if output_format in ["json", "yaml"]:
-                    formatted = (
-                        self._formatter.format_as_json(result)
-                        if output_format == "json"
-                        else self._formatter.format_as_yaml(result)
-                    )
-                    print(formatted)
-                else:
-                    # Text output
-                    mode = "DRY RUN" if dry_run else "FIX"
-                    print(
-                        f"\n🔧 {mode}: Checking {result.get('total_agents', 0)} agent(s) for frontmatter issues...\n"
-                    )
-
-                    if result.get("results"):
-                        for agent_result in result["results"]:
-                            print(f"📄 {agent_result['agent']}:")
-                            if agent_result.get("skipped"):
-                                print(
-                                    f"  ⚠️  Skipped: {agent_result.get('reason', 'Unknown reason')}"
-                                )
-                            elif agent_result.get("was_valid"):
-                                print("  ✓ No issues found")
-                            else:
-                                if agent_result.get("errors_found", 0) > 0:
-                                    print(
-                                        f"  ❌ Errors found: {agent_result['errors_found']}"
-                                    )
-                                if agent_result.get("warnings_found", 0) > 0:
-                                    print(
-                                        f"  ⚠️  Warnings found: {agent_result['warnings_found']}"
-                                    )
-                                if dry_run:
-                                    if agent_result.get("corrections_available", 0) > 0:
-                                        print(
-                                            f"  🔧 Would fix: {agent_result['corrections_available']} issues"
-                                        )
-                                elif agent_result.get("corrections_made", 0) > 0:
-                                    print(
-                                        f"  ✓ Fixed: {agent_result['corrections_made']} issues"
-                                    )
-                            print()
-
-                    # Summary
-                    print("=" * 80)
-                    print("SUMMARY:")
-                    print(f"  Agents checked: {result.get('agents_checked', 0)}")
-                    print(
-                        f"  Total issues found: {result.get('total_issues_found', 0)}"
-                    )
-                    if dry_run:
-                        print(
-                            f"  Issues that would be fixed: {result.get('total_corrections_available', 0)}"
-                        )
-                        print("\n💡 Run without --dry-run to apply fixes")
-                    else:
-                        print(
-                            f"  Issues fixed: {result.get('total_corrections_made', 0)}"
-                        )
-                        if result.get("total_corrections_made", 0) > 0:
-                            print("\n✓ Frontmatter issues have been fixed!")
-                    print("=" * 80 + "\n")
+                return self._fix_all_agents(dry_run, output_format)
+            if agent_name:
+                return self._fix_single_agent(agent_name, dry_run, output_format)
+            return self._handle_no_agent_specified(output_format)
 
-                msg = f"{'Would fix' if dry_run else 'Fixed'} {result.get('total_corrections_available' if dry_run else 'total_corrections_made', 0)} issues"
-                return CommandResult.success_result(msg, data=result)
+        except Exception as e:
+            self.logger.error(f"Error fixing agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error fixing agents: {e}")
 
-            if agent_name:
-                # Fix specific agent
-                result = self.validation_service.fix_agent_frontmatter(
-                    agent_name, dry_run=dry_run
-                )
+    def _fix_all_agents(self, dry_run: bool, output_format: str) -> CommandResult:
+        """Fix all agents' frontmatter issues."""
+        result = self.validation_service.fix_all_agents(dry_run=dry_run)
 
-                if not result.get("success"):
-                    return CommandResult.error_result(
-                        result.get("error", "Failed to fix agent")
-                    )
+        if self._is_structured_format(output_format):
+            self._print_structured_output(result, output_format)
+        else:
+            self._print_all_agents_text_output(result, dry_run)
 
-                if output_format in ["json", "yaml"]:
-                    formatted = (
-                        self._formatter.format_as_json(result)
-                        if output_format == "json"
-                        else self._formatter.format_as_yaml(result)
-                    )
-                    print(formatted)
-                else:
-                    # Text output
-                    mode = "DRY RUN" if dry_run else "FIX"
-                    print(
-                        f"\n🔧 {mode}: Checking agent '{agent_name}' for frontmatter issues...\n"
-                    )
+        msg = f"{'Would fix' if dry_run else 'Fixed'} {result.get('total_corrections_available' if dry_run else 'total_corrections_made', 0)} issues"
+        return CommandResult.success_result(msg, data=result)
 
-                    print(f"📄 {agent_name}:")
-                    if result.get("was_valid"):
-                        print("  ✓ No issues found")
-                    else:
-                        if result.get("errors_found"):
-                            print("  ❌ Errors:")
-                            for error in result["errors_found"]:
-                                print(f"    - {error}")
-                        if result.get("warnings_found"):
-                            print("  ⚠️  Warnings:")
-                            for warning in result["warnings_found"]:
-                                print(f"    - {warning}")
-                        if dry_run:
-                            if result.get("corrections_available"):
-                                print("  🔧 Would fix:")
-                                for correction in result["corrections_available"]:
-                                    print(f"    - {correction}")
-                        elif result.get("corrections_made"):
-                            print("  ✓ Fixed:")
-                            for correction in result["corrections_made"]:
-                                print(f"    - {correction}")
-                    print()
+    def _fix_single_agent(
+        self, agent_name: str, dry_run: bool, output_format: str
+    ) -> CommandResult:
+        """Fix a single agent's frontmatter issues."""
+        result = self.validation_service.fix_agent_frontmatter(
+            agent_name, dry_run=dry_run
+        )
 
-                    if dry_run and result.get("corrections_available"):
-                        print("💡 Run without --dry-run to apply fixes\n")
-                    elif not dry_run and result.get("corrections_made"):
-                        print("✓ Frontmatter issues have been fixed!\n")
+        if not result.get("success"):
+            return CommandResult.error_result(
+                result.get("error", "Failed to fix agent")
+            )
 
-                msg = f"{'Would fix' if dry_run else 'Fixed'} agent '{agent_name}'"
-                return CommandResult.success_result(msg, data=result)
+        if self._is_structured_format(output_format):
+            self._print_structured_output(result, output_format)
+        else:
+            self._print_single_agent_text_output(agent_name, result, dry_run)
 
-            # No agent specified and not --all
-            usage_msg = "Please specify an agent name or use --all to fix all agents\nUsage: claude-mpm agents fix [agent_name] [--dry-run] [--all]"
-            if output_format in ["json", "yaml"]:
-                return CommandResult.error_result(
-                    "No agent specified", data={"usage": usage_msg}
-                )
-            print(f"❌ {usage_msg}")
-            return CommandResult.error_result("No agent specified")
+        msg = f"{'Would fix' if dry_run else 'Fixed'} agent '{agent_name}'"
+        return CommandResult.success_result(msg, data=result)
 
-        except Exception as e:
-            self.logger.error(f"Error fixing agents: {e}", exc_info=True)
-            return CommandResult.error_result(f"Error fixing agents: {e}")
+    def _handle_no_agent_specified(self, output_format: str) -> CommandResult:
+        """Handle case where no agent is specified."""
+        usage_msg = "Please specify an agent name or use --all to fix all agents\nUsage: claude-mpm agents fix [agent_name] [--dry-run] [--all]"
+        if self._is_structured_format(output_format):
+            return CommandResult.error_result(
+                "No agent specified", data={"usage": usage_msg}
+            )
+        print(f"❌ {usage_msg}")
+        return CommandResult.error_result("No agent specified")
+
+    def _print_structured_output(self, result: dict, output_format: str) -> None:
+        """Print result in JSON or YAML format."""
+        formatted = (
+            self._formatter.format_as_json(result)
+            if str(output_format).lower() == OutputFormat.JSON
+            else self._formatter.format_as_yaml(result)
+        )
+        print(formatted)
+
+    def _print_all_agents_text_output(self, result: dict, dry_run: bool) -> None:
+        """Print text output for all agents fix operation."""
+        mode = "DRY RUN" if dry_run else "FIX"
+        print(
+            f"\n🔧 {mode}: Checking {result.get('total_agents', 0)} agent(s) for frontmatter issues...\n"
+        )
+
+        if result.get("results"):
+            for agent_result in result["results"]:
+                self._print_agent_result(agent_result, dry_run)
+
+        self._print_all_agents_summary(result, dry_run)
+
+    def _print_agent_result(self, agent_result: dict, dry_run: bool) -> None:
+        """Print result for a single agent."""
+        print(f"📄 {agent_result['agent']}:")
+        if agent_result.get("skipped"):
+            print(f"  ⚠️  Skipped: {agent_result.get('reason', 'Unknown reason')}")
+        elif agent_result.get("was_valid"):
+            print("  ✓ No issues found")
+        else:
+            self._print_agent_issues(agent_result, dry_run)
+        print()
+
+    def _print_agent_issues(self, agent_result: dict, dry_run: bool) -> None:
+        """Print issues found for an agent."""
+        if agent_result.get("errors_found", 0) > 0:
+            print(f"  ❌ Errors found: {agent_result['errors_found']}")
+        if agent_result.get("warnings_found", 0) > 0:
+            print(f"  ⚠️  Warnings found: {agent_result['warnings_found']}")
+
+        if dry_run:
+            if agent_result.get("corrections_available", 0) > 0:
+                print(f"  🔧 Would fix: {agent_result['corrections_available']} issues")
+        elif agent_result.get("corrections_made", 0) > 0:
+            print(f"  ✓ Fixed: {agent_result['corrections_made']} issues")
+
+    def _print_all_agents_summary(self, result: dict, dry_run: bool) -> None:
+        """Print summary for all agents fix operation."""
+        print("=" * 80)
+        print("SUMMARY:")
+        print(f"  Agents checked: {result.get('agents_checked', 0)}")
+        print(f"  Total issues found: {result.get('total_issues_found', 0)}")
+
+        if dry_run:
+            print(
+                f"  Issues that would be fixed: {result.get('total_corrections_available', 0)}"
+            )
+            print("\n💡 Run without --dry-run to apply fixes")
+        else:
+            print(f"  Issues fixed: {result.get('total_corrections_made', 0)}")
+            if result.get("total_corrections_made", 0) > 0:
+                print("\n✓ Frontmatter issues have been fixed!")
+        print("=" * 80 + "\n")
+
+    def _print_single_agent_text_output(
+        self, agent_name: str, result: dict, dry_run: bool
+    ) -> None:
+        """Print text output for single agent fix operation."""
+        mode = "DRY RUN" if dry_run else "FIX"
+        print(f"\n🔧 {mode}: Checking agent '{agent_name}' for frontmatter issues...\n")
+
+        print(f"📄 {agent_name}:")
+        if result.get("was_valid"):
+            print("  ✓ No issues found")
+        else:
+            self._print_single_agent_issues(result, dry_run)
+        print()
+
+        self._print_single_agent_footer(result, dry_run)
+
+    def _print_single_agent_issues(self, result: dict, dry_run: bool) -> None:
+        """Print issues for a single agent."""
+        if result.get("errors_found"):
+            print("  ❌ Errors:")
+            for error in result["errors_found"]:
+                print(f"    - {error}")
+
+        if result.get("warnings_found"):
+            print("  ⚠️  Warnings:")
+            for warning in result["warnings_found"]:
+                print(f"    - {warning}")
+
+        if dry_run:
+            if result.get("corrections_available"):
+                print("  🔧 Would fix:")
+                for correction in result["corrections_available"]:
+                    print(f"    - {correction}")
+        elif result.get("corrections_made"):
+            print("  ✓ Fixed:")
+            for correction in result["corrections_made"]:
+                print(f"    - {correction}")
+
+    def _print_single_agent_footer(self, result: dict, dry_run: bool) -> None:
+        """Print footer message for single agent fix."""
+        if dry_run and result.get("corrections_available"):
+            print("💡 Run without --dry-run to apply fixes\n")
+        elif not dry_run and result.get("corrections_made"):
+            print("✓ Frontmatter issues have been fixed!\n")
 
     def _check_agent_dependencies(self, args) -> CommandResult:
         """Check agent dependencies."""
@@ -684,7 +752,7 @@ class AgentsCommand(AgentCommand):
     def _list_agent_dependencies(self, args) -> CommandResult:
         """List agent dependencies."""
         try:
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
             result = self.dependency_service.list_dependencies(
                 format_type=output_format
             )
@@ -696,7 +764,7 @@ class AgentsCommand(AgentCommand):
             if output_format == "pip":
                 for dep in result["dependencies"]:
                     print(dep)
-            elif output_format == "json":
+            elif str(output_format).lower() == OutputFormat.JSON:
                 print(json.dumps(result["data"], indent=2))
             else:  # text format
                 print("=" * 60)
@@ -854,7 +922,7 @@ class AgentsCommand(AgentCommand):
                 agents_dir=agents_dir, dry_run=dry_run
             )
 
-            output_format = getattr(args, "format", "text")
+            output_format = self._get_output_format(args)
 
             formatted = self._formatter.format_cleanup_result(
                 results, output_format=output_format, dry_run=dry_run
@@ -876,6 +944,510 @@ class AgentsCommand(AgentCommand):
             self.logger.error(f"Error during cleanup: {e}", exc_info=True)
             return CommandResult.error_result(f"Error during cleanup: {e}")
 
+    def _create_local_agent(self, args) -> CommandResult:
+        """Create a new local agent template."""
+        try:
+            if getattr(args, "interactive", False):
+                # Launch interactive wizard
+                from ..interactive.agent_wizard import run_interactive_agent_wizard
+
+                exit_code = run_interactive_agent_wizard()
+                if exit_code == 0:
+                    return CommandResult.success_result("Agent created successfully")
+                return CommandResult.error_result("Agent creation cancelled or failed")
+
+            # Non-interactive creation
+            from ...services.agents.local_template_manager import (
+                LocalAgentTemplateManager,
+            )
+
+            agent_id = getattr(args, "agent_id", None)
+            if not agent_id:
+                return CommandResult.error_result(
+                    "--agent-id is required for non-interactive creation"
+                )
+
+            manager = LocalAgentTemplateManager()
+            name = getattr(args, "name", agent_id.replace("-", " ").title())
+            model = getattr(args, "model", "sonnet")
+            inherit_from = getattr(args, "inherit_from", None)
+
+            # Create basic template
+            template = manager.create_local_template(
+                agent_id=agent_id,
+                name=name,
+                description=f"Local agent: {name}",
+                instructions="# Agent Instructions\n\nCustomize this agent's behavior here.",
+                model=model,
+                parent_agent=inherit_from,
+                tier="project",
+            )
+
+            if template:
+                return CommandResult.success_result(
+                    f"Created local agent '{agent_id}' in .claude-mpm/agents/",
+                    data={
+                        "agent_id": agent_id,
+                        "path": f".claude-mpm/agents/{agent_id}.json",
+                    },
+                )
+            return CommandResult.error_result("Failed to create agent template")
+
+        except Exception as e:
+            self.logger.error(f"Error creating local agent: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error creating local agent: {e}")
+
+    def _edit_local_agent(self, args) -> CommandResult:
+        """Edit a local agent template."""
+        try:
+            agent_id = getattr(args, "agent_id", None)
+            if not agent_id:
+                return CommandResult.error_result("agent_id is required")
+
+            import os
+            import subprocess
+
+            from ...services.agents.local_template_manager import (
+                LocalAgentTemplateManager,
+            )
+
+            manager = LocalAgentTemplateManager()
+            template = manager.get_local_template(agent_id)
+
+            if not template:
+                return CommandResult.error_result(f"Local agent '{agent_id}' not found")
+
+            # Get template file path
+            template_file = None
+            if template.tier == "project":
+                template_file = manager.project_agents_dir / f"{agent_id}.json"
+            else:
+                template_file = manager.user_agents_dir / f"{agent_id}.json"
+
+            if not template_file or not template_file.exists():
+                return CommandResult.error_result(
+                    f"Template file not found for '{agent_id}'"
+                )
+
+            if getattr(args, "interactive", False):
+                # Launch interactive editor
+                from ..interactive.agent_wizard import AgentWizard
+
+                wizard = AgentWizard()
+                success, message = wizard._edit_agent_config(template)
+                if success:
+                    return CommandResult.success_result(message)
+                return CommandResult.error_result(message)
+
+            # Use system editor
+            editor = getattr(args, "editor", None) or os.environ.get("EDITOR", "nano")
+            subprocess.run([editor, str(template_file)], check=True)
+            return CommandResult.success_result(
+                f"Agent '{agent_id}' edited successfully"
+            )
+
+        except subprocess.CalledProcessError:
+            return CommandResult.error_result("Editor exited with error")
+        except Exception as e:
+            self.logger.error(f"Error editing local agent: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error editing local agent: {e}")
+
+    def _delete_local_agent(self, args) -> CommandResult:
+        """Delete local agent templates."""
+        try:
+            agent_ids = getattr(args, "agent_ids", [])
+            if not agent_ids:
+                return CommandResult.error_result("No agent IDs specified")
+
+            from ...services.agents.local_template_manager import (
+                LocalAgentTemplateManager,
+            )
+
+            manager = LocalAgentTemplateManager()
+            force = getattr(args, "force", False)
+            keep_deployment = getattr(args, "keep_deployment", False)
+            backup = getattr(args, "backup", False)
+
+            # Confirmation if not forced
+            if not force:
+                print(f"\n⚠️  This will delete {len(agent_ids)} agent(s):")
+                for agent_id in agent_ids:
+                    print(f"  - {agent_id}")
+                confirm = input("\nAre you sure? [y/N]: ").strip().lower()
+                if confirm not in ["y", "yes"]:
+                    return CommandResult.error_result("Deletion cancelled")
+
+            # Delete agents
+            if len(agent_ids) == 1:
+                result = manager.delete_local_template(
+                    agent_id=agent_ids[0],
+                    tier="all",
+                    delete_deployment=not keep_deployment,
+                    backup_first=backup,
+                )
+                if result["success"]:
+                    message = f"Successfully deleted agent '{agent_ids[0]}'"
+                    if result["backup_location"]:
+                        message += f"\nBackup saved to: {result['backup_location']}"
+                    return CommandResult.success_result(message, data=result)
+                return CommandResult.error_result(
+                    f"Failed to delete agent: {', '.join(result['errors'])}"
+                )
+            results = manager.delete_multiple_templates(
+                agent_ids=agent_ids,
+                tier="all",
+                delete_deployment=not keep_deployment,
+                backup_first=backup,
+            )
+
+            message = ""
+            if results["successful"]:
+                message = (
+                    f"Successfully deleted {len(results['successful'])} agent(s):\n"
+                )
+                for agent_id in results["successful"]:
+                    message += f"  - {agent_id}\n"
+
+            if results["failed"]:
+                if message:
+                    message += "\n"
+                message += f"Failed to delete {len(results['failed'])} agent(s):\n"
+                for agent_id in results["failed"]:
+                    errors = results["details"][agent_id]["errors"]
+                    message += f"  - {agent_id}: {', '.join(errors)}\n"
+
+            if results["successful"]:
+                return CommandResult.success_result(message.strip(), data=results)
+            return CommandResult.error_result(message.strip(), data=results)
+
+        except Exception as e:
+            self.logger.error(f"Error deleting local agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error deleting local agents: {e}")
+
+    def _manage_local_agents(self, args) -> CommandResult:
+        """Launch interactive management menu for local agents."""
+        try:
+            from ..interactive.agent_wizard import run_interactive_agent_manager
+
+            exit_code = run_interactive_agent_manager()
+            if exit_code == 0:
+                return CommandResult.success_result("Agent management completed")
+            return CommandResult.error_result("Agent management failed or cancelled")
+
+        except Exception as e:
+            self.logger.error(f"Error managing local agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error managing local agents: {e}")
+
+    def _configure_deployment(self, args) -> CommandResult:
+        """Configure agent deployment settings."""
+        try:
+            from pathlib import Path
+
+            import yaml
+
+            from claude_mpm.core.config import Config
+
+            config = Config()
+            config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+
+            # Handle show command
+            if getattr(args, "show", False):
+                from ...services.agents.deployment.deployment_config_loader import (
+                    DeploymentConfigLoader,
+                )
+
+                loader = DeploymentConfigLoader(self.logger)
+                settings = loader.get_deployment_settings(config)
+
+                print("\n📋 Agent Deployment Configuration")
+                print("=" * 50)
+                print(f"Configuration file: {config_path}")
+                print("\n🔧 Deployment Settings:")
+                print(f"  Deploy system agents: {settings['deploy_system_agents']}")
+                print(f"  Deploy local agents: {settings['deploy_local_agents']}")
+                print(f"  Deploy user agents: {settings['deploy_user_agents']}")
+                print(
+                    f"  Prefer local over system: {settings['prefer_local_over_system']}"
+                )
+                print(f"  Version comparison: {settings['version_comparison']}")
+
+                if settings["enabled_agents"]:
+                    print(
+                        f"\n✅ Enabled agents: {', '.join(settings['enabled_agents'])}"
+                    )
+                else:
+                    print("\n✅ Enabled agents: All (no restrictions)")
+
+                if settings["disabled_agents"]:
+                    print(
+                        f"❌ Disabled agents: {', '.join(settings['disabled_agents'])}"
+                    )
+                else:
+                    print("❌ Disabled agents: None")
+
+                print("\n" + "=" * 50)
+                return CommandResult.success_result(
+                    "Displayed deployment configuration"
+                )
+
+            # Handle interactive mode
+            if getattr(args, "interactive", False):
+                return self._configure_deployment_interactive(config_path)
+
+            # Load current configuration
+            if not config_path.exists():
+                config_path.parent.mkdir(parents=True, exist_ok=True)
+                config_data = {}
+            else:
+                with config_path.open() as f:
+                    config_data = yaml.safe_load(f) or {}
+
+            # Ensure agent_deployment section exists
+            if "agent_deployment" not in config_data:
+                config_data["agent_deployment"] = {}
+
+            modified = False
+
+            # Handle enable/disable operations
+            if getattr(args, "enable_all", False):
+                config_data["agent_deployment"]["enabled_agents"] = []
+                config_data["agent_deployment"]["disabled_agents"] = []
+                print("✅ Enabled all agents for deployment")
+                modified = True
+
+            if getattr(args, "enable_system", False):
+                config_data["agent_deployment"]["deploy_system_agents"] = True
+                print("✅ Enabled system agents for deployment")
+                modified = True
+
+            if getattr(args, "disable_system", False):
+                config_data["agent_deployment"]["deploy_system_agents"] = False
+                print("❌ Disabled system agents from deployment")
+                modified = True
+
+            if getattr(args, "enable_local", False):
+                config_data["agent_deployment"]["deploy_local_agents"] = True
+                print("✅ Enabled local agents for deployment")
+                modified = True
+
+            if getattr(args, "disable_local", False):
+                config_data["agent_deployment"]["deploy_local_agents"] = False
+                print("❌ Disabled local agents from deployment")
+                modified = True
+
+            if getattr(args, "enable", None):
+                enabled = config_data["agent_deployment"].get("enabled_agents", [])
+                disabled = config_data["agent_deployment"].get("disabled_agents", [])
+
+                for agent_id in args.enable:
+                    if agent_id not in enabled:
+                        enabled.append(agent_id)
+                    if agent_id in disabled:
+                        disabled.remove(agent_id)
+
+                config_data["agent_deployment"]["enabled_agents"] = enabled
+                config_data["agent_deployment"]["disabled_agents"] = disabled
+                print(f"✅ Enabled agents: {', '.join(args.enable)}")
+                modified = True
+
+            if getattr(args, "disable", None):
+                disabled = config_data["agent_deployment"].get("disabled_agents", [])
+
+                for agent_id in args.disable:
+                    if agent_id not in disabled:
+                        disabled.append(agent_id)
+
+                config_data["agent_deployment"]["disabled_agents"] = disabled
+                print(f"❌ Disabled agents: {', '.join(args.disable)}")
+                modified = True
+
+            # Save configuration if modified
+            if modified:
+                with config_path.open("w") as f:
+                    yaml.dump(config_data, f, default_flow_style=False, sort_keys=False)
+                print(f"\n💾 Configuration saved to {config_path}")
+                return CommandResult.success_result("Deployment configuration updated")
+
+            # If no modifications were made and not showing, display help
+            if not getattr(args, "show", False):
+                print("No configuration changes specified. Use --help for options.")
+                return CommandResult.success_result("No changes made")
+
+        except Exception as e:
+            self.logger.error(f"Error configuring deployment: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error configuring deployment: {e}")
+
+    def _configure_deployment_interactive(self, config_path: Path) -> CommandResult:
+        """Interactive mode for configuring agent deployment."""
+        try:
+            import yaml
+
+            from ...utils.ui_helpers import (
+                prompt_choice,
+                prompt_multiselect,
+                prompt_yes_no,
+            )
+
+            # Load current configuration
+            if config_path.exists():
+                with config_path.open() as f:
+                    config_data = yaml.safe_load(f) or {}
+            else:
+                config_data = {}
+
+            if "agent_deployment" not in config_data:
+                config_data["agent_deployment"] = {}
+
+            settings = config_data["agent_deployment"]
+
+            print("\n🎮 Interactive Agent Deployment Configuration")
+            print("=" * 50)
+
+            # Configure source types
+            settings["deploy_system_agents"] = prompt_yes_no(
+                "Deploy system agents?",
+                default=settings.get("deploy_system_agents", True),
+            )
+
+            settings["deploy_local_agents"] = prompt_yes_no(
+                "Deploy local project agents?",
+                default=settings.get("deploy_local_agents", True),
+            )
+
+            settings["deploy_user_agents"] = prompt_yes_no(
+                "Deploy user-level agents?",
+                default=settings.get("deploy_user_agents", True),
+            )
+
+            # Configure version behavior
+            settings["prefer_local_over_system"] = prompt_yes_no(
+                "Should local agents override system agents with same ID?",
+                default=settings.get("prefer_local_over_system", True),
+            )
+
+            settings["version_comparison"] = prompt_yes_no(
+                "Compare versions across sources and deploy highest?",
+                default=settings.get("version_comparison", True),
+            )
+
+            # Configure specific agents
+            choice = prompt_choice(
+                "How would you like to configure specific agents?",
+                [
+                    "No restrictions (all agents enabled)",
+                    "Specify disabled agents",
+                    "Specify enabled agents only",
+                ],
+            )
+
+            if choice == "No restrictions (all agents enabled)":
+                settings["enabled_agents"] = []
+                settings["disabled_agents"] = []
+            elif choice == "Specify disabled agents":
+                # Get list of available agents
+                from ...services.agents.listing_service import AgentListingService
+
+                listing_service = AgentListingService()
+                agents, _ = listing_service.list_all_agents()
+                agent_ids = sorted({agent.name for agent in agents})
+
+                if agent_ids:
+                    disabled = prompt_multiselect(
+                        "Select agents to disable:",
+                        agent_ids,
+                        default=settings.get("disabled_agents", []),
+                    )
+                    settings["disabled_agents"] = disabled
+                    settings["enabled_agents"] = []
+                else:
+                    print("No agents found to configure")
+            else:  # Specify enabled agents only
+                from ...services.agents.listing_service import AgentListingService
+
+                listing_service = AgentListingService()
+                agents, _ = listing_service.list_all_agents()
+                agent_ids = sorted({agent.name for agent in agents})
+
+                if agent_ids:
+                    enabled = prompt_multiselect(
+                        "Select agents to enable (others will be disabled):",
+                        agent_ids,
+                        default=settings.get("enabled_agents", []),
+                    )
+                    settings["enabled_agents"] = enabled
+                    settings["disabled_agents"] = []
+                else:
+                    print("No agents found to configure")
+
+            # Save configuration
+            config_data["agent_deployment"] = settings
+
+            # Ensure parent directory exists
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with config_path.open("w") as f:
+                yaml.dump(config_data, f, default_flow_style=False, sort_keys=False)
+
+            print(f"\n✅ Configuration saved to {config_path}")
+
+            # Show summary
+            print("\n📋 New Configuration Summary:")
+            print(
+                f"  System agents: {'Enabled' if settings.get('deploy_system_agents', True) else 'Disabled'}"
+            )
+            print(
+                f"  Local agents: {'Enabled' if settings.get('deploy_local_agents', True) else 'Disabled'}"
+            )
+            print(
+                f"  User agents: {'Enabled' if settings.get('deploy_user_agents', True) else 'Disabled'}"
+            )
+
+            if settings.get("enabled_agents"):
+                print(f"  Enabled specific: {', '.join(settings['enabled_agents'])}")
+            elif settings.get("disabled_agents"):
+                print(f"  Disabled specific: {', '.join(settings['disabled_agents'])}")
+            else:
+                print("  All agents enabled")
+
+            return CommandResult.success_result("Interactive configuration completed")
+
+        except KeyboardInterrupt:
+            print("\n\nConfiguration cancelled.")
+            return CommandResult.error_result("Configuration cancelled by user")
+        except Exception as e:
+            self.logger.error(f"Error in interactive configuration: {e}", exc_info=True)
+            return CommandResult.error_result(
+                f"Error in interactive configuration: {e}"
+            )
+
+    def _detect_toolchain(self, args) -> CommandResult:
+        """Detect project toolchain without deploying agents.
+
+        Part of TSK-0054 Phase 5: Auto-configuration CLI integration.
+        """
+        try:
+            from .agents_detect import AgentsDetectCommand
+
+            cmd = AgentsDetectCommand()
+            return cmd.run(args)
+        except Exception as e:
+            self.logger.error(f"Error detecting toolchain: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error detecting toolchain: {e}")
+
+    def _recommend_agents(self, args) -> CommandResult:
+        """Recommend agents based on project toolchain.
+
+        Part of TSK-0054 Phase 5: Auto-configuration CLI integration.
+        """
+        try:
+            from .agents_recommend import AgentsRecommendCommand
+
+            cmd = AgentsRecommendCommand()
+            return cmd.run(args)
+        except Exception as e:
+            self.logger.error(f"Error recommending agents: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error recommending agents: {e}")
+
 
 def manage_agents(args):
     """
@@ -887,7 +1459,7 @@ def manage_agents(args):
     result = command.execute(args)
 
     # Print result if structured output format is requested
-    if hasattr(args, "format") and args.format in ["json", "yaml"]:
+    if _is_structured_output(args):
         command.print_result(result, args)
 
     return result.exit_code