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

claude_mpm/cli/commands/run.py

@@ -569,41 +569,6 @@ class RunCommand(BaseCommand):
             return False
 
 
-def _ensure_mcp_services_configured(logger):
-    """
-    Ensure MCP services are configured in .mcp.json on startup.
-
-    This function automatically configures the core MCP services
-    (mcp-vector-search, mcp-browser, mcp-ticketer) if they're not
-    already configured in the project's .mcp.json file.
-
-    Args:
-        logger: Logger instance for output
-    """
-    try:
-        from ...services.mcp_config_manager import MCPConfigManager
-
-        logger.debug("Checking MCP service configuration...")
-        manager = MCPConfigManager()
-
-        # Check and auto-configure missing MCP services
-        success, message = manager.ensure_mcp_services_configured()
-
-        if success:
-            if "already configured" not in message.lower():
-                logger.info(message)
-                print(f"✅ {message}")
-            else:
-                logger.debug(message)
-        else:
-            logger.warning(f"MCP auto-configuration issue: {message}")
-            # Don't fail the session, just warn
-
-    except Exception as e:
-        logger.debug(f"MCP auto-configuration skipped: {e}")
-        # Don't fail the session if auto-configuration fails
-
-
 def _handle_reload_agents(logger):
     """
     Handle the --reload-agents flag by deleting all local claude-mpm system agents.
@@ -738,10 +703,7 @@ def run_session_legacy(args):
     if getattr(args, "reload_agents", False):
         _handle_reload_agents(logger)
 
-    # Auto-configure MCP services on startup
-    _ensure_mcp_services_configured(logger)
-
-    # Trigger vector search indexing after MCP is configured
+    # Trigger vector search indexing
     try:
         from ...cli.startup_logging import start_vector_search_indexing
 

claude_mpm/cli/commands/skills.py

@@ -83,6 +83,7 @@ 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,
@@ -195,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]")
@@ -896,6 +951,254 @@ class SkillsManagementCommand(BaseCommand):
             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)