claude-mpm 5.4.71__py3-none-any.whl → 5.4.74__py3-none-any.whl

claude_mpm/cli/commands/agents.py

@@ -1379,7 +1379,7 @@ class AgentsCommand(AgentCommand):
                 return CommandResult.error_result("agent_id is required")
 
             import os
-            import subprocess
+            import subprocess  # nosec B404
 
             from ...services.agents.local_template_manager import (
                 LocalAgentTemplateManager,
@@ -1415,7 +1415,7 @@ class AgentsCommand(AgentCommand):
 
             # Use system editor
             editor = getattr(args, "editor", None) or os.environ.get("EDITOR", "nano")
-            subprocess.run([editor, str(template_file)], check=True)
+            subprocess.run([editor, str(template_file)], check=True)  # nosec B603
             return CommandResult.success_result(
                 f"Agent '{agent_id}' edited successfully"
             )
@@ -1519,8 +1519,6 @@ class AgentsCommand(AgentCommand):
             console.print("For a better experience with integrated configuration:")
             console.print("  • Agent management")
             console.print("  • Skills management")
-            console.print("  • Template editing")
-            console.print("  • Behavior configuration")
             console.print("  • Startup settings\n")
 
             console.print("Please use: [bold green]claude-mpm config[/bold green]\n")

claude_mpm/cli/commands/agents_reconcile.py

@@ -0,0 +1,197 @@
+"""
+Agent/Skill Reconciliation CLI Command
+
+Shows the reconciliation view between configured and deployed agents/skills,
+and performs reconciliation (deploy missing, remove unneeded).
+
+Usage:
+    claude-mpm agents reconcile [--dry-run] [--show-only]
+    claude-mpm skills reconcile [--dry-run] [--show-only]
+"""
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from ...core.unified_config import UnifiedConfig
+from ...services.agents.deployment.deployment_reconciler import (
+    DeploymentReconciler,
+    ReconciliationState,
+)
+from ..shared import BaseCommand, CommandResult
+
+
+class AgentsReconcileCommand(BaseCommand):
+    """CLI command for agent reconciliation."""
+
+    def __init__(self):
+        super().__init__("agents-reconcile")
+        self.console = Console()
+
+    def run(self, args) -> CommandResult:
+        """Execute reconciliation."""
+        # Load config
+        config = UnifiedConfig()
+        reconciler = DeploymentReconciler(config)
+
+        # Get project path
+        project_path = Path(getattr(args, "project_path", "."))
+
+        # Show current state
+        if getattr(args, "show_only", False) or getattr(args, "dry_run", False):
+            return self._show_reconciliation_view(reconciler, project_path)
+
+        # Perform reconciliation
+        return self._reconcile_agents(reconciler, project_path)
+
+    def _show_reconciliation_view(
+        self, reconciler: DeploymentReconciler, project_path: Path
+    ) -> CommandResult:
+        """Show reconciliation view without making changes."""
+        view = reconciler.get_reconciliation_view(project_path)
+        agent_state = view["agents"]
+        skill_state = view["skills"]
+
+        # Display agents table
+        self.console.print(
+            "\n[bold blue]═══ Agent Reconciliation View ═══[/bold blue]\n"
+        )
+        agent_table = self._build_reconciliation_table(agent_state, "Agent")
+        self.console.print(agent_table)
+
+        # Display skills table
+        self.console.print(
+            "\n[bold blue]═══ Skill Reconciliation View ═══[/bold blue]\n"
+        )
+        skill_table = self._build_reconciliation_table(skill_state, "Skill")
+        self.console.print(skill_table)
+
+        # Show summary
+        self._show_summary(agent_state, skill_state)
+
+        return CommandResult.success_result("Reconciliation view displayed")
+
+    def _build_reconciliation_table(
+        self, state: ReconciliationState, item_type: str
+    ) -> Table:
+        """Build Rich table for reconciliation state."""
+        table = Table(title=f"{item_type} Deployment Status")
+
+        table.add_column(f"{item_type}", style="cyan", no_wrap=True)
+        table.add_column("Configured", style="green")
+        table.add_column("Deployed", style="yellow")
+        table.add_column("Action", style="magenta")
+
+        # All items to consider
+        all_items = state.configured | state.deployed | state.cached
+
+        for item_id in sorted(all_items):
+            configured = "✓" if item_id in state.configured else "✗"
+            deployed = "✓" if item_id in state.deployed else "✗"
+
+            # Determine action
+            if item_id in state.to_deploy:
+                if item_id in state.cached:
+                    action = "Will deploy"
+                else:
+                    action = "[red]Missing in cache![/red]"
+            elif item_id in state.to_remove:
+                action = "Will remove"
+            elif item_id in state.unchanged:
+                action = "-"
+            elif item_id in state.cached and item_id not in state.configured:
+                action = "[dim]Available (not configured)[/dim]"
+            else:
+                action = "-"
+
+            table.add_row(item_id, configured, deployed, action)
+
+        return table
+
+    def _show_summary(
+        self, agent_state: ReconciliationState, skill_state: ReconciliationState
+    ) -> None:
+        """Show reconciliation summary."""
+        self.console.print("\n[bold]Summary:[/bold]")
+
+        # Agents
+        self.console.print("\nAgents:")
+        self.console.print(f"  Configured: {len(agent_state.configured)}")
+        self.console.print(f"  Deployed: {len(agent_state.deployed)}")
+        self.console.print(f"  To deploy: {len(agent_state.to_deploy)}")
+        self.console.print(f"  To remove: {len(agent_state.to_remove)}")
+        self.console.print(f"  Unchanged: {len(agent_state.unchanged)}")
+
+        # Skills
+        self.console.print("\nSkills:")
+        self.console.print(f"  Configured: {len(skill_state.configured)}")
+        self.console.print(f"  Deployed: {len(skill_state.deployed)}")
+        self.console.print(f"  To deploy: {len(skill_state.to_deploy)}")
+        self.console.print(f"  To remove: {len(skill_state.to_remove)}")
+        self.console.print(f"  Unchanged: {len(skill_state.unchanged)}")
+
+        # Show next steps
+        if agent_state.to_deploy or skill_state.to_deploy:
+            self.console.print(
+                "\n[yellow]Run without --show-only to perform deployment[/yellow]"
+            )
+
+    def _reconcile_agents(
+        self, reconciler: DeploymentReconciler, project_path: Path
+    ) -> CommandResult:
+        """Perform agent and skill reconciliation."""
+        # Show current state first
+        self._show_reconciliation_view(reconciler, project_path)
+
+        self.console.print("\n[bold blue]Performing reconciliation...[/bold blue]\n")
+
+        # Reconcile agents
+        self.console.print("[cyan]Reconciling agents...[/cyan]")
+        agent_result = reconciler.reconcile_agents(project_path)
+
+        if agent_result.deployed:
+            self.console.print(
+                f"  [green]✓ Deployed: {', '.join(agent_result.deployed)}[/green]"
+            )
+        if agent_result.removed:
+            self.console.print(
+                f"  [yellow]✓ Removed: {', '.join(agent_result.removed)}[/yellow]"
+            )
+        if agent_result.errors:
+            for error in agent_result.errors:
+                self.console.print(f"  [red]✗ {error}[/red]")
+
+        # Reconcile skills
+        self.console.print("\n[cyan]Reconciling skills...[/cyan]")
+        skill_result = reconciler.reconcile_skills(project_path)
+
+        if skill_result.deployed:
+            self.console.print(
+                f"  [green]✓ Deployed: {', '.join(skill_result.deployed)}[/green]"
+            )
+        if skill_result.removed:
+            self.console.print(
+                f"  [yellow]✓ Removed: {', '.join(skill_result.removed)}[/yellow]"
+            )
+        if skill_result.errors:
+            for error in skill_result.errors:
+                self.console.print(f"  [red]✗ {error}[/red]")
+
+        # Final summary
+        total_errors = len(agent_result.errors) + len(skill_result.errors)
+        if total_errors == 0:
+            self.console.print("\n[bold green]✓ Reconciliation complete![/bold green]")
+            return CommandResult.success_result("Reconciliation successful")
+        self.console.print(
+            f"\n[bold yellow]⚠ Reconciliation complete with {total_errors} errors[/bold yellow]"
+        )
+        return CommandResult.error_result(f"Reconciliation had {total_errors} errors")
+
+
+class SkillsReconcileCommand(AgentsReconcileCommand):
+    """CLI command for skill reconciliation (alias to agents reconcile)."""
+
+    def __init__(self):
+        BaseCommand.__init__(self, "skills-reconcile")
+        self.console = Console()

claude_mpm/cli/commands/configure.py

@@ -656,32 +656,84 @@ class ConfigureCommand(BaseCommand):
         self.behavior_manager.manage_behaviors()
 
     def _manage_skills(self) -> None:
-        """Skills management interface."""
+        """Skills management interface with table display."""
         from ...cli.interactive.skills_wizard import SkillsWizard
+        from ...skills.registry import get_registry
         from ...skills.skill_manager import get_manager
 
         wizard = SkillsWizard()
         manager = get_manager()
+        registry = get_registry()
 
         while True:
             self.console.clear()
             self._display_header()
 
-            self.console.print("\n[bold]Skills Management Options:[/bold]\n")
-            self.console.print("  [1] View Available Skills")
-            self.console.print("  [2] Configure Skills for Agents")
-            self.console.print("  [3] View Current Skill Mappings")
-            self.console.print("  [4] Auto-Link Skills to Agents")
-            self.console.print("  [b] Back to Main Menu")
+            # Display skills table
+            self._display_skills_table(registry)
+
+            # Show action options
+            self.console.print("\n[bold]Actions:[/bold]")
+            self.console.print("  [1] Toggle skill installation")
+            self.console.print("  [2] Configure skills for agents")
+            self.console.print("  [3] View current skill mappings")
+            self.console.print("  [4] Auto-link skills to agents")
+            self.console.print("  [b] Back to main menu")
             self.console.print()
 
             choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="b")
 
             if choice == "1":
-                # View available skills
+                # Toggle skill installation
                 self.console.clear()
                 self._display_header()
-                wizard.list_available_skills()
+                self._display_skills_table(registry)
+
+                skill_num = Prompt.ask(
+                    "\n[bold blue]Enter skill number to toggle (or 'b' to go back)[/bold blue]",
+                    default="b",
+                )
+
+                if skill_num == "b":
+                    continue
+
+                try:
+                    skill_idx = int(skill_num) - 1
+                    all_skills = self._get_all_skills_sorted(registry)
+
+                    if 0 <= skill_idx < len(all_skills):
+                        skill = all_skills[skill_idx]
+                        deployed_ids = self._get_deployed_skill_ids()
+
+                        if skill.skill_id in deployed_ids:
+                            # Uninstall
+                            confirm = Confirm.ask(
+                                f"\n[yellow]Uninstall skill '{skill.name}'?[/yellow]",
+                                default=False,
+                            )
+                            if confirm:
+                                self._uninstall_skill(skill)
+                                self.console.print(
+                                    f"\n[green]✓ Skill '{skill.name}' uninstalled[/green]"
+                                )
+                        else:
+                            # Install
+                            confirm = Confirm.ask(
+                                f"\n[cyan]Install skill '{skill.name}'?[/cyan]",
+                                default=True,
+                            )
+                            if confirm:
+                                self._install_skill(skill)
+                                self.console.print(
+                                    f"\n[green]✓ Skill '{skill.name}' installed[/green]"
+                                )
+                    else:
+                        self.console.print("[red]Invalid skill number[/red]")
+                except ValueError:
+                    self.console.print(
+                        "[red]Invalid input. Please enter a number.[/red]"
+                    )
+
                 Prompt.ask("\nPress Enter to continue")
 
             elif choice == "2":
@@ -805,6 +857,116 @@ class ConfigureCommand(BaseCommand):
                 self.console.print("[red]Invalid choice. Please try again.[/red]")
                 Prompt.ask("\nPress Enter to continue")
 
+    def _display_skills_table(self, registry) -> None:
+        """Display skills in a table format like agents."""
+        from rich import box
+        from rich.table import Table
+
+        # Get all skills and deployed skill IDs
+        all_skills = self._get_all_skills_sorted(registry)
+        deployed_ids = self._get_deployed_skill_ids()
+
+        # Create table with same styling as agents table
+        table = Table(show_header=True, header_style="bold cyan", box=box.ROUNDED)
+        table.add_column("#", style="bright_black", width=6)
+        table.add_column("Skill ID", style="bright_black", overflow="ellipsis")
+        table.add_column("Name", style="bright_cyan", overflow="ellipsis")
+        table.add_column("Source", style="bright_yellow")
+        table.add_column("Status", style="bright_black")
+
+        # Populate table
+        for i, skill in enumerate(all_skills, 1):
+            # Determine status
+            if skill.skill_id in deployed_ids:
+                status = "[green]Installed[/green]"
+            else:
+                status = "Available"
+
+            # Determine source label
+            if skill.source == "bundled":
+                source = "MPM Skills"
+            elif skill.source == "user":
+                source = "User Skills"
+            elif skill.source == "project":
+                source = "Project Skills"
+            else:
+                source = skill.source.title()
+
+            # Get display name (fallback to skill_id with formatting)
+            name = skill.name or skill.skill_id.replace("-", " ").title()
+
+            table.add_row(str(i), skill.skill_id, name, source, status)
+
+        self.console.print(table)
+
+        # Show summary
+        installed_count = len([s for s in all_skills if s.skill_id in deployed_ids])
+        self.console.print(
+            f"\nShowing {len(all_skills)} skills ({installed_count} installed)"
+        )
+
+    def _get_all_skills_sorted(self, registry):
+        """Get all skills from registry, sorted by source and name."""
+        # Get skills from all sources
+        bundled = registry.list_skills(source="bundled")
+        user = registry.list_skills(source="user")
+        project = registry.list_skills(source="project")
+
+        # Combine and sort: bundled first, then user, then project
+        # Within each group, sort by name
+        all_skills = []
+        all_skills.extend(sorted(bundled, key=lambda s: s.name.lower()))
+        all_skills.extend(sorted(user, key=lambda s: s.name.lower()))
+        all_skills.extend(sorted(project, key=lambda s: s.name.lower()))
+
+        return all_skills
+
+    def _get_deployed_skill_ids(self) -> set:
+        """Get set of deployed skill IDs from .claude/skills/ directory."""
+        from pathlib import Path
+
+        skills_dir = Path.cwd() / ".claude" / "skills"
+        if not skills_dir.exists():
+            return set()
+
+        # Each deployed skill is a directory in .claude/skills/
+        deployed_ids = set()
+        for skill_dir in skills_dir.iterdir():
+            if skill_dir.is_dir() and not skill_dir.name.startswith("."):
+                deployed_ids.add(skill_dir.name)
+
+        return deployed_ids
+
+    def _install_skill(self, skill) -> None:
+        """Install a skill to .claude/skills/ directory."""
+        import shutil
+        from pathlib import Path
+
+        # Target directory
+        target_dir = Path.cwd() / ".claude" / "skills" / skill.skill_id
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy skill file(s)
+        if skill.path.is_file():
+            # Single file skill - copy to skill.md in target directory
+            shutil.copy2(skill.path, target_dir / "skill.md")
+        elif skill.path.is_dir():
+            # Directory-based skill - copy all contents
+            for item in skill.path.iterdir():
+                if item.is_file():
+                    shutil.copy2(item, target_dir / item.name)
+                elif item.is_dir():
+                    shutil.copytree(item, target_dir / item.name, dirs_exist_ok=True)
+
+    def _uninstall_skill(self, skill) -> None:
+        """Uninstall a skill from .claude/skills/ directory."""
+        import shutil
+        from pathlib import Path
+
+        target_dir = Path.cwd() / ".claude" / "skills" / skill.skill_id
+        if target_dir.exists():
+            shutil.rmtree(target_dir)
+
     def _display_behavior_files(self) -> None:
         """Display current behavior files."""
         self.behavior_manager.display_behavior_files()
@@ -1437,18 +1599,20 @@ class ConfigureCommand(BaseCommand):
 
                 # Add inline control: Select/Deselect all from this collection
                 if all_selected:
+                    deselect_value = f"__DESELECT_ALL_{collection_id}__"
                     choices.append(
                         Choice(
-                            f"  [Deselect all from {collection_id}]",
-                            value=f"__DESELECT_ALL_{collection_id}__",
+                            f"  [Deselect all from {collection_id}]",  # nosec B608
+                            value=deselect_value,
                             checked=False,
                         )
                     )
                 else:
+                    select_value = f"__SELECT_ALL_{collection_id}__"
                     choices.append(
                         Choice(
-                            f"  [Select all from {collection_id}]",
-                            value=f"__SELECT_ALL_{collection_id}__",
+                            f"  [Select all from {collection_id}]",  # nosec B608
+                            value=select_value,
                             checked=False,
                         )
                     )
@@ -2329,7 +2493,8 @@ class ConfigureCommand(BaseCommand):
                 f"  Detection Quality: [{'green' if summary.get('detection_quality') == 'high' else 'yellow'}]{summary.get('detection_quality', 'unknown')}[/]"
             )
             self.console.print()
-        except Exception:
+        except Exception:  # nosec B110 - Suppress broad except for failed safety check
+            # Silent failure on safety check - non-critical feature
             pass
 
         # Build mapping: agent_id -> AgentConfig