claude-mpm 5.4.3__py3-none-any.whl → 5.4.21__py3-none-any.whl

claude_mpm/cli/commands/skills.py

@@ -537,7 +537,7 @@ class SkillsManagementCommand(BaseCommand):
             toolchain = getattr(args, "toolchain", None)
             categories = getattr(args, "categories", None)
             force = getattr(args, "force", False)
-            all_skills = getattr(args, "all", False)
+            all_skills = getattr(args, "all_skills", False)
 
             if collection:
                 console.print(
@@ -554,17 +554,36 @@ class SkillsManagementCommand(BaseCommand):
                     "[yellow]No toolchain specified. Use --toolchain to filter by language,[/yellow]"
                 )
                 console.print(
-                    "[yellow]or --all to deploy all available skills.[/yellow]\n"
+                    "[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
             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
             )
 
             # Display results
+            # Show selective mode summary
+            if result.get("selective_mode"):
+                total_available = result.get("total_available", 0)
+                deployed_count = result["deployed_count"]
+                console.print(
+                    f"[cyan]📌 Selective deployment: {deployed_count} agent-referenced skills "
+                    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"
+                )
+
             if result["deployed_count"] > 0:
                 console.print(
                     f"[green]✓ Deployed {result['deployed_count']} skill(s):[/green]"
@@ -953,23 +972,37 @@ class SkillsManagementCommand(BaseCommand):
             console.print(f"[red]Unexpected error: {e}[/red]")
 
     def _configure_skills(self, args) -> CommandResult:
-        """Interactive skills configuration with checkbox selection.
+        """Interactive skills configuration using configuration.yaml.
 
         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.
+        - Shows current mode (user_defined vs agent_referenced)
+        - If agent mode: shows agent-scanned skills
+        - Allows switching to user_defined mode and selecting skills
+        - Can reset to agent mode (clears user_defined)
+        - Saves selections to configuration.yaml
+
+        Configuration structure:
+        ```yaml
+        skills:
+          agent_referenced:  # Auto-populated from agent scan (read-only)
+            - systematic-debugging
+            - typescript-core
+          user_defined:      # User override - if set, ONLY these are deployed
+            []               # Empty = use agent_referenced
+        ```
         """
         try:
+            from pathlib import Path
+
             import questionary
+            import yaml
             from questionary import Choice, Style
             from rich.prompt import Prompt
 
+            from ...services.skills.selective_skill_deployer import (
+                get_skills_to_deploy,
+            )
+
             # Questionary style (matching agents configure)
             QUESTIONARY_STYLE = Style(
                 [
@@ -994,203 +1027,197 @@ class SkillsManagementCommand(BaseCommand):
                 ]
             )
 
-            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")
+            console.print("\n[bold cyan]Skills Configuration Manager[/bold cyan]\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", [])
-            }
+            # Load current configuration
+            project_config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+            skills_to_deploy, current_mode = get_skills_to_deploy(project_config_path)
 
-            # Get available skills from GitHub
-            console.print("[dim]Fetching available skills from GitHub...[/dim]\n")
-            available_result = self.skills_deployer.list_available_skills()
+            # Display current mode and skill count
+            console.print(f"[bold]Current Mode:[/bold] [cyan]{current_mode}[/cyan]")
+            console.print(
+                f"[bold]Active Skills:[/bold] {len(skills_to_deploy)} skills\n"
+            )
 
-            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
+            if current_mode == "agent_referenced":
+                console.print(
+                    "[dim]Agent mode: Skills are auto-detected from deployed agents[/dim]"
+                )
+                console.print(
+                    "[dim]Switch to user mode to manually select skills[/dim]\n"
                 )
+            else:
+                console.print(
+                    "[dim]User mode: You've manually selected which skills to deploy[/dim]"
+                )
+                console.print("[dim]Reset to agent mode to use auto-detection[/dim]\n")
+
+            # Offer mode switching
+            action_choices = [
+                Choice("View current skills", value="view"),
+                Choice("Switch to user mode (manual selection)", value="switch_user"),
+                Choice("Reset to agent mode (auto-detection)", value="reset_agent"),
+                Choice("Cancel", value="cancel"),
+            ]
+
+            action = questionary.select(
+                "What would you like to do?",
+                choices=action_choices,
+                style=QUESTIONARY_STYLE,
+            ).ask()
+
+            if action == "cancel" or action is None:
+                console.print("[yellow]Configuration cancelled[/yellow]")
+                return CommandResult(success=True, exit_code=0)
 
-            # 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
-                    )
+            if action == "view":
+                # Display current skills
+                console.print("\n[bold]Current Skills:[/bold]\n")
+                for skill in sorted(skills_to_deploy):
+                    console.print(f"  • {skill}")
+                console.print()
+                Prompt.ask("\nPress Enter to continue")
+                return CommandResult(success=True, exit_code=0)
 
-                    skill_choices.append(choice)
-                    skill_map[skill_name] = skill
+            if action == "reset_agent":
+                # Reset to agent mode by clearing user_defined
+                with open(project_config_path, encoding="utf-8") as f:
+                    config = yaml.safe_load(f) or {}
 
-                # Display checkbox selection
-                selected_skills = questionary.checkbox(
-                    "Select skills (Space to toggle, Enter to confirm):",
-                    choices=skill_choices,
-                    style=QUESTIONARY_STYLE,
-                ).ask()
+                if "skills" not in config:
+                    config["skills"] = {}
 
-                if selected_skills is None:
-                    # User cancelled (Ctrl+C)
-                    console.print("[yellow]Skills configuration cancelled[/yellow]")
-                    return CommandResult(success=True, exit_code=0)
+                config["skills"]["user_defined"] = []
 
-                # Determine changes
-                to_install = []
-                to_remove = []
+                with open(project_config_path, "w", encoding="utf-8") as f:
+                    yaml.dump(config, f, default_flow_style=False, sort_keys=False)
 
-                for skill in all_skills:
-                    skill_name = skill["name"]
-                    is_deployed = skill["is_deployed"]
-                    is_selected = skill_name in selected_skills
+                console.print(
+                    "\n[green]✓ Reset to agent mode - skills will be auto-detected from agents[/green]\n"
+                )
+                Prompt.ask("\nPress Enter to continue")
+                return CommandResult(success=True, exit_code=0)
 
-                    if is_selected and not is_deployed:
-                        to_install.append(skill_name)
-                    elif not is_selected and is_deployed:
-                        to_remove.append(skill_name)
+            # Switch to user mode - manual skill selection
+            if action == "switch_user":
+                console.print(
+                    "\n[bold cyan]Switching to User Mode - Manual Skill Selection[/bold cyan]\n"
+                )
+                console.print("[dim]Fetching available skills from GitHub...[/dim]\n")
 
-                # 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}")
+                # Get available skills
+                available_result = self.skills_deployer.list_available_skills()
 
-                if to_remove:
-                    console.print(
-                        f"\n[yellow]✗ Remove ({len(to_remove)} skills):[/yellow]"
+                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
                     )
-                    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]"
-                    )
+                # Flatten skills by category
+                all_skills = []
+                for category, skills in available_result.get("by_category", {}).items():
+                    for skill in skills:
+                        skill_name = skill.get("name", "unknown")
+                        is_currently_selected = skill_name in skills_to_deploy
+                        skill_info = {
+                            "name": skill_name,
+                            "category": category,
+                            "is_selected": is_currently_selected,
+                        }
+                        all_skills.append(skill_info)
+
+                # Sort by selection status (selected first), then by name
+                all_skills.sort(key=lambda s: (not s["is_selected"], s["name"]))
+
+                # Build checkbox choices
+                while True:
+                    skill_choices = []
+
+                    for skill in all_skills:
+                        skill_name = skill["name"]
+                        category = skill["category"]
+                        is_selected = skill["is_selected"]
+
+                        # Format: "skill-name (category)"
+                        choice_text = f"{skill_name} ({category})"
+
+                        # Pre-select if currently in skills_to_deploy
+                        choice = Choice(
+                            title=choice_text, value=skill_name, checked=is_selected
+                        )
 
-                console.print()
+                        skill_choices.append(choice)
+
+                    # 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)
+
+                    # Show summary
+                    console.print("\n[bold]Selected Skills:[/bold]")
+                    console.print(f"  {len(selected_skills)} skills selected\n")
+
+                    if selected_skills:
+                        for skill in sorted(selected_skills):
+                            console.print(f"  • {skill}")
+                        console.print()
+
+                    # Ask user to confirm, adjust, or cancel
+                    confirm_action = questionary.select(
+                        "\nWhat would you like to do?",
+                        choices=[
+                            Choice("Save to configuration", value="apply"),
+                            Choice("Adjust selection", value="adjust"),
+                            Choice("Cancel", value="cancel"),
+                        ],
+                        default="apply",
+                        style=QUESTIONARY_STYLE,
+                    ).ask()
+
+                    if confirm_action == "cancel":
+                        console.print("[yellow]Configuration cancelled[/yellow]")
+                        Prompt.ask("\nPress Enter to continue")
+                        return CommandResult(success=True, exit_code=0)
+
+                    if confirm_action == "adjust":
+                        # Update selection state and loop back
+                        for skill in all_skills:
+                            skill["is_selected"] = skill["name"] in selected_skills
+                        console.print("\n[dim]Adjusting selection...[/dim]\n")
+                        continue
+
+                    # Save to configuration.yaml
+                    with open(project_config_path, encoding="utf-8") as f:
+                        config = yaml.safe_load(f) or {}
+
+                    if "skills" not in config:
+                        config["skills"] = {}
+
+                    config["skills"]["user_defined"] = sorted(selected_skills)
+
+                    with open(project_config_path, "w", encoding="utf-8") as f:
+                        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
 
-                # 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]"
+                        f"\n[green]✓ Saved {len(selected_skills)} skills to user_defined mode[/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")
+                    console.print(
+                        "[yellow]⚠️  Important:[/yellow] Run [cyan]claude-mpm init[/cyan] to deploy these skills\n"
+                    )
+                    Prompt.ask("\nPress Enter to continue")
 
-                # Exit the loop after successful execution
-                break
+                    # Exit the loop after successful save
+                    break
 
-            exit_code = 0 if success else 1
-            return CommandResult(success=success, exit_code=exit_code)
+            return CommandResult(success=True, exit_code=0)
 
         except Exception as e:
             console.print(f"[red]Error in skills configuration: {e}[/red]")
@@ -1199,8 +1226,6 @@ class SkillsManagementCommand(BaseCommand):
             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:
     """

claude_mpm/cli/executor.py

@@ -24,6 +24,7 @@ from .commands import (
     show_info,
 )
 from .commands.analyze_code import manage_analyze_code
+from .commands.config import manage_config
 from .commands.dashboard import manage_dashboard
 from .commands.skills import manage_skills
 from .commands.upgrade import upgrade
@@ -236,9 +237,8 @@ def execute_command(command: str, args) -> int:
         CLICommands.MEMORY.value: manage_memory,
         CLICommands.MONITOR.value: manage_monitor,
         CLICommands.DASHBOARD.value: manage_dashboard,
-        # Configuration management commands (synonymous)
-        # Both 'config' and 'configure' launch the interactive configuration TUI
-        CLICommands.CONFIG.value: manage_configure,  # Alias to configure
+        # Configuration management commands
+        CLICommands.CONFIG.value: manage_config,  # Unified config with subcommands
         CLICommands.CONFIGURE.value: manage_configure,  # Interactive configuration TUI
         CLICommands.AGGREGATE.value: aggregate_command,
         CLICommands.ANALYZE_CODE.value: manage_analyze_code,

claude_mpm/cli/parsers/agents_parser.py

@@ -406,15 +406,6 @@ Available commands:
         help="Show descriptions and metadata for each agent",
     )
 
-    # Auto-configuration commands (TSK-0054 Phase 5)
-    from .auto_configure_parser import (
-        add_agents_detect_subparser,
-        add_agents_recommend_subparser,
-    )
-
-    add_agents_detect_subparser(agents_subparsers)
-    add_agents_recommend_subparser(agents_subparsers)
-
     # Phase 3: Agent Selection Modes (single-tier deployment)
     # Minimal configuration - deploy 6 core agents
     deploy_minimal_parser = agents_subparsers.add_parser(

claude_mpm/cli/parsers/auto_configure_parser.py

@@ -118,141 +118,3 @@ Examples:
     )
 
     return auto_configure_parser
-
-
-def add_agents_detect_subparser(agents_subparsers) -> argparse.ArgumentParser:
-    """
-    Add the agents detect subparser for toolchain detection.
-
-    WHY: Allows users to see what toolchain is detected without making changes,
-    useful for debugging and verification.
-
-    Args:
-        agents_subparsers: The agents subparsers object
-
-    Returns:
-        The configured detect subparser
-    """
-    detect_parser = agents_subparsers.add_parser(
-        "detect",
-        help="Detect project toolchain without deploying",
-        description="""
-Detect and display project toolchain without making any changes.
-
-This command analyzes your project to detect:
-  • Programming languages and versions
-  • Frameworks and libraries
-  • Deployment targets and platforms
-
-Useful for debugging toolchain detection and verifying what would be
-detected before running auto-configure.
-        """,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Detect toolchain in current directory
-  claude-mpm agents detect
-
-  # Detect with verbose output showing evidence
-  claude-mpm agents detect --verbose
-
-  # JSON output for scripting
-  claude-mpm agents detect --json
-
-  # Detect specific project
-  claude-mpm agents detect --project-path /path/to/project
-        """,
-    )
-    add_common_arguments(detect_parser)
-
-    detect_parser.add_argument(
-        "--project-path",
-        type=Path,
-        metavar="PATH",
-        help="Project path to analyze (default: current directory)",
-    )
-
-    return detect_parser
-
-
-def add_agents_recommend_subparser(
-    agents_subparsers,
-) -> argparse.ArgumentParser:
-    """
-    Add the agents recommend subparser for agent recommendations.
-
-    WHY: Allows users to see what agents would be recommended without deploying,
-    useful for reviewing recommendations before committing to deployment.
-
-    Args:
-        agents_subparsers: The agents subparsers object
-
-    Returns:
-        The configured recommend subparser
-    """
-    recommend_parser = agents_subparsers.add_parser(
-        "recommend",
-        help="Show recommended agents without deploying",
-        description="""
-Show recommended agents based on project toolchain without deploying.
-
-This command analyzes your project toolchain and recommends appropriate
-agents with detailed reasoning for each recommendation. No changes are
-made to your project.
-
-Useful for:
-  • Reviewing recommendations before deployment
-  • Understanding why agents are recommended
-  • Adjusting confidence thresholds
-        """,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Show recommendations with reasoning
-  claude-mpm agents recommend
-
-  # Require 90% confidence for recommendations
-  claude-mpm agents recommend --min-confidence 0.9
-
-  # JSON output for scripting
-  claude-mpm agents recommend --json
-
-  # Hide detailed reasoning
-  claude-mpm agents recommend --no-reasoning
-
-  # Recommend for specific project
-  claude-mpm agents recommend --project-path /path/to/project
-        """,
-    )
-    add_common_arguments(recommend_parser)
-
-    recommend_parser.add_argument(
-        "--project-path",
-        type=Path,
-        metavar="PATH",
-        help="Project path to analyze (default: current directory)",
-    )
-
-    recommend_parser.add_argument(
-        "--min-confidence",
-        type=float,
-        default=0.8,
-        metavar="FLOAT",
-        help="Minimum confidence threshold for recommendations (0.0-1.0, default: 0.8)",
-    )
-
-    recommend_parser.add_argument(
-        "--show-reasoning",
-        action="store_true",
-        default=True,
-        help="Show detailed reasoning for recommendations (default)",
-    )
-
-    recommend_parser.add_argument(
-        "--no-reasoning",
-        dest="show_reasoning",
-        action="store_false",
-        help="Hide detailed reasoning for recommendations",
-    )
-
-    return recommend_parser