claude-mpm 5.4.48__py3-none-any.whl → 5.6.34__py3-none-any.whl

claude_mpm/cli/commands/skills.py

@@ -18,7 +18,7 @@ ARCHITECTURE:
 """
 
 import os
-import subprocess
+import subprocess  # nosec B404
 from typing import Optional
 
 from rich.console import Console
@@ -84,6 +84,7 @@ class SkillsManagementCommand(BaseCommand):
                 SkillsCommands.INFO.value: self._show_skill_info,
                 SkillsCommands.CONFIG.value: self._manage_config,
                 SkillsCommands.CONFIGURE.value: self._configure_skills,
+                SkillsCommands.SELECT.value: self._select_skills_interactive,
                 # GitHub deployment commands
                 SkillsCommands.DEPLOY_FROM_GITHUB.value: self._deploy_from_github,
                 SkillsCommands.LIST_AVAILABLE.value: self._list_available_github_skills,
@@ -504,7 +505,7 @@ class SkillsManagementCommand(BaseCommand):
                 # Open in editor
                 editor = os.environ.get("EDITOR", "nano")
                 try:
-                    subprocess.run([editor, str(config_path)], check=True)
+                    subprocess.run([editor, str(config_path)], check=True)  # nosec B603
                     console.print(
                         f"\n[green]Configuration saved to {config_path}[/green]\n"
                     )
@@ -537,6 +538,7 @@ class SkillsManagementCommand(BaseCommand):
             toolchain = getattr(args, "toolchain", None)
             categories = getattr(args, "categories", None)
             force = getattr(args, "force", False)
+            deploy_all = getattr(args, "all", False)
 
             if collection:
                 console.print(
@@ -547,14 +549,15 @@ class SkillsManagementCommand(BaseCommand):
                     "\n[bold cyan]Deploying skills from default collection...[/bold cyan]\n"
                 )
 
-            # Selective deployment is ALWAYS enabled (deploy only agent-referenced skills)
-            # This ensures only skills linked to deployed agents are deployed
+            # Use selective deployment unless --all flag is provided
+            # Selective mode deploys only agent-referenced skills
+            # --all mode deploys all available skills from the collection
             result = self.skills_deployer.deploy_skills(
                 collection=collection,
                 toolchain=toolchain,
                 categories=categories,
                 force=force,
-                selective=True,  # Always use selective deployment
+                selective=not deploy_all,
             )
 
             # Display results
@@ -673,33 +676,91 @@ class SkillsManagementCommand(BaseCommand):
     def _check_deployed_skills(self, args) -> CommandResult:
         """Check currently deployed skills in ~/.claude/skills/."""
         try:
-            result = self.skills_deployer.check_deployed_skills()
+            # Get deployed skills
+            deployed_result = self.skills_deployer.check_deployed_skills()
+            deployed_names = {skill["name"] for skill in deployed_result["skills"]}
 
             console.print("\n[bold cyan]Claude Code Skills Status:[/bold cyan]\n")
-            console.print(f"[dim]Directory: {result['claude_skills_dir']}[/dim]\n")
+            console.print(
+                f"[dim]Directory: {deployed_result['claude_skills_dir']}[/dim]\n"
+            )
+
+            # Fetch available skills from GitHub to get full list
+            try:
+                available_result = self.skills_deployer.list_available_skills()
+                all_skills = available_result.get("skills", [])
+            except Exception as e:
+                console.print(
+                    f"[yellow]Warning: Could not fetch available skills: {e}[/yellow]\n"
+                )
+                all_skills = []
 
-            if result["deployed_count"] == 0:
-                console.print("[yellow]No skills currently deployed.[/yellow]")
+            # Combine deployed and available skills
+            skill_map = {}
+
+            # Add available skills
+            for skill in all_skills:
+                skill_name = skill.get("name", "")
+                if skill_name:
+                    skill_map[skill_name] = {
+                        "name": skill.get("display_name")
+                        or skill_name.replace("-", " ").title(),
+                        "skill_id": skill_name,
+                        "source": "MPM Skills",
+                        "is_deployed": skill_name in deployed_names,
+                    }
+
+            # Add any deployed skills not in available list (local/custom skills)
+            for skill in deployed_result["skills"]:
+                skill_name = skill["name"]
+                if skill_name not in skill_map:
+                    skill_map[skill_name] = {
+                        "name": skill_name.replace("-", " ").title(),
+                        "skill_id": skill_name,
+                        "source": "Local",
+                        "is_deployed": True,
+                    }
+
+            if not skill_map:
+                console.print("[yellow]No skills available.[/yellow]")
                 console.print(
                     "[dim]Use 'claude-mpm skills deploy-github' to deploy skills.[/dim]\n"
                 )
                 return CommandResult(success=True, exit_code=0)
 
-            console.print(
-                f"[green]{result['deployed_count']} skill(s) deployed:[/green]\n"
+            # Create table matching agent management format
+            table = Table(show_header=True, header_style="bold cyan")
+            table.add_column("#", style="bright_black", width=6, no_wrap=True)
+            table.add_column(
+                "Skill ID", style="bright_black", no_wrap=True, overflow="ellipsis"
             )
+            table.add_column(
+                "Name", style="bright_cyan", no_wrap=True, overflow="ellipsis"
+            )
+            table.add_column("Source", style="bright_yellow", no_wrap=True)
+            table.add_column("Status", style="bright_black", no_wrap=True)
 
-            # Create table for deployed skills
-            table = Table(show_header=True, header_style="bold cyan")
-            table.add_column("Skill Name", style="green")
-            table.add_column("Path", style="dim")
+            # Sort skills by name for consistent display
+            sorted_skills = sorted(skill_map.values(), key=lambda s: s["skill_id"])
 
-            for skill in sorted(result["skills"], key=lambda s: s["name"]):
-                table.add_row(skill["name"], skill["path"])
+            for idx, skill in enumerate(sorted_skills, 1):
+                status = (
+                    "[green]Installed[/green]" if skill["is_deployed"] else "Available"
+                )
+                table.add_row(
+                    str(idx), skill["skill_id"], skill["name"], skill["source"], status
+                )
 
             console.print(table)
             console.print()
 
+            # Show summary
+            deployed_count = sum(1 for s in skill_map.values() if s["is_deployed"])
+            console.print(
+                f"[dim]Showing {len(skill_map)} skills ({deployed_count} installed, "
+                f"{len(skill_map) - deployed_count} available)[/dim]\n"
+            )
+
             return CommandResult(success=True, exit_code=0)
 
         except Exception as e:
@@ -1222,6 +1283,99 @@ class SkillsManagementCommand(BaseCommand):
             console.print(f"[dim]{traceback.format_exc()}[/dim]")
             return CommandResult(success=False, message=str(e), exit_code=1)
 
+    def _select_skills_interactive(self, args) -> CommandResult:
+        """Interactive skill selection with topic grouping.
+
+        This command provides a two-tier selection interface:
+        1. Select topic groups (toolchains) to explore
+        2. Multi-select skills within each topic group
+
+        Features:
+        - Groups skills by toolchain (universal, python, typescript, etc.)
+        - Shows skills auto-included by agent dependencies
+        - Displays token counts for each skill
+        - Updates config and runs reconciliation
+
+        Returns:
+            CommandResult with success/failure status
+        """
+        try:
+            from ...cli.interactive.skill_selector import run_skill_selector
+            from ...core.unified_config import UnifiedConfig
+            from ...services.agents.deployment.deployment_reconciler import (
+                DeploymentReconciler,
+            )
+
+            console.print("\n[bold cyan]Interactive Skill Selector[/bold cyan]\n")
+
+            # Run skill selector
+            selected_skills = run_skill_selector()
+
+            if selected_skills is None:
+                console.print("\n[yellow]Skill selection cancelled[/yellow]")
+                return CommandResult(success=True, exit_code=0)
+
+            # Update config with selected skills
+            config = UnifiedConfig()
+            config.skills.enabled = selected_skills
+
+            # Save config
+            try:
+                config.save()
+                console.print(
+                    f"\n[green]✓ Saved {len(selected_skills)} skills to configuration[/green]"
+                )
+            except Exception as e:
+                console.print(f"\n[red]Failed to save configuration: {e}[/red]")
+                return CommandResult(success=False, message=str(e), exit_code=1)
+
+            # Run reconciliation to deploy skills
+            console.print("\n[cyan]Running skill reconciliation...[/cyan]")
+            reconciler = DeploymentReconciler(config)
+
+            try:
+                from pathlib import Path
+
+                project_path = Path.cwd()
+                result = reconciler.reconcile_skills(project_path)
+
+                if result.deployed:
+                    console.print(
+                        f"  [green]✓ Deployed: {', '.join(result.deployed)}[/green]"
+                    )
+                if result.removed:
+                    console.print(
+                        f"  [yellow]✓ Removed: {', '.join(result.removed)}[/yellow]"
+                    )
+                if result.errors:
+                    for error in result.errors:
+                        console.print(f"  [red]✗ {error}[/red]")
+
+                if result.success:
+                    console.print(
+                        "\n[bold green]✓ Skill deployment complete![/bold green]"
+                    )
+                    return CommandResult(success=True, exit_code=0)
+                console.print(
+                    f"\n[yellow]⚠ Deployment had {len(result.errors)} errors[/yellow]"
+                )
+                return CommandResult(
+                    success=False,
+                    message=f"{len(result.errors)} deployment errors",
+                    exit_code=1,
+                )
+
+            except Exception as e:
+                console.print(f"\n[red]Reconciliation failed: {e}[/red]")
+                return CommandResult(success=False, message=str(e), exit_code=1)
+
+        except Exception as e:
+            console.print(f"[red]Skill selection error: {e}[/red]")
+            import traceback
+
+            console.print(f"[dim]{traceback.format_exc()}[/dim]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
 
 def manage_skills(args) -> int:
     """

claude_mpm/cli/executor.py

@@ -66,6 +66,7 @@ def ensure_run_attributes(args):
     args.monitor = getattr(args, "monitor", False)
     args.force = getattr(args, "force", False)
     args.reload_agents = getattr(args, "reload_agents", False)
+    args.force_sync = getattr(args, "force_sync", False)
     # Include dependency checking attributes
     args.check_dependencies = getattr(args, "check_dependencies", True)
     args.force_check_dependencies = getattr(args, "force_check_dependencies", False)
@@ -126,6 +127,14 @@ def execute_command(command: str, args) -> int:
         result = handle_verify(args)
         return result if result is not None else 0
 
+    # Handle commander command with lazy import
+    if command == "commander":
+        # Lazy import to avoid loading unless needed
+        from .commands.commander import handle_commander_command
+
+        result = handle_commander_command(args)
+        return result if result is not None else 0
+
     # Handle skill-source command with lazy import
     if command == "skill-source":
         # Lazy import to avoid loading unless needed
@@ -205,35 +214,127 @@ def execute_command(command: str, args) -> int:
             "status": show_status,
         }
 
-        # Get handler and invoke
+        # Get handler and call it with argument list (same pattern as autotodos)
         handler = handlers.get(subcommand)
         if handler:
-            # Build Click context programmatically
-            import click
+            try:
+                # Build argument list for Click command based on subcommand
+                click_args = []
+
+                # list command: --format, --hook-type
+                if subcommand == "list":
+                    if hasattr(args, "format") and args.format:
+                        click_args.extend(["--format", args.format])
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                # clear command: --hook-type, -y
+                elif subcommand == "clear":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                    if hasattr(args, "yes") and args.yes:
+                        click_args.append("-y")
+                # diagnose command: hook_type (positional argument)
+                elif subcommand == "diagnose":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.append(args.hook_type)
+                # status and summary commands: no options
+
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
+                return 0
+            except SystemExit as e:
+                return e.code if e.code is not None else 0
+            except Exception as e:
+                print(f"Error: {e}")
+                return 1
+        else:
+            print(f"Unknown hook-errors subcommand: {subcommand}")
+            return 1
 
-            ctx = click.Context(command=handler)
+    # Handle autotodos command with lazy import
+    if command == "autotodos":
+        # Lazy import to avoid loading unless needed
+        from .commands.autotodos import (
+            clear_autotodos,
+            inject_autotodos,
+            list_autotodos,
+            list_pm_violations,
+            scan_delegation_patterns,
+            show_autotodos_status,
+        )
 
-            # Prepare keyword arguments from args
-            kwargs = {}
-            if hasattr(args, "format"):
-                kwargs["format"] = args.format
-            if hasattr(args, "hook_type"):
-                kwargs["hook_type"] = args.hook_type
-            if hasattr(args, "yes"):
-                kwargs["yes"] = args.yes
+        # Get subcommand
+        subcommand = getattr(args, "autotodos_command", "status")
+        if not subcommand:
+            subcommand = "status"
 
+        # Map subcommands to functions
+        handlers = {
+            "list": list_autotodos,
+            "inject": inject_autotodos,
+            "clear": clear_autotodos,
+            "status": show_autotodos_status,
+            "scan": scan_delegation_patterns,
+            "violations": list_pm_violations,
+        }
+
+        # Get handler and call it with standalone_mode=False
+        handler = handlers.get(subcommand)
+        if handler:
             try:
-                # Invoke handler with arguments
-                with ctx:
-                    handler.invoke(ctx, **kwargs)
+                # Build argument list for Click command
+                click_args = []
+
+                if subcommand == "list":
+                    fmt = getattr(args, "format", "table")
+                    click_args = ["--format", fmt]
+                elif subcommand == "inject":
+                    output = getattr(args, "output", None)
+                    if output:
+                        click_args = ["--output", output]
+                elif subcommand == "clear":
+                    error_key = getattr(args, "error_key", None)
+                    event_type = getattr(args, "event_type", "all")
+                    if error_key:
+                        click_args.append("--error-key")
+                        click_args.append(error_key)
+                    if event_type != "all":
+                        click_args.append("--event-type")
+                        click_args.append(event_type)
+                    if getattr(args, "yes", False):
+                        click_args.append("-y")
+                elif subcommand == "scan":
+                    text = getattr(args, "text", None)
+                    file = getattr(args, "file", None)
+                    fmt = getattr(args, "format", "table")
+                    save = getattr(args, "save", False)
+
+                    if text:
+                        click_args.append(text)
+                    if file:
+                        click_args.extend(["--file", file])
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+                    if save:
+                        click_args.append("--save")
+                elif subcommand == "violations":
+                    fmt = getattr(args, "format", "table")
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
                 return 0
             except SystemExit as e:
                 return e.code if e.code is not None else 0
             except Exception as e:
                 print(f"Error: {e}")
+                import traceback
+
+                traceback.print_exc()
                 return 1
         else:
-            print(f"Unknown hook-errors subcommand: {subcommand}")
+            print(f"Unknown autotodos subcommand: {subcommand}")
             return 1
 
     # Map stable commands to their implementations
@@ -259,6 +360,7 @@ def execute_command(command: str, args) -> int:
         CLICommands.SKILLS.value: manage_skills,
         "debug": manage_debug,  # Add debug command
         "mpm-init": None,  # Will be handled separately with lazy import
+        "commander": None,  # Will be handled separately with lazy import
     }
 
     # Execute command if found
@@ -286,6 +388,8 @@ def execute_command(command: str, args) -> int:
         "local-deploy",
         "skill-source",
         "agent-source",
+        "hook-errors",
+        "autotodos",
     ]
 
     suggestion = suggest_similar_commands(command, all_commands)

claude_mpm/cli/interactive/__init__.py

@@ -10,12 +10,22 @@ from .agent_wizard import (
     run_interactive_agent_manager,
     run_interactive_agent_wizard,
 )
+from .questionary_styles import (
+    BANNER_WIDTH,
+    MPM_STYLE,
+    print_banner,
+    print_section_header,
+)
 from .skills_wizard import SkillsWizard, discover_and_link_runtime_skills
 
 __all__ = [
+    "BANNER_WIDTH",
+    "MPM_STYLE",
     "AgentWizard",
     "SkillsWizard",
     "discover_and_link_runtime_skills",
+    "print_banner",
+    "print_section_header",
     "run_interactive_agent_manager",
     "run_interactive_agent_wizard",
 ]

claude_mpm/cli/interactive/agent_wizard.py

@@ -12,8 +12,12 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 import questionary
-from questionary import Style
 
+from claude_mpm.cli.interactive.questionary_styles import (
+    BANNER_WIDTH,
+    MPM_STYLE,
+    print_section_header,
+)
 from claude_mpm.core.logging_config import get_logger
 from claude_mpm.services.agents.local_template_manager import (
     LocalAgentTemplate,
@@ -23,16 +27,6 @@ from claude_mpm.utils.agent_filters import apply_all_filters
 
 logger = get_logger(__name__)
 
-# Questionary style matching Rich cyan theme (consistent with configure.py)
-QUESTIONARY_STYLE = Style(
-    [
-        ("selected", "fg:cyan bold"),
-        ("pointer", "fg:cyan bold"),
-        ("highlighted", "fg:cyan"),
-        ("question", "fg:cyan bold"),
-    ]
-)
-
 
 class AgentWizard:
     """
@@ -113,9 +107,7 @@ class AgentWizard:
             Tuple of (success, message)
         """
         try:
-            print("\n" + "=" * 60)
-            print("🧙‍♂️  Agent Creation Wizard")
-            print("=" * 60)
+            print_section_header("🧙‍♂️", "Agent Creation Wizard", width=BANNER_WIDTH)
             print("\nI'll guide you through creating a custom local agent.")
             print("Press Ctrl+C anytime to cancel.\n")
 
@@ -281,9 +273,7 @@ class AgentWizard:
                 # Get merged agents from all sources
                 all_agents = self._merge_agent_sources()
 
-                print("\n" + "=" * 60)
-                print("🔧  Agent Management Menu")
-                print("=" * 60)
+                print_section_header("🔧", "Agent Management Menu", width=BANNER_WIDTH)
 
                 if not all_agents:
                     print(
@@ -384,7 +374,7 @@ class AgentWizard:
                 choice = questionary.select(
                     "Agent Management Menu:",
                     choices=menu_choices,
-                    style=QUESTIONARY_STYLE,
+                    style=MPM_STYLE,
                 ).ask()
 
                 if not choice:  # User pressed Esc
@@ -776,9 +766,7 @@ class AgentWizard:
 
     def _confirm_creation(self, config: Dict[str, Any]) -> bool:
         """Show preview and get confirmation from user."""
-        print("\n" + "=" * 60)
-        print("📋  Agent Configuration Preview")
-        print("=" * 60)
+        print_section_header("📋", "Agent Configuration Preview", width=BANNER_WIDTH)
 
         print(f"Agent ID:     {config['agent_id']}")
         print(f"Name:         {config['name']}")
@@ -795,7 +783,8 @@ class AgentWizard:
         print("\nInstructions Preview:")
         print(f"  {config['instructions_preview']}")
 
-        print("\n" + "=" * 60)
+        print()
+        print("=" * BANNER_WIDTH)
 
         while True:
             confirm = input("\nCreate this agent? [Y/n]: ").strip().lower()
@@ -1046,8 +1035,7 @@ class AgentWizard:
 
     def _interactive_delete_menu(self, templates: list) -> Tuple[bool, str]:
         """Interactive deletion menu for multiple agents."""
-        print("\n🗑️  Delete Agents")
-        print("=" * 50)
+        print_section_header("🗑️", "Delete Agents", width=BANNER_WIDTH)
 
         if not templates:
             return False, "No agents available to delete"
@@ -1154,9 +1142,9 @@ class AgentWizard:
         Args:
             agent: Agent metadata dictionary
         """
-        print("\n" + "=" * 60)
-        print(f"📄 Agent Details: {agent['agent_id']}")
-        print("=" * 60)
+        print_section_header(
+            "📄", f"Agent Details: {agent['agent_id']}", width=BANNER_WIDTH
+        )
         print(f"Name:         {agent['name']}")
         print(f"Category:     {agent['category'] or 'N/A'}")
         print(f"Source:       [{agent['source_type']}] {agent['source_identifier']}")
@@ -1188,9 +1176,7 @@ class AgentWizard:
             input("\nPress Enter to continue...")
             return
 
-        print("\n" + "=" * 60)
-        print("📦 Deploy Agent")
-        print("=" * 60)
+        print_section_header("📦", "Deploy Agent", width=BANNER_WIDTH)
         print(f"\n{len(deployable)} agent(s) available to deploy:\n")
 
         # Build agent selection choices with arrow-key navigation
@@ -1200,7 +1186,7 @@ class AgentWizard:
         ]
 
         choice = questionary.select(
-            "Select agent to deploy:", choices=agent_choices, style=QUESTIONARY_STYLE
+            "Select agent to deploy:", choices=agent_choices, style=MPM_STYLE
         ).ask()
 
         if not choice:  # User pressed Esc
@@ -1296,9 +1282,7 @@ class AgentWizard:
             return
 
         while True:
-            print("\n" + "=" * 60)
-            print("🔍 Browse & Filter Agents")
-            print("=" * 60)
+            print_section_header("🔍", "Browse & Filter Agents", width=BANNER_WIDTH)
 
             # Show filter menu with arrow-key navigation
             print("\n[bold]Filter by:[/bold]")
@@ -1314,7 +1298,7 @@ class AgentWizard:
             choice = questionary.select(
                 "Browse & Filter Agents:",
                 choices=filter_choices,
-                style=QUESTIONARY_STYLE,
+                style=MPM_STYLE,
             ).ask()
 
             if not choice or "Back" in choice:
@@ -1343,7 +1327,7 @@ class AgentWizard:
                 cat_choices = [f"{idx}. {cat}" for idx, cat in enumerate(categories, 1)]
 
                 cat_choice = questionary.select(
-                    "Select category:", choices=cat_choices, style=QUESTIONARY_STYLE
+                    "Select category:", choices=cat_choices, style=MPM_STYLE
                 ).ask()
 
                 if not cat_choice:  # User pressed Esc
@@ -1457,9 +1441,11 @@ class AgentWizard:
                 continue
 
             # Display filtered results
-            print("\n" + "=" * 60)
-            print(f"📋 {filter_description} ({len(filtered_agents)} agents)")
-            print("=" * 60)
+            print_section_header(
+                "📋",
+                f"{filter_description} ({len(filtered_agents)} agents)",
+                width=BANNER_WIDTH,
+            )
 
             if not filtered_agents:
                 print("\n[yellow]No agents found matching filter[/yellow]")
@@ -1523,7 +1509,7 @@ class AgentWizard:
         ]
 
         agent_choice = questionary.select(
-            "Select agent to deploy:", choices=agent_choices, style=QUESTIONARY_STYLE
+            "Select agent to deploy:", choices=agent_choices, style=MPM_STYLE
         ).ask()
 
         if not agent_choice:  # User pressed Esc
@@ -1629,7 +1615,7 @@ class AgentWizard:
         ]
 
         agent_choice = questionary.select(
-            "Select agent to view:", choices=agent_choices, style=QUESTIONARY_STYLE
+            "Select agent to view:", choices=agent_choices, style=MPM_STYLE
         ).ask()
 
         if not agent_choice:  # User pressed Esc
@@ -1652,9 +1638,7 @@ class AgentWizard:
         preset_service = AgentPresetService(self.source_manager)
 
         while True:
-            print("\n" + "=" * 60)
-            print("📦 Deploy Agent Preset")
-            print("=" * 60)
+            print_section_header("📦", "Deploy Agent Preset", width=BANNER_WIDTH)
 
             # List available presets
             presets = preset_service.list_presets()
@@ -1690,9 +1674,7 @@ class AgentWizard:
                 preset_name = presets[idx]["name"]
 
                 # Show preset details
-                print("\n" + "=" * 60)
-                print(f"📦 Preset: {preset_name}")
-                print("=" * 60)
+                print_section_header("📦", f"Preset: {preset_name}", width=BANNER_WIDTH)
                 print(f"\n[bold]Description:[/bold] {presets[idx]['description']}\n")
 
                 # Resolve preset
@@ -1872,9 +1854,7 @@ class AgentWizard:
             input("\nPress Enter to continue...")
             return
 
-        print("\n" + "=" * 60)
-        print("🔗 Manage Agent Sources")
-        print("=" * 60)
+        print_section_header("🔗", "Manage Agent Sources", width=BANNER_WIDTH)
 
         try:
             from claude_mpm.config.agent_sources import AgentSourceConfiguration