claude-mpm 4.13.2__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
@@ -145,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)
@@ -166,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)
@@ -188,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)
@@ -199,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={
@@ -220,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
@@ -259,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
@@ -284,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}")
@@ -306,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 = {
@@ -389,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(
@@ -415,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(
@@ -453,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(
@@ -475,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."""
@@ -696,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
             )
@@ -708,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)
@@ -866,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
@@ -1403,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

claude_mpm/cli/commands/aggregate.py

@@ -16,6 +16,7 @@ import json
 import sys
 from typing import Optional
 
+from ...core.enums import OutputFormat
 from ...core.logger import get_logger
 from ...services.event_aggregator import (
     aggregator_status,
@@ -110,7 +111,10 @@ def aggregate_command(args):
     result = command.execute(args)
 
     # Print result if structured output format is requested
-    if hasattr(args, "format") and args.format in ["json", "yaml"]:
+    if hasattr(args, "format") and str(args.format).lower() in (
+        OutputFormat.JSON,
+        OutputFormat.YAML,
+    ):
         command.print_result(result, args)
 
     return result.exit_code
@@ -407,7 +411,7 @@ def export_command_legacy(args):
         output_path = Path(f"session_{session.session_id[:8]}_export.json")
 
     # Export based on format
-    if args.format == "json":
+    if str(args.format).lower() == OutputFormat.JSON:
         # Full JSON export
         with output_path.open("w") as f:
             json.dump(session.to_dict(), f, indent=2)
@@ -529,7 +533,7 @@ def add_aggregate_parser(subparsers):
         "--format",
         "-f",
         choices=["json", "summary", "events"],
-        default="json",
+        default=OutputFormat.JSON,
         help="Export format (default: json)",
     )
 

claude_mpm/cli/commands/analyze.py

@@ -23,6 +23,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional
 
+from ...core.enums import OutputFormat
 from ...core.logging_config import get_logger
 from ...services.cli.session_manager import SessionManager
 from ..shared import BaseCommand, CommandResult
@@ -132,7 +133,11 @@ class AnalyzeCommand(BaseCommand):
             self._save_output(output, args.output)
 
         return CommandResult.success_result(
-            message=output if args.format == "text" else "Analysis completed",
+            message=(
+                output
+                if str(args.format).lower() == OutputFormat.TEXT
+                else "Analysis completed"
+            ),
             data=result_data,
         )
 
@@ -422,7 +427,7 @@ class AnalyzeCommand(BaseCommand):
         Returns:
             Formatted output string
         """
-        if format_type == "json":
+        if str(format_type).lower() == OutputFormat.JSON:
             result_data["diagrams"] = diagrams
             return json.dumps(result_data, indent=2)
 
@@ -516,7 +521,7 @@ def analyze_command(args):
     result = command.run(args)
 
     if result.success:
-        if args.format == "json":
+        if str(args.format).lower() == OutputFormat.JSON:
             print(json.dumps(result.data, indent=2))
         else:
             print(result.message)
@@ -540,7 +545,7 @@ if __name__ == "__main__":
     parser.add_argument("--focus", nargs="+")
     parser.add_argument("--session-id", type=str)
     parser.add_argument("--no-session", action="store_true")
-    parser.add_argument("--format", default="text")
+    parser.add_argument("--format", default=OutputFormat.TEXT)
     parser.add_argument("--output", type=Path)
     parser.add_argument("--verbose", action="store_true")
 

claude_mpm/cli/commands/analyze_code.py

@@ -37,6 +37,7 @@ except ImportError:
     RICH_AVAILABLE = False
     Console = None
 
+from ...core.enums import OutputFormat
 from ...core.logging_config import get_logger
 from ...tools.code_tree_analyzer import CodeTreeAnalyzer
 from ...tools.code_tree_builder import CodeTreeBuilder
@@ -73,7 +74,11 @@ class AnalyzeCodeCommand(BaseCommand):
             return f"Path is not a directory: {path}"
 
         # Validate output format
-        if args.output and args.output not in ("json", "tree", "stats"):
+        if args.output and str(args.output).lower() not in (
+            OutputFormat.JSON,
+            "tree",
+            "stats",
+        ):
             return f"Invalid output format: {args.output}"
 
         return None
@@ -123,7 +128,7 @@ class AnalyzeCodeCommand(BaseCommand):
             )
 
             # Handle output format
-            if args.output == "json":
+            if str(args.output).lower() == OutputFormat.JSON:
                 # Output JSON to stdout
                 json.dump(analysis_result, sys.stdout, indent=2, default=str)
                 sys.stdout.write("\n")

claude_mpm/cli/commands/auto_configure.py

@@ -26,12 +26,10 @@ try:
 except ImportError:
     RICH_AVAILABLE = False
 
+from ...core.enums import OperationResult
 from ...services.agents.auto_config_manager import AutoConfigManagerService
 from ...services.agents.observers import NullObserver
-from ...services.core.models.agent_config import (
-    ConfigurationResult,
-    ConfigurationStatus,
-)
+from ...services.core.models.agent_config import ConfigurationResult
 from ..shared import BaseCommand, CommandResult
 
 
@@ -419,7 +417,7 @@ class AutoConfigureCommand(BaseCommand):
             return self._display_result_plain(result)
 
         # Display summary
-        if result.status == ConfigurationStatus.SUCCESS:
+        if result.status == OperationResult.SUCCESS:
             panel = Panel(
                 f"✅ Auto-configuration completed successfully!\n\n"
                 f"Deployed {len(result.deployed_agents)} agent(s)",
@@ -436,7 +434,7 @@ class AutoConfigureCommand(BaseCommand):
 
             return CommandResult.success_result()
 
-        if result.status == ConfigurationStatus.PARTIAL_SUCCESS:
+        if result.status == OperationResult.WARNING:
             panel = Panel(
                 f"⚠️  Auto-configuration partially completed\n\n"
                 f"Deployed: {len(result.deployed_agents)}\n"
@@ -465,7 +463,7 @@ class AutoConfigureCommand(BaseCommand):
 
     def _display_result_plain(self, result: ConfigurationResult) -> CommandResult:
         """Display result in plain text (fallback)."""
-        if result.status == ConfigurationStatus.SUCCESS:
+        if result.status == OperationResult.SUCCESS:
             print("\n✅ Auto-configuration completed successfully!")
             print(f"Deployed {len(result.deployed_agents)} agent(s)")
 
@@ -476,7 +474,7 @@ class AutoConfigureCommand(BaseCommand):
 
             return CommandResult.success_result()
 
-        if result.status == ConfigurationStatus.PARTIAL_SUCCESS:
+        if result.status == OperationResult.WARNING:
             print("\n⚠️  Auto-configuration partially completed")
             print(f"Deployed: {len(result.deployed_agents)}")
             print(f"Failed: {len(result.failed_agents)}")
@@ -565,7 +563,7 @@ class AutoConfigureCommand(BaseCommand):
 
         print(json.dumps(output, indent=2))
 
-        if result.status == ConfigurationStatus.SUCCESS:
+        if result.status == OperationResult.SUCCESS:
             return CommandResult.success_result(data=output)
         return CommandResult.error_result(
             "Configuration failed or partial", exit_code=1, data=output