claude-mpm 4.21.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

claude_mpm/cli/commands/skills.py

@@ -3,13 +3,18 @@ Skills command implementation for claude-mpm.
 
 WHY: This module provides CLI commands for managing Claude Code skills,
 exposing SkillsService functionality for skill discovery, deployment, validation,
-updates, and configuration.
+updates, and configuration. Also provides GitHub skills deployment via SkillsDeployer.
 
 DESIGN DECISIONS:
 - Use BaseCommand pattern for consistency with other CLI commands
 - Rich output formatting for user-friendly display
 - Graceful error handling with informative messages
 - Support for verbose output and structured formats
+- Dual service approach: SkillsService for bundled, SkillsDeployer for GitHub
+
+ARCHITECTURE:
+- SkillsService: Manages bundled skills (in project .claude/skills/)
+- SkillsDeployer: Downloads from GitHub to ~/.claude/skills/ for Claude Code
 """
 
 import os
@@ -19,8 +24,10 @@ from typing import Optional
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.panel import Panel
+from rich.table import Table
 
 from ...constants import SkillsCommands
+from ...services.skills_deployer import SkillsDeployerService
 from ...skills.skills_service import SkillsService
 from ..shared import BaseCommand, CommandResult
 
@@ -33,6 +40,7 @@ class SkillsManagementCommand(BaseCommand):
     def __init__(self):
         super().__init__("skills")
         self._skills_service = None
+        self._skills_deployer = None
 
     @property
     def skills_service(self) -> SkillsService:
@@ -41,6 +49,13 @@ class SkillsManagementCommand(BaseCommand):
             self._skills_service = SkillsService()
         return self._skills_service
 
+    @property
+    def skills_deployer(self) -> SkillsDeployerService:
+        """Get skills deployer instance (lazy loaded)."""
+        if self._skills_deployer is None:
+            self._skills_deployer = SkillsDeployerService()
+        return self._skills_deployer
+
     def validate_args(self, args) -> Optional[str]:
         """Validate command arguments."""
         # Most skills commands are optional, basic validation
@@ -68,6 +83,18 @@ class SkillsManagementCommand(BaseCommand):
                 SkillsCommands.UPDATE.value: self._update_skills,
                 SkillsCommands.INFO.value: self._show_skill_info,
                 SkillsCommands.CONFIG.value: self._manage_config,
+                # GitHub deployment commands
+                SkillsCommands.DEPLOY_FROM_GITHUB.value: self._deploy_from_github,
+                SkillsCommands.LIST_AVAILABLE.value: self._list_available_github_skills,
+                SkillsCommands.CHECK_DEPLOYED.value: self._check_deployed_skills,
+                SkillsCommands.REMOVE.value: self._remove_skills,
+                # Collection management commands
+                SkillsCommands.COLLECTION_LIST.value: self._collection_list,
+                SkillsCommands.COLLECTION_ADD.value: self._collection_add,
+                SkillsCommands.COLLECTION_REMOVE.value: self._collection_remove,
+                SkillsCommands.COLLECTION_ENABLE.value: self._collection_enable,
+                SkillsCommands.COLLECTION_DISABLE.value: self._collection_disable,
+                SkillsCommands.COLLECTION_SET_DEFAULT.value: self._collection_set_default,
             }
 
             handler = command_map.get(args.skills_command)
@@ -448,6 +475,209 @@ class SkillsManagementCommand(BaseCommand):
             console.print(f"[red]Error managing configuration: {e}[/red]")
             return CommandResult(success=False, message=str(e), exit_code=1)
 
+    def _deploy_from_github(self, args) -> CommandResult:
+        """Deploy skills from GitHub repository."""
+        try:
+            collection = getattr(args, "collection", None)
+            toolchain = getattr(args, "toolchain", None)
+            categories = getattr(args, "categories", None)
+            force = getattr(args, "force", False)
+            all_skills = getattr(args, "all", False)
+
+            if collection:
+                console.print(
+                    f"\n[bold cyan]Deploying skills from collection '{collection}'...[/bold cyan]\n"
+                )
+            else:
+                console.print(
+                    "\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 to deploy all available skills.[/yellow]\n"
+                )
+
+            result = self.skills_deployer.deploy_skills(
+                collection=collection,
+                toolchain=toolchain,
+                categories=categories,
+                force=force,
+            )
+
+            # Display results
+            if result["deployed_count"] > 0:
+                console.print(
+                    f"[green]✓ Deployed {result['deployed_count']} skill(s):[/green]"
+                )
+                for skill in result["deployed_skills"]:
+                    console.print(f"  • {skill}")
+                console.print()
+
+            if result["skipped_count"] > 0:
+                console.print(
+                    f"[yellow]⊘ Skipped {result['skipped_count']} skill(s) (already deployed):[/yellow]"
+                )
+                for skill in result["skipped_skills"]:
+                    console.print(f"  • {skill}")
+                console.print("[dim]Use --force to redeploy[/dim]\n")
+
+            if result["errors"]:
+                console.print(f"[red]✗ {len(result['errors'])} error(s):[/red]")
+                for error in result["errors"]:
+                    console.print(f"  • {error}")
+                console.print()
+
+            # Show restart instructions
+            if result["restart_instructions"]:
+                console.print(
+                    Panel(
+                        result["restart_instructions"],
+                        title="⚠️  Important",
+                        border_style="yellow",
+                    )
+                )
+                console.print()
+
+            exit_code = 1 if result["errors"] else 0
+            return CommandResult(success=not result["errors"], exit_code=exit_code)
+
+        except Exception as e:
+            console.print(f"[red]Error deploying from GitHub: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _list_available_github_skills(self, args) -> CommandResult:
+        """List available skills from GitHub repository."""
+        try:
+            collection = getattr(args, "collection", None)
+
+            if collection:
+                console.print(
+                    f"\n[bold cyan]Fetching skills from collection '{collection}'...[/bold cyan]\n"
+                )
+            else:
+                console.print(
+                    "\n[bold cyan]Fetching skills from default collection...[/bold cyan]\n"
+                )
+
+            result = self.skills_deployer.list_available_skills(collection=collection)
+
+            if result.get("error"):
+                console.print(f"[red]Error: {result['error']}[/red]")
+                return CommandResult(
+                    success=False, message=result["error"], exit_code=1
+                )
+
+            console.print(
+                f"[green]Found {result['total_skills']} available skills[/green]\n"
+            )
+
+            # Display by category
+            console.print("[bold yellow]By Category:[/bold yellow]\n")
+            for category, skills in sorted(result["by_category"].items()):
+                console.print(f"  [cyan]{category}[/cyan] ({len(skills)} skills)")
+                if hasattr(args, "verbose") and args.verbose:
+                    for skill in sorted(skills, key=lambda s: s.get("name", "")):
+                        console.print(f"    • {skill.get('name', 'unknown')}")
+            console.print()
+
+            # Display by toolchain
+            console.print("[bold yellow]By Toolchain:[/bold yellow]\n")
+            for toolchain, skills in sorted(result["by_toolchain"].items()):
+                console.print(f"  [cyan]{toolchain}[/cyan] ({len(skills)} skills)")
+                if hasattr(args, "verbose") and args.verbose:
+                    for skill in sorted(skills, key=lambda s: s.get("name", "")):
+                        console.print(f"    • {skill.get('name', 'unknown')}")
+            console.print()
+
+            return CommandResult(success=True, exit_code=0)
+
+        except Exception as e:
+            console.print(f"[red]Error listing available skills: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _check_deployed_skills(self, args) -> CommandResult:
+        """Check currently deployed skills in ~/.claude/skills/."""
+        try:
+            result = self.skills_deployer.check_deployed_skills()
+
+            console.print("\n[bold cyan]Claude Code Skills Status:[/bold cyan]\n")
+            console.print(f"[dim]Directory: {result['claude_skills_dir']}[/dim]\n")
+
+            if result["deployed_count"] == 0:
+                console.print("[yellow]No skills currently deployed.[/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 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")
+
+            for skill in sorted(result["skills"], key=lambda s: s["name"]):
+                table.add_row(skill["name"], skill["path"])
+
+            console.print(table)
+            console.print()
+
+            return CommandResult(success=True, exit_code=0)
+
+        except Exception as e:
+            console.print(f"[red]Error checking deployed skills: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _remove_skills(self, args) -> CommandResult:
+        """Remove deployed skills."""
+        try:
+            skill_names = getattr(args, "skill_names", None)
+            remove_all = getattr(args, "all", False)
+
+            if remove_all:
+                skill_names = None
+                console.print(
+                    "\n[bold yellow]Removing ALL deployed skills...[/bold yellow]\n"
+                )
+            elif skill_names:
+                console.print(
+                    f"\n[bold cyan]Removing {len(skill_names)} skill(s)...[/bold cyan]\n"
+                )
+            else:
+                console.print("[red]Error: Specify skill names or use --all[/red]")
+                return CommandResult(success=False, exit_code=1)
+
+            result = self.skills_deployer.remove_skills(skill_names)
+
+            if result["removed_count"] > 0:
+                console.print(
+                    f"[green]✓ Removed {result['removed_count']} skill(s):[/green]"
+                )
+                for skill in result["removed_skills"]:
+                    console.print(f"  • {skill}")
+                console.print()
+
+            if result["errors"]:
+                console.print(f"[red]✗ {len(result['errors'])} error(s):[/red]")
+                for error in result["errors"]:
+                    console.print(f"  • {error}")
+                console.print()
+
+            exit_code = 1 if result["errors"] else 0
+            return CommandResult(success=not result["errors"], exit_code=exit_code)
+
+        except Exception as e:
+            console.print(f"[red]Error removing skills: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
     def _get_skill_metadata(self, skill_name: str) -> Optional[dict]:
         """Get skill metadata from SKILL.md file."""
         try:
@@ -464,6 +694,210 @@ class SkillsManagementCommand(BaseCommand):
         except Exception:
             return None
 
+    # === Collection Management Commands ===
+
+    def _collection_list(self, args) -> CommandResult:
+        """List all configured skill collections."""
+        try:
+            result = self.skills_deployer.list_collections()
+
+            console.print("\n[bold cyan]Skill Collections:[/bold cyan]\n")
+            console.print(
+                f"[dim]Default collection: {result['default_collection']}[/dim]"
+            )
+            console.print(
+                f"[dim]Enabled: {result['enabled_count']} / {result['total_count']}[/dim]\n"
+            )
+
+            if not result["collections"]:
+                console.print("[yellow]No collections configured.[/yellow]")
+                console.print(
+                    "[dim]Use 'claude-mpm skills collection-add' to add a collection.[/dim]\n"
+                )
+                return CommandResult(success=True, exit_code=0)
+
+            # Create table for collections
+            table = Table(show_header=True, header_style="bold cyan")
+            table.add_column("Name", style="green")
+            table.add_column("URL", style="white")
+            table.add_column("Priority", justify="center")
+            table.add_column("Enabled", justify="center")
+            table.add_column("Last Update", style="dim")
+            table.add_column("Default", justify="center")
+
+            # Sort by priority
+            sorted_collections = sorted(
+                result["collections"].items(), key=lambda x: x[1].get("priority", 999)
+            )
+
+            for name, config in sorted_collections:
+                enabled_icon = "✓" if config.get("enabled", True) else "✗"
+                default_icon = "⭐" if name == result["default_collection"] else ""
+                last_update = config.get("last_update") or "Never"
+
+                table.add_row(
+                    name,
+                    config["url"],
+                    str(config.get("priority", "N/A")),
+                    enabled_icon,
+                    last_update,
+                    default_icon,
+                )
+
+            console.print(table)
+            console.print()
+
+            return CommandResult(success=True, exit_code=0)
+
+        except Exception as e:
+            console.print(f"[red]Error listing collections: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _collection_add(self, args) -> CommandResult:
+        """Add a new skill collection."""
+        try:
+            name = getattr(args, "collection_name", None)
+            url = getattr(args, "collection_url", None)
+            priority = getattr(args, "priority", 99)
+
+            if not name or not url:
+                console.print("[red]Error: Collection name and URL are required[/red]")
+                console.print(
+                    "[dim]Usage: claude-mpm skills collection-add NAME URL [--priority N][/dim]"
+                )
+                return CommandResult(success=False, exit_code=1)
+
+            console.print(f"\n[bold cyan]Adding collection '{name}'...[/bold cyan]\n")
+
+            result = self.skills_deployer.add_collection(name, url, priority)
+
+            console.print(f"[green]✓ {result['message']}[/green]")
+            console.print(f"  [dim]URL: {url}[/dim]")
+            console.print(f"  [dim]Priority: {priority}[/dim]\n")
+
+            return CommandResult(success=True, exit_code=0)
+
+        except ValueError as e:
+            console.print(f"[red]Error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+        except Exception as e:
+            console.print(f"[red]Unexpected error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _collection_remove(self, args) -> CommandResult:
+        """Remove a skill collection."""
+        try:
+            name = getattr(args, "collection_name", None)
+
+            if not name:
+                console.print("[red]Error: Collection name is required[/red]")
+                console.print(
+                    "[dim]Usage: claude-mpm skills collection-remove NAME[/dim]"
+                )
+                return CommandResult(success=False, exit_code=1)
+
+            console.print(
+                f"\n[bold yellow]Removing collection '{name}'...[/bold yellow]\n"
+            )
+
+            result = self.skills_deployer.remove_collection(name)
+
+            console.print(f"[green]✓ {result['message']}[/green]")
+            if result.get("directory_removed"):
+                console.print("  [dim]Collection directory removed[/dim]")
+            elif result.get("directory_error"):
+                console.print(
+                    f"  [yellow]Warning: {result['directory_error']}[/yellow]"
+                )
+            console.print()
+
+            return CommandResult(success=True, exit_code=0)
+
+        except ValueError as e:
+            console.print(f"[red]Error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+        except Exception as e:
+            console.print(f"[red]Unexpected error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _collection_enable(self, args) -> CommandResult:
+        """Enable a disabled collection."""
+        try:
+            name = getattr(args, "collection_name", None)
+
+            if not name:
+                console.print("[red]Error: Collection name is required[/red]")
+                console.print(
+                    "[dim]Usage: claude-mpm skills collection-enable NAME[/dim]"
+                )
+                return CommandResult(success=False, exit_code=1)
+
+            result = self.skills_deployer.enable_collection(name)
+
+            console.print(f"\n[green]✓ {result['message']}[/green]\n")
+
+            return CommandResult(success=True, exit_code=0)
+
+        except ValueError as e:
+            console.print(f"[red]Error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+        except Exception as e:
+            console.print(f"[red]Unexpected error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _collection_disable(self, args) -> CommandResult:
+        """Disable a collection."""
+        try:
+            name = getattr(args, "collection_name", None)
+
+            if not name:
+                console.print("[red]Error: Collection name is required[/red]")
+                console.print(
+                    "[dim]Usage: claude-mpm skills collection-disable NAME[/dim]"
+                )
+                return CommandResult(success=False, exit_code=1)
+
+            result = self.skills_deployer.disable_collection(name)
+
+            console.print(f"\n[green]✓ {result['message']}[/green]\n")
+
+            return CommandResult(success=True, exit_code=0)
+
+        except ValueError as e:
+            console.print(f"[red]Error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+        except Exception as e:
+            console.print(f"[red]Unexpected error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+    def _collection_set_default(self, args) -> CommandResult:
+        """Set the default collection."""
+        try:
+            name = getattr(args, "collection_name", None)
+
+            if not name:
+                console.print("[red]Error: Collection name is required[/red]")
+                console.print(
+                    "[dim]Usage: claude-mpm skills collection-set-default NAME[/dim]"
+                )
+                return CommandResult(success=False, exit_code=1)
+
+            result = self.skills_deployer.set_default_collection(name)
+
+            console.print(f"\n[green]✓ {result['message']}[/green]")
+            if result.get("previous_default"):
+                console.print(f"  [dim]Previous: {result['previous_default']}[/dim]")
+            console.print()
+
+            return CommandResult(success=True, exit_code=0)
+
+        except ValueError as e:
+            console.print(f"[red]Error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+        except Exception as e:
+            console.print(f"[red]Unexpected error: {e}[/red]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
 
 def manage_skills(args) -> int:
     """

claude_mpm/cli/executor.py

@@ -13,7 +13,6 @@ from .commands import (
     cleanup_memory,
     manage_agent_manager,
     manage_agents,
-    manage_config,
     manage_configure,
     manage_debug,
     manage_mcp,
@@ -126,6 +125,22 @@ def execute_command(command: str, args) -> int:
         result = handle_verify(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
+        from .commands.skill_source import skill_source_command
+
+        result = skill_source_command(args)
+        return result if result is not None else 0
+
+    # Handle agent-source command with lazy import
+    if command == "agent-source":
+        # Lazy import to avoid loading unless needed
+        from .commands.agent_source import agent_source_command
+
+        result = agent_source_command(args)
+        return result if result is not None else 0
+
     # Handle auto-configure command with lazy import
     if command == "auto-configure":
         # Lazy import to avoid loading unless needed
@@ -146,6 +161,62 @@ def execute_command(command: str, args) -> int:
         # Convert CommandResult to exit code
         return result.exit_code if result else 0
 
+    # Handle hook-errors command with lazy import
+    if command == "hook-errors":
+        # Lazy import to avoid loading unless needed
+        from .commands.hook_errors import (
+            clear_errors,
+            diagnose_errors,
+            list_errors,
+            show_status,
+            show_summary,
+        )
+
+        # Get subcommand
+        subcommand = getattr(args, "hook_errors_command", "status")
+        if not subcommand:
+            subcommand = "status"
+
+        # Map subcommands to functions
+        handlers = {
+            "list": list_errors,
+            "summary": show_summary,
+            "clear": clear_errors,
+            "diagnose": diagnose_errors,
+            "status": show_status,
+        }
+
+        # Get handler and invoke
+        handler = handlers.get(subcommand)
+        if handler:
+            # Build Click context programmatically
+            import click
+
+            ctx = click.Context(command=handler)
+
+            # 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
+
+            try:
+                # Invoke handler with arguments
+                with ctx:
+                    handler.invoke(ctx, **kwargs)
+                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
+
     # Map stable commands to their implementations
     command_map = {
         CLICommands.RUN.value: run_session,
@@ -157,8 +228,10 @@ def execute_command(command: str, args) -> int:
         CLICommands.MEMORY.value: manage_memory,
         CLICommands.MONITOR.value: manage_monitor,
         CLICommands.DASHBOARD.value: manage_dashboard,
-        CLICommands.CONFIG.value: manage_config,
-        CLICommands.CONFIGURE.value: manage_configure,
+        # Configuration management commands (synonymous)
+        # Both 'config' and 'configure' launch the interactive configuration TUI
+        CLICommands.CONFIG.value: manage_configure,  # Alias to configure
+        CLICommands.CONFIGURE.value: manage_configure,  # Interactive configuration TUI
         CLICommands.AGGREGATE.value: aggregate_command,
         CLICommands.ANALYZE_CODE.value: manage_analyze_code,
         CLICommands.CLEANUP.value: cleanup_memory,
@@ -193,6 +266,8 @@ def execute_command(command: str, args) -> int:
         "verify",
         "auto-configure",
         "local-deploy",
+        "skill-source",
+        "agent-source",
     ]
 
     suggestion = suggest_similar_commands(command, all_commands)