claude-mpm 5.4.41__py3-none-any.whl → 5.6.23__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,7 +538,7 @@ class SkillsManagementCommand(BaseCommand):
             toolchain = getattr(args, "toolchain", None)
             categories = getattr(args, "categories", None)
             force = getattr(args, "force", False)
-            all_skills = getattr(args, "all_skills", False)
+            deploy_all = getattr(args, "all", False)
 
             if collection:
                 console.print(
@@ -548,23 +549,15 @@ class SkillsManagementCommand(BaseCommand):
                     "\n[bold cyan]Deploying skills from default collection...[/bold cyan]\n"
                 )
 
-            # Auto-detect toolchain if not specified and not deploying all
-            if not toolchain and not all_skills:
-                console.print(
-                    "[yellow]No toolchain specified. Use --toolchain to filter by language,[/yellow]"
-                )
-                console.print(
-                    "[yellow]or --all-skills to deploy all available skills (not just agent-referenced).[/yellow]\n"
-                )
-
-            # Selective deployment is enabled by default (deploy only agent-referenced skills)
-            # Use --all-skills to disable selective mode
+            # 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=not all_skills,  # Disable selective mode if --all-skills is set
+                selective=not deploy_all,
             )
 
             # Display results
@@ -577,11 +570,7 @@ class SkillsManagementCommand(BaseCommand):
                     f"(out of {total_available} available)[/cyan]"
                 )
                 console.print(
-                    "[dim]Use --all-skills to deploy all available skills[/dim]\n"
-                )
-            else:
-                console.print(
-                    "[cyan]📦 Deploying all available skills (selective mode disabled)[/cyan]\n"
+                    "[dim]Use 'claude-mpm skills configure' to manually select skills[/dim]\n"
                 )
 
             if result["deployed_count"] > 0:
@@ -606,6 +595,16 @@ class SkillsManagementCommand(BaseCommand):
                     console.print(f"  • {error}")
                 console.print()
 
+            # Show cleanup results
+            cleanup = result.get("cleanup", {})
+            if cleanup.get("removed_count", 0) > 0:
+                console.print(
+                    f"[yellow]🧹 Removed {cleanup['removed_count']} orphaned skill(s):[/yellow]"
+                )
+                for skill in cleanup.get("removed_skills", []):
+                    console.print(f"  • {skill}")
+                console.print()
+
             # Show restart instructions
             if result["restart_instructions"]:
                 console.print(
@@ -677,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:
@@ -1226,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",
 ]