claude-mpm 4.21.3__py3-none-any.whl → 5.1.9__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,19 @@ class SkillsManagementCommand(BaseCommand):
                 SkillsCommands.UPDATE.value: self._update_skills,
                 SkillsCommands.INFO.value: self._show_skill_info,
                 SkillsCommands.CONFIG.value: self._manage_config,
+                SkillsCommands.CONFIGURE.value: self._configure_skills,
+                # 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)
@@ -168,55 +196,109 @@ class SkillsManagementCommand(BaseCommand):
             return CommandResult(success=False, message=str(e), exit_code=1)
 
     def _deploy_skills(self, args) -> CommandResult:
-        """Deploy bundled skills to project."""
+        """Deploy skills using two-phase sync: cache → deploy.
+
+        Phase 3 Integration (1M-486): Uses Git skill source manager for deployment.
+        - Phase 1: Sync skills to ~/.claude-mpm/cache/skills/ (if needed)
+        - Phase 2: Deploy from cache to project .claude-mpm/skills/
+
+        This replaces bundled skill deployment with a multi-project
+        architecture where one cache serves multiple project deployments.
+        """
         try:
+            from pathlib import Path
+
+            from ...config.skill_sources import SkillSourceConfiguration
+            from ...services.skills.git_skill_source_manager import (
+                GitSkillSourceManager,
+            )
+
             force = getattr(args, "force", False)
             specific_skills = getattr(args, "skills", None)
 
             console.print("\n[bold cyan]Deploying skills...[/bold cyan]\n")
 
-            result = self.skills_service.deploy_bundled_skills(
-                force=force, skill_names=specific_skills
+            # Initialize git skill source manager
+            config = SkillSourceConfiguration.load()
+            git_skill_manager = GitSkillSourceManager(config)
+            project_dir = Path.cwd()
+
+            # Phase 1: Sync skills to cache
+            console.print("[dim]Phase 1: Syncing skills to cache...[/dim]")
+            sync_results = git_skill_manager.sync_all_sources(force=force)
+
+            synced_count = sum(
+                1 for result in sync_results.values() if result.get("synced")
+            )
+            console.print(f"[dim]Synced {synced_count} skill source(s)[/dim]\n")
+
+            # Phase 2: Deploy from cache to project
+            console.print("[dim]Phase 2: Deploying from cache to project...[/dim]\n")
+            deploy_result = git_skill_manager.deploy_skills_to_project(
+                project_dir=project_dir,
+                skill_list=specific_skills,
+                force=force,
             )
 
             # Display results
-            if result["deployed"]:
+            if deploy_result["deployed"]:
                 console.print(
-                    f"[green]✓ Deployed {len(result['deployed'])} skill(s):[/green]"
+                    f"[green]✓ Deployed {len(deploy_result['deployed'])} skill(s):[/green]"
                 )
-                for skill in result["deployed"]:
+                for skill in deploy_result["deployed"]:
                     console.print(f"  • {skill}")
                 console.print()
 
-            if result["skipped"]:
+            if deploy_result["updated"]:
                 console.print(
-                    f"[yellow]⊘ Skipped {len(result['skipped'])} skill(s) (already deployed):[/yellow]"
+                    f"[green]⟳ Updated {len(deploy_result['updated'])} skill(s):[/green]"
                 )
-                for skill in result["skipped"]:
+                for skill in deploy_result["updated"]:
+                    console.print(f"  • {skill}")
+                console.print()
+
+            if deploy_result["skipped"]:
+                console.print(
+                    f"[yellow]⊘ Skipped {len(deploy_result['skipped'])} skill(s) (already up-to-date):[/yellow]"
+                )
+                for skill in deploy_result["skipped"]:
                     console.print(f"  • {skill}")
                 console.print("[dim]Use --force to redeploy[/dim]\n")
 
-            if result["errors"]:
+            if deploy_result["failed"]:
                 console.print(
-                    f"[red]✗ Failed to deploy {len(result['errors'])} skill(s):[/red]"
+                    f"[red]✗ Failed to deploy {len(deploy_result['failed'])} skill(s):[/red]"
                 )
-                for skill, error in result["errors"].items():
-                    console.print(f"  • {skill}: {error}")
+                for skill in deploy_result["failed"]:
+                    console.print(f"  • {skill}")
                 console.print()
 
             # Summary
+            success_count = len(deploy_result["deployed"]) + len(
+                deploy_result["updated"]
+            )
             total = (
-                len(result["deployed"]) + len(result["skipped"]) + len(result["errors"])
+                success_count
+                + len(deploy_result["skipped"])
+                + len(deploy_result["failed"])
             )
             console.print(
-                f"[bold]Summary:[/bold] {len(result['deployed'])} deployed, "
-                f"{len(result['skipped'])} skipped, {len(result['errors'])} errors "
-                f"(Total: {total})\n"
+                f"[bold]Summary:[/bold] {success_count} deployed/updated, "
+                f"{len(deploy_result['skipped'])} skipped, "
+                f"{len(deploy_result['failed'])} errors (Total: {total})\n"
+            )
+
+            console.print(
+                f"[dim]Deployment directory: {deploy_result['deployment_dir']}[/dim]\n"
             )
 
             # Exit with error if any deployments failed
-            exit_code = 1 if result["errors"] else 0
-            return CommandResult(success=not result["errors"], exit_code=exit_code)
+            exit_code = 1 if deploy_result["failed"] else 0
+            return CommandResult(
+                success=not deploy_result["failed"],
+                message=f"Deployed {success_count} skills from cache",
+                exit_code=exit_code,
+            )
 
         except Exception as e:
             console.print(f"[red]Error deploying skills: {e}[/red]")
@@ -448,6 +530,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 +749,458 @@ 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]")
+
+    def _configure_skills(self, args) -> CommandResult:
+        """Interactive skills configuration with checkbox selection.
+
+        Provides checkbox-based selection interface matching agents configure UX:
+        - Status column showing Installed/Available
+        - Pre-selection for installed skills
+        - Apply/Adjust/Cancel menu
+        - While loop for adjustment
+        - Simplified labels (checkbox state only)
+
+        This is Option 3 (Hybrid approach): Separate command for interactive mode
+        while keeping deploy-github for CLI automation.
+        """
+        try:
+            import questionary
+            from questionary import Choice, Style
+            from rich.prompt import Prompt
+
+            # Questionary style (matching agents configure)
+            QUESTIONARY_STYLE = Style(
+                [
+                    (
+                        "selected",
+                        "fg:#e0e0e0 bold",
+                    ),  # Light gray - excellent readability
+                    (
+                        "pointer",
+                        "fg:#ffd700 bold",
+                    ),  # Gold/yellow - highly visible pointer
+                    ("highlighted", "fg:#e0e0e0"),  # Light gray - clear hover state
+                    (
+                        "question",
+                        "fg:#e0e0e0 bold",
+                    ),  # Light gray bold - prominent questions
+                    ("checkbox", "fg:#00ff00"),  # Green - for checked boxes
+                    (
+                        "checkbox-selected",
+                        "fg:#00ff00 bold",
+                    ),  # Green bold - for checked selected boxes
+                ]
+            )
+
+            console.print("\n[bold cyan]Interactive Skills Configuration[/bold cyan]\n")
+            console.print(
+                "[dim]Select skills to install/uninstall using checkboxes[/dim]"
+            )
+            console.print("[dim]● = Installed, ○ = Available[/dim]\n")
+
+            # Get deployed skills for status detection
+            deployed_result = self.skills_deployer.check_deployed_skills()
+            deployed_skills = {
+                skill["name"] for skill in deployed_result.get("skills", [])
+            }
+
+            # Get available skills from GitHub
+            console.print("[dim]Fetching available skills from GitHub...[/dim]\n")
+            available_result = self.skills_deployer.list_available_skills()
+
+            if available_result.get("error"):
+                console.print(f"[red]Error: {available_result['error']}[/red]")
+                return CommandResult(
+                    success=False, message=available_result["error"], exit_code=1
+                )
+
+            # Flatten skills by category
+            all_skills = []
+            for category, skills in available_result.get("by_category", {}).items():
+                for skill in skills:
+                    skill_info = {
+                        "name": skill.get("name", "unknown"),
+                        "category": category,
+                        "is_deployed": skill.get("name", "unknown") in deployed_skills,
+                    }
+                    all_skills.append(skill_info)
+
+            # Sort by deployed status (deployed first), then by name
+            all_skills.sort(key=lambda s: (not s["is_deployed"], s["name"]))
+
+            # Build checkbox choices with pre-selection
+            # Loop to allow adjusting selection
+            while True:
+                skill_choices = []
+                skill_map = {}  # For lookup after selection
+
+                for skill in all_skills:
+                    skill_name = skill["name"]
+                    category = skill["category"]
+                    is_deployed = skill["is_deployed"]
+
+                    # Simple format: "skill-name (category)"
+                    # Checkbox state (checked/unchecked) indicates installed status
+                    choice_text = f"{skill_name} ({category})"
+
+                    # Pre-select if deployed
+                    choice = Choice(
+                        title=choice_text, value=skill_name, checked=is_deployed
+                    )
+
+                    skill_choices.append(choice)
+                    skill_map[skill_name] = skill
+
+                # Display checkbox selection
+                selected_skills = questionary.checkbox(
+                    "Select skills (Space to toggle, Enter to confirm):",
+                    choices=skill_choices,
+                    style=QUESTIONARY_STYLE,
+                ).ask()
+
+                if selected_skills is None:
+                    # User cancelled (Ctrl+C)
+                    console.print("[yellow]Skills configuration cancelled[/yellow]")
+                    return CommandResult(success=True, exit_code=0)
+
+                # Determine changes
+                to_install = []
+                to_remove = []
+
+                for skill in all_skills:
+                    skill_name = skill["name"]
+                    is_deployed = skill["is_deployed"]
+                    is_selected = skill_name in selected_skills
+
+                    if is_selected and not is_deployed:
+                        to_install.append(skill_name)
+                    elif not is_selected and is_deployed:
+                        to_remove.append(skill_name)
+
+                # Show summary of changes
+                console.print("\n[bold]Changes to apply:[/bold]")
+                if to_install:
+                    console.print(
+                        f"\n[green]✓ Install ({len(to_install)} skills):[/green]"
+                    )
+                    for skill in to_install:
+                        console.print(f"  • {skill}")
+
+                if to_remove:
+                    console.print(
+                        f"\n[yellow]✗ Remove ({len(to_remove)} skills):[/yellow]"
+                    )
+                    for skill in to_remove:
+                        console.print(f"  • {skill}")
+
+                if not to_install and not to_remove:
+                    console.print(
+                        "\n[dim]No changes (selection matches current deployment)[/dim]"
+                    )
+
+                console.print()
+
+                # Ask user to confirm, adjust, or cancel
+                action = questionary.select(
+                    "\nWhat would you like to do?",
+                    choices=[
+                        Choice("Apply these changes", value="apply"),
+                        Choice("Adjust selection", value="adjust"),
+                        Choice("Cancel", value="cancel"),
+                    ],
+                    default="apply",
+                    style=QUESTIONARY_STYLE,
+                ).ask()
+
+                if action == "cancel":
+                    console.print("[yellow]Changes cancelled[/yellow]")
+                    Prompt.ask("\nPress Enter to continue")
+                    return CommandResult(success=True, exit_code=0)
+                if action == "adjust":
+                    # Loop back to skill selection
+                    console.print("\n[dim]Adjusting selection...[/dim]\n")
+                    continue
+
+                # Apply changes
+                success = True
+                errors = []
+
+                # Install skills
+                if to_install:
+                    console.print("\n[bold cyan]Installing skills...[/bold cyan]\n")
+                    for skill_name in to_install:
+                        try:
+                            # Deploy single skill
+                            result = self.skills_deployer.deploy_skills(
+                                skill_names=[skill_name], force=False
+                            )
+
+                            if result.get("errors"):
+                                errors.extend(result["errors"])
+                                success = False
+                            else:
+                                console.print(
+                                    f"[green]✓ Installed: {skill_name}[/green]"
+                                )
+                        except Exception as e:
+                            errors.append(f"Failed to install {skill_name}: {e}")
+                            success = False
+
+                # Remove skills
+                if to_remove:
+                    console.print("\n[bold yellow]Removing skills...[/bold yellow]\n")
+                    for skill_name in to_remove:
+                        try:
+                            # Remove single skill
+                            result = self.skills_deployer.remove_skills(
+                                skill_names=[skill_name]
+                            )
+
+                            if result.get("errors"):
+                                errors.extend(result["errors"])
+                                success = False
+                            else:
+                                console.print(
+                                    f"[yellow]✗ Removed: {skill_name}[/yellow]"
+                                )
+                        except Exception as e:
+                            errors.append(f"Failed to remove {skill_name}: {e}")
+                            success = False
+
+                # Show errors if any
+                if errors:
+                    console.print(f"\n[red]✗ {len(errors)} error(s):[/red]")
+                    for error in errors:
+                        console.print(f"  • {error}")
+
+                # Show restart instructions
+                if success and (to_install or to_remove):
+                    console.print(
+                        "\n[bold green]✓ Changes applied successfully![/bold green]"
+                    )
+                    console.print("\n[yellow]⚠️  Important:[/yellow]")
+                    console.print("  Restart Claude Code for changes to take effect")
+
+                console.print()
+                Prompt.ask("\nPress Enter to continue")
+
+                # Exit the loop after successful execution
+                break
+
+            exit_code = 0 if success else 1
+            return CommandResult(success=success, exit_code=exit_code)
+
+        except Exception as e:
+            console.print(f"[red]Error in skills configuration: {e}[/red]")
+            import traceback
+
+            console.print(f"[dim]{traceback.format_exc()}[/dim]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
 
 def manage_skills(args) -> int:
     """