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

claude_mpm/cli/commands/mpm_init/core.py

@@ -203,6 +203,10 @@ class MPMInitCommand:
             if update_mode and result.get("status") == OperationResult.SUCCESS:
                 self._handle_update_post_processing()
 
+            # Deploy PM skills after successful initialization
+            if result.get("status") == OperationResult.SUCCESS:
+                self._deploy_pm_skills()
+
             return result
 
         except Exception as e:
@@ -683,5 +687,73 @@ class MPMInitCommand:
         """
         return len(text) // 4
 
+    def _deploy_pm_skills(self) -> None:
+        """Deploy PM skills templates to project .claude-mpm directory.
+
+        Copies PM skills from bundled templates to .claude-mpm/skills/pm/
+        with version tracking and checksum validation.
+        """
+        try:
+            from rich.progress import (
+                BarColumn,
+                Progress,
+                TaskProgressColumn,
+                TextColumn,
+            )
+
+            from claude_mpm.services.pm_skills_deployer import PMSkillsDeployerService
+
+            deployer = PMSkillsDeployerService()
+
+            # Use progress bar for deployment
+            with Progress(
+                TextColumn("[cyan]Deploying PM skills[/cyan]"),
+                BarColumn(bar_width=30),
+                TaskProgressColumn(),
+                TextColumn("[dim]{task.description}[/dim]"),
+                console=self.console,
+            ) as progress:
+                task = progress.add_task("", total=None)  # Unknown total initially
+
+                def update_progress(skill_name: str, current: int, total: int) -> None:
+                    progress.update(
+                        task, total=total, completed=current, description=skill_name
+                    )
+
+                result = deployer.deploy_pm_skills(
+                    self.project_path, progress_callback=update_progress
+                )
+
+            if result.success:
+                if result.deployed:
+                    self.console.print(
+                        f"[green]✓ Deployed {len(result.deployed)} PM skills[/green]"
+                    )
+
+                if result.skipped:
+                    self.console.print(
+                        f"[dim]  Skipped {len(result.skipped)} (already deployed)[/dim]"
+                    )
+
+                if result.errors:
+                    self.console.print(
+                        f"[yellow]⚠️  {len(result.errors)} errors:[/yellow]"
+                    )
+                    for error in result.errors[:3]:  # Show first 3 errors
+                        self.console.print(f"  • {error['skill']}: {error['error']}")
+            else:
+                self.console.print(
+                    f"[yellow]⚠️  PM skills deployment had errors: {result.message}[/yellow]"
+                )
+
+        except ImportError as e:
+            logger.warning(f"PM skills deployer not available: {e}")
+            self.console.print(
+                "[yellow]⚠️  PM skills deployment skipped (service not available)[/yellow]"
+            )
+        except Exception as e:
+            logger.error(f"Failed to deploy PM skills: {e}")
+            self.console.print(f"[yellow]⚠️  PM skills deployment failed: {e}[/yellow]")
+
 
 __all__ = ["MPMInitCommand"]

claude_mpm/cli/commands/postmortem.py

@@ -317,7 +317,7 @@ def _create_prs(report, verbose: bool) -> int:
     print(f"\n🤖 Creating {len(pr_actions)} PR(s) for agent improvements...")
 
     # Check if we're in the agent cache git repo
-    agent_cache_path = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+    agent_cache_path = Path.home() / ".claude-mpm" / "cache" / "agents"
 
     if not agent_cache_path.exists():
         print(f"❌ Agent cache not found at: {agent_cache_path}")

claude_mpm/cli/commands/profile.py

@@ -0,0 +1,276 @@
+"""
+Profile management commands for claude-mpm CLI.
+
+WHY: Users need a simple way to manage deployment profiles from the command
+line. Profiles control which agents and skills are deployed, reducing context
+usage by limiting available agents to only what's needed.
+
+DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
+- Provide clear, actionable output with standardized error handling
+- Support profile listing, activation, and status reporting
+- Integrate with ConfigLoader for profile persistence
+"""
+
+from pathlib import Path
+
+import yaml
+from rich.table import Table
+
+from ...core.shared.config_loader import ConfigLoader
+from ...services.profile_manager import ProfileManager
+from ...utils.console import console
+from ..shared import BaseCommand, CommandResult
+
+
+class ProfileCommand(BaseCommand):
+    """Profile management command for agents and skills filtering."""
+
+    def __init__(self):
+        super().__init__("profile")
+        # ProfileManager will auto-detect project directory
+        self.profile_manager = ProfileManager()
+        self.config_loader = ConfigLoader()
+
+    def validate_args(self, args) -> str:
+        """Validate command arguments."""
+        if not hasattr(args, "profile_command") or not args.profile_command:
+            return "Profile command required. Use: list, set, status, or show"
+
+        valid_commands = ["list", "set", "status", "show"]
+        if args.profile_command not in valid_commands:
+            return (
+                f"Unknown profile command: {args.profile_command}. "
+                f"Valid commands: {', '.join(valid_commands)}"
+            )
+
+        # Validate set command has profile name
+        if args.profile_command == "set":
+            if not hasattr(args, "profile_name") or not args.profile_name:
+                return "Profile name required for 'set' command"
+
+        # Validate show command has profile name
+        if args.profile_command == "show":
+            if not hasattr(args, "profile_name") or not args.profile_name:
+                return "Profile name required for 'show' command"
+
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the profile command."""
+        try:
+            if args.profile_command == "list":
+                return self._list_profiles(args)
+            if args.profile_command == "set":
+                return self._set_profile(args)
+            if args.profile_command == "status":
+                return self._show_status(args)
+            if args.profile_command == "show":
+                return self._show_profile(args)
+            return CommandResult.error_result(
+                f"Unknown profile command: {args.profile_command}"
+            )
+        except Exception as e:
+            return CommandResult.error_result(f"Profile command failed: {e}")
+
+    def _list_profiles(self, args) -> CommandResult:
+        """List all available profiles."""
+        profiles = self.profile_manager.list_available_profiles()
+
+        if not profiles:
+            console.print("[yellow]No profiles found in .claude-mpm/profiles/[/yellow]")
+            return CommandResult.success_result("No profiles available")
+
+        # Load current active profile
+        main_config = self.config_loader.load_main_config()
+        active_profile = main_config.get("active_profile")
+
+        # Create table
+        table = Table(title="Available Deployment Profiles")
+        table.add_column("Profile", style="cyan", no_wrap=True)
+        table.add_column("Description", style="white")
+        table.add_column("Status", style="green")
+
+        for profile_name in profiles:
+            description = self.profile_manager.get_profile_description(profile_name)
+            status = "✓ Active" if profile_name == active_profile else ""
+
+            table.add_row(
+                profile_name, description or "(no description)", status or "-"
+            )
+
+        console.print(table)
+
+        return CommandResult.success_result(
+            f"Found {len(profiles)} profile(s)", {"profiles": profiles}
+        )
+
+    def _set_profile(self, args) -> CommandResult:
+        """Set active profile."""
+        profile_name = args.profile_name
+
+        # Validate profile exists
+        available_profiles = self.profile_manager.list_available_profiles()
+        if profile_name not in available_profiles:
+            return CommandResult.error_result(
+                f"Profile '{profile_name}' not found. "
+                f"Available profiles: {', '.join(available_profiles)}"
+            )
+
+        # Load profile to validate it
+        success = self.profile_manager.load_profile(profile_name)
+        if not success:
+            return CommandResult.error_result(
+                f"Failed to load profile '{profile_name}'"
+            )
+
+        # Update configuration.yaml
+        config_path = Path.cwd() / ".claude-mpm" / "configuration.yaml"
+        if not config_path.exists():
+            # Create configuration.yaml if it doesn't exist
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            config_data = {"active_profile": profile_name}
+        else:
+            # Load existing configuration
+            with config_path.open("r") as f:
+                config_data = yaml.safe_load(f) or {}
+            config_data["active_profile"] = profile_name
+
+        # Save configuration
+        with config_path.open("w") as f:
+            yaml.safe_dump(config_data, f, default_flow_style=False, sort_keys=False)
+
+        # Show summary
+        summary = self.profile_manager.get_filtering_summary()
+        console.print(
+            f"[green]✓[/green] Active profile set to: [cyan]{profile_name}[/cyan]"
+        )
+        console.print(
+            f"  Agents enabled: [cyan]{summary['enabled_agents_count']}[/cyan]"
+        )
+        console.print(
+            f"  Skills enabled: [cyan]{summary['enabled_skills_count']}[/cyan]"
+        )
+        console.print(
+            f"  Skill patterns disabled: [cyan]{summary['disabled_patterns_count']}[/cyan]"
+        )
+        console.print(
+            "\n[yellow]Note:[/yellow] Restart Claude Code or run [cyan]claude-mpm init[/cyan] "
+            "to apply profile filtering."
+        )
+
+        return CommandResult.success_result(
+            f"Profile '{profile_name}' activated",
+            {"profile": profile_name, "summary": summary},
+        )
+
+    def _show_status(self, args) -> CommandResult:
+        """Show current profile status."""
+        # Load current active profile
+        main_config = self.config_loader.load_main_config()
+        active_profile = main_config.get("active_profile")
+
+        if not active_profile:
+            console.print(
+                "[yellow]No active profile[/yellow] - All agents and skills enabled"
+            )
+            return CommandResult.success_result(
+                "No active profile", {"active_profile": None}
+            )
+
+        # Load profile
+        success = self.profile_manager.load_profile(active_profile)
+        if not success:
+            return CommandResult.error_result(
+                f"Failed to load active profile '{active_profile}'"
+            )
+
+        # Get summary
+        summary = self.profile_manager.get_filtering_summary()
+
+        # Display status
+        console.print(f"[green]Active Profile:[/green] [cyan]{active_profile}[/cyan]")
+        console.print()
+
+        # Agents section
+        console.print("[bold]Agents:[/bold]")
+        console.print(f"  Enabled: [cyan]{summary['enabled_agents_count']}[/cyan]")
+        console.print(f"  Disabled: [cyan]{summary['disabled_agents_count']}[/cyan]")
+
+        # Skills section
+        console.print()
+        console.print("[bold]Skills:[/bold]")
+        console.print(f"  Enabled: [cyan]{summary['enabled_skills_count']}[/cyan]")
+        console.print(
+            f"  Disabled patterns: [cyan]{summary['disabled_patterns_count']}[/cyan]"
+        )
+
+        return CommandResult.success_result(
+            f"Profile '{active_profile}' status",
+            {"active_profile": active_profile, "summary": summary},
+        )
+
+    def _show_profile(self, args) -> CommandResult:
+        """Show detailed profile configuration."""
+        profile_name = args.profile_name
+
+        # Validate profile exists
+        available_profiles = self.profile_manager.list_available_profiles()
+        if profile_name not in available_profiles:
+            return CommandResult.error_result(
+                f"Profile '{profile_name}' not found. "
+                f"Available profiles: {', '.join(available_profiles)}"
+            )
+
+        # Load profile
+        success = self.profile_manager.load_profile(profile_name)
+        if not success:
+            return CommandResult.error_result(
+                f"Failed to load profile '{profile_name}'"
+            )
+
+        # Display profile details
+        console.print(f"[bold]Profile:[/bold] [cyan]{profile_name}[/cyan]")
+        console.print()
+
+        # Show enabled agents
+        enabled_agents = self.profile_manager.get_enabled_agents()
+        if enabled_agents:
+            console.print("[bold]Enabled Agents:[/bold]")
+            for agent in sorted(enabled_agents):
+                console.print(f"  • {agent}")
+            console.print()
+
+        # Show disabled agents
+        disabled_agents = self.profile_manager.get_disabled_agents()
+        if disabled_agents:
+            console.print("[bold]Disabled Agents:[/bold]")
+            for agent in sorted(disabled_agents):
+                console.print(f"  • {agent}")
+            console.print()
+
+        # Show enabled skills
+        enabled_skills = self.profile_manager.get_enabled_skills()
+        if enabled_skills:
+            console.print("[bold]Enabled Skills:[/bold]")
+            for skill in sorted(enabled_skills):
+                console.print(f"  • {skill}")
+            console.print()
+
+        # Show disabled skill patterns
+        disabled_patterns = self.profile_manager.get_disabled_skill_patterns()
+        if disabled_patterns:
+            console.print("[bold]Disabled Skill Patterns:[/bold]")
+            for pattern in disabled_patterns:
+                console.print(f"  • {pattern}")
+
+        return CommandResult.success_result(
+            f"Profile '{profile_name}' details",
+            {
+                "profile": profile_name,
+                "enabled_agents": list(enabled_agents),
+                "disabled_agents": list(disabled_agents),
+                "enabled_skills": list(enabled_skills),
+                "disabled_patterns": disabled_patterns,
+            },
+        )

claude_mpm/cli/commands/skills.py

@@ -537,7 +537,6 @@ class SkillsManagementCommand(BaseCommand):
             toolchain = getattr(args, "toolchain", None)
             categories = getattr(args, "categories", None)
             force = getattr(args, "force", False)
-            all_skills = getattr(args, "all_skills", False)
 
             if collection:
                 console.print(
@@ -548,23 +547,14 @@ class SkillsManagementCommand(BaseCommand):
                     "\n[bold cyan]Deploying skills from default collection...[/bold cyan]\n"
                 )
 
-            # Auto-detect toolchain if not specified and not deploying all
-            if not toolchain and not all_skills:
-                console.print(
-                    "[yellow]No toolchain specified. Use --toolchain to filter by language,[/yellow]"
-                )
-                console.print(
-                    "[yellow]or --all-skills to deploy all available skills (not just agent-referenced).[/yellow]\n"
-                )
-
-            # Selective deployment is enabled by default (deploy only agent-referenced skills)
-            # Use --all-skills to disable selective mode
+            # Selective deployment is ALWAYS enabled (deploy only agent-referenced skills)
+            # This ensures only skills linked to deployed agents are deployed
             result = self.skills_deployer.deploy_skills(
                 collection=collection,
                 toolchain=toolchain,
                 categories=categories,
                 force=force,
-                selective=not all_skills,  # Disable selective mode if --all-skills is set
+                selective=True,  # Always use selective deployment
             )
 
             # Display results
@@ -577,11 +567,7 @@ class SkillsManagementCommand(BaseCommand):
                     f"(out of {total_available} available)[/cyan]"
                 )
                 console.print(
-                    "[dim]Use --all-skills to deploy all available skills[/dim]\n"
-                )
-            else:
-                console.print(
-                    "[cyan]📦 Deploying all available skills (selective mode disabled)[/cyan]\n"
+                    "[dim]Use 'claude-mpm skills configure' to manually select skills[/dim]\n"
                 )
 
             if result["deployed_count"] > 0:
@@ -606,6 +592,16 @@ class SkillsManagementCommand(BaseCommand):
                     console.print(f"  • {error}")
                 console.print()
 
+            # Show cleanup results
+            cleanup = result.get("cleanup", {})
+            if cleanup.get("removed_count", 0) > 0:
+                console.print(
+                    f"[yellow]🧹 Removed {cleanup['removed_count']} orphaned skill(s):[/yellow]"
+                )
+                for skill in cleanup.get("removed_skills", []):
+                    console.print(f"  • {skill}")
+                console.print()
+
             # Show restart instructions
             if result["restart_instructions"]:
                 console.print(

claude_mpm/cli/executor.py

@@ -150,6 +150,16 @@ def execute_command(command: str, args) -> int:
         result = summarize_command(args)
         return result if result is not None else 0
 
+    # Handle profile command with lazy import
+    if command == "profile":
+        # Lazy import to avoid loading unless needed
+        from .commands.profile import ProfileCommand
+
+        cmd = ProfileCommand()
+        result = cmd.run(args)
+        # Convert CommandResult to exit code
+        return result.exit_code if result else 0
+
     # Handle auto-configure command with lazy import
     if command == "auto-configure":
         # Lazy import to avoid loading unless needed

claude_mpm/cli/interactive/agent_wizard.py

@@ -1374,7 +1374,7 @@ class AgentWizard:
                         Path.home()
                         / ".claude-mpm"
                         / "cache"
-                        / "remote-agents"
+                        / "agents"
                         / "bobmatnyc"
                         / "claude-mpm-agents"
                         / "AUTO-DEPLOY-INDEX.md"
@@ -1419,7 +1419,7 @@ class AgentWizard:
                         Path.home()
                         / ".claude-mpm"
                         / "cache"
-                        / "remote-agents"
+                        / "agents"
                         / "bobmatnyc"
                         / "claude-mpm-agents"
                         / "AUTO-DEPLOY-INDEX.md"

claude_mpm/cli/parsers/base_parser.py

@@ -438,6 +438,13 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .profile_parser import add_profile_subparser
+
+        add_profile_subparser(subparsers)
+    except ImportError:
+        pass
+
     try:
         from .monitor_parser import add_monitor_subparser
 

claude_mpm/cli/parsers/profile_parser.py

@@ -0,0 +1,147 @@
+"""
+Profile command parser for claude-mpm CLI.
+
+WHY: This module provides the profile command for managing deployment profiles
+that control which agents and skills are deployed.
+
+DESIGN DECISION: Provides intuitive subcommands for listing, activating,
+and inspecting profiles to reduce context usage by limiting deployed components.
+"""
+
+import argparse
+
+from .base_parser import add_common_arguments
+
+
+def add_profile_subparser(subparsers) -> argparse.ArgumentParser:
+    """
+    Add the profile subparser for deployment profile management.
+
+    WHY: Users need to manage which agents and skills are deployed to reduce
+    context usage and improve performance. Profiles define enabled/disabled
+    agents and skills for specific workflows.
+
+    Args:
+        subparsers: The subparsers object from the main parser
+
+    Returns:
+        The configured profile subparser
+    """
+    # Profile command with subcommands
+    profile_parser = subparsers.add_parser(
+        "profile",
+        help="Manage deployment profiles for agents and skills",
+        description="""
+Deployment profile management for Claude MPM.
+
+Profiles control which agents and skills are deployed, reducing context usage
+by limiting available agents to only what's needed for your workflow.
+
+Available commands:
+  list      List all available profiles
+  set       Set the active profile
+  status    Show current active profile and filtering summary
+  show      Show detailed configuration of a profile
+
+Example workflows:
+  # List available profiles
+  claude-mpm profile list
+
+  # Activate a profile
+  claude-mpm profile set framework-development
+
+  # Check current profile status
+  claude-mpm profile status
+
+  # View profile details
+  claude-mpm profile show framework-development
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(profile_parser)
+
+    # Add subcommands
+    profile_subparsers = profile_parser.add_subparsers(
+        dest="profile_command",
+        help="Profile management commands",
+        metavar="SUBCOMMAND",
+    )
+
+    # List subcommand
+    list_parser = profile_subparsers.add_parser(
+        "list",
+        help="List all available deployment profiles",
+        description="""
+List all profiles found in .claude-mpm/profiles/ directory.
+
+Shows profile names, descriptions, and indicates which profile is currently active.
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(list_parser)
+
+    # Set subcommand
+    set_parser = profile_subparsers.add_parser(
+        "set",
+        help="Set the active deployment profile",
+        description="""
+Set the active deployment profile.
+
+This updates configuration.yaml with the selected profile, which will be
+applied on next startup or when running 'claude-mpm init'.
+
+Examples:
+  # Activate framework development profile
+  claude-mpm profile set framework-development
+
+  # Activate minimal profile for focused work
+  claude-mpm profile set minimal
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(set_parser)
+    set_parser.add_argument(
+        "profile_name",
+        help="Name of profile to activate (without .yaml extension)",
+    )
+
+    # Status subcommand
+    status_parser = profile_subparsers.add_parser(
+        "status",
+        help="Show current active profile and filtering summary",
+        description="""
+Display current active profile with filtering summary.
+
+Shows:
+- Active profile name
+- Number of agents enabled/disabled
+- Number of skills enabled/disabled
+- Disabled skill patterns
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(status_parser)
+
+    # Show subcommand
+    show_parser = profile_subparsers.add_parser(
+        "show",
+        help="Show detailed configuration of a profile",
+        description="""
+Display detailed configuration of a specific profile.
+
+Shows complete lists of enabled/disabled agents and skills, including
+glob patterns for skill filtering.
+
+Examples:
+  # Show framework development profile details
+  claude-mpm profile show framework-development
+""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    add_common_arguments(show_parser)
+    show_parser.add_argument(
+        "profile_name",
+        help="Name of profile to display (without .yaml extension)",
+    )
+
+    return profile_parser

claude_mpm/cli/parsers/skills_parser.py

@@ -167,12 +167,6 @@ def add_skills_subparser(subparsers) -> argparse.ArgumentParser:
         action="store_true",
         help="Force redeployment of already deployed skills",
     )
-    deploy_github_parser.add_argument(
-        "--all-skills",
-        action="store_true",
-        dest="all_skills",
-        help="Deploy ALL available skills (not just agent-referenced). By default, only skills referenced in agent frontmatter are deployed.",
-    )
 
     # List available GitHub skills
     list_available_parser = skills_subparsers.add_parser(