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

claude_mpm/cli/commands/agents.py

@@ -15,6 +15,7 @@ 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
@@ -27,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."""
 
@@ -87,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
@@ -122,6 +156,9 @@ class AgentsCommand(AgentCommand):
                 "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:
@@ -142,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)
@@ -163,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)
@@ -185,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)
@@ -196,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={
@@ -217,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
@@ -256,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
@@ -281,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}")
@@ -303,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 = {
@@ -386,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(
@@ -412,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(
@@ -450,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(
@@ -472,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."""
@@ -693,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
             )
@@ -705,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)
@@ -863,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
@@ -1361,6 +1420,34 @@ class AgentsCommand(AgentCommand):
                 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):
     """
@@ -1372,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