claude-mpm 5.4.55__py3-none-any.whl → 5.6.1__py3-none-any.whl

claude_mpm/cli/commands/hook_errors.py

@@ -57,33 +57,33 @@ def list_errors(format, hook_type):
 
     if not errors:
         if hook_type:
-            click.echo(f"No errors recorded for hook type: {hook_type}")
+            click.echo(f"No errors recorded for hook type: {hook_type}", err=True)
         else:
-            click.echo("No errors recorded. Hook system is healthy! ✅")
+            click.echo("No errors recorded. Hook system is healthy! ✅", err=True)
         return
 
     if format == "json":
         # JSON output
-        click.echo(json.dumps(errors, indent=2))
+        click.echo(json.dumps(errors, indent=2), err=True)
     else:
         # Table output
-        click.echo("\n" + "=" * 80)
-        click.echo("Hook Error Memory Report")
-        click.echo("=" * 80)
+        click.echo("\n" + "=" * 80, err=True)
+        click.echo("Hook Error Memory Report", err=True)
+        click.echo("=" * 80, err=True)
 
         for key, data in errors.items():
-            click.echo(f"\n🔴 Error: {data['type']}")
-            click.echo(f"   Hook Type: {data['hook_type']}")
-            click.echo(f"   Details: {data['details']}")
-            click.echo(f"   Match: {data['match']}")
-            click.echo(f"   Count: {data['count']} occurrences")
-            click.echo(f"   First Seen: {data['first_seen']}")
-            click.echo(f"   Last Seen: {data['last_seen']}")
+            click.echo(f"\n🔴 Error: {data['type']}", err=True)
+            click.echo(f"   Hook Type: {data['hook_type']}", err=True)
+            click.echo(f"   Details: {data['details']}", err=True)
+            click.echo(f"   Match: {data['match']}", err=True)
+            click.echo(f"   Count: {data['count']} occurrences", err=True)
+            click.echo(f"   First Seen: {data['first_seen']}", err=True)
+            click.echo(f"   Last Seen: {data['last_seen']}", err=True)
 
-        click.echo("\n" + "=" * 80)
-        click.echo(f"Total unique errors: {len(errors)}")
-        click.echo(f"Memory file: {error_memory.memory_file}")
-        click.echo("\nTo clear errors: claude-mpm hook-errors clear")
+        click.echo("\n" + "=" * 80, err=True)
+        click.echo(f"Total unique errors: {len(errors)}", err=True)
+        click.echo(f"Memory file: {error_memory.memory_file}", err=True)
+        click.echo("\nTo clear errors: claude-mpm hook-errors clear", err=True)
 
 
 @hook_errors_group.command(name="summary")
@@ -99,28 +99,28 @@ def show_summary():
     summary = error_memory.get_error_summary()
 
     if summary["total_errors"] == 0:
-        click.echo("No errors recorded. Hook system is healthy! ✅")
+        click.echo("No errors recorded. Hook system is healthy! ✅", err=True)
         return
 
-    click.echo("\n" + "=" * 80)
-    click.echo("Hook Error Summary")
-    click.echo("=" * 80)
-    click.echo("\n📊 Statistics:")
-    click.echo(f"   Total Errors: {summary['total_errors']}")
-    click.echo(f"   Unique Errors: {summary['unique_errors']}")
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("Hook Error Summary", err=True)
+    click.echo("=" * 80, err=True)
+    click.echo("\n📊 Statistics:", err=True)
+    click.echo(f"   Total Errors: {summary['total_errors']}", err=True)
+    click.echo(f"   Unique Errors: {summary['unique_errors']}", err=True)
 
     if summary["errors_by_type"]:
-        click.echo("\n🔍 Errors by Type:")
+        click.echo("\n🔍 Errors by Type:", err=True)
         for error_type, count in summary["errors_by_type"].items():
-            click.echo(f"   {error_type}: {count}")
+            click.echo(f"   {error_type}: {count}", err=True)
 
     if summary["errors_by_hook"]:
-        click.echo("\n🎣 Errors by Hook Type:")
+        click.echo("\n🎣 Errors by Hook Type:", err=True)
         for hook_type, count in summary["errors_by_hook"].items():
-            click.echo(f"   {hook_type}: {count}")
+            click.echo(f"   {hook_type}: {count}", err=True)
 
-    click.echo(f"\n📁 Memory File: {summary['memory_file']}")
-    click.echo("\nFor detailed list: claude-mpm hook-errors list")
+    click.echo(f"\n📁 Memory File: {summary['memory_file']}", err=True)
+    click.echo("\nFor detailed list: claude-mpm hook-errors list", err=True)
 
 
 @hook_errors_group.command(name="clear")
@@ -158,21 +158,21 @@ def clear_errors(hook_type, yes):
         scope = "all hook types"
 
     if count == 0:
-        click.echo(f"No errors to clear {scope}.")
+        click.echo(f"No errors to clear {scope}.", err=True)
         return
 
     # Confirm if not using -y flag
     if not yes:
         message = f"Clear {count} error(s) {scope}?"
         if not click.confirm(message):
-            click.echo("Cancelled.")
+            click.echo("Cancelled.", err=True)
             return
 
     # Clear errors
     error_memory.clear_errors(hook_type)
 
-    click.echo(f"✅ Cleared {count} error(s) {scope}.")
-    click.echo("\nHooks will be retried on next execution.")
+    click.echo(f"✅ Cleared {count} error(s) {scope}.", err=True)
+    click.echo("\nHooks will be retried on next execution.", err=True)
 
 
 @hook_errors_group.command(name="diagnose")
@@ -201,19 +201,19 @@ def diagnose_errors(hook_type):
 
     if not errors:
         if hook_type:
-            click.echo(f"No errors to diagnose for hook type: {hook_type}")
+            click.echo(f"No errors to diagnose for hook type: {hook_type}", err=True)
         else:
-            click.echo("No errors to diagnose. Hook system is healthy! ✅")
+            click.echo("No errors to diagnose. Hook system is healthy! ✅", err=True)
         return
 
-    click.echo("\n" + "=" * 80)
-    click.echo("Hook Error Diagnostics")
-    click.echo("=" * 80)
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("Hook Error Diagnostics", err=True)
+    click.echo("=" * 80, err=True)
 
     for key, data in errors.items():
-        click.echo(f"\n🔴 Error: {data['type']}")
-        click.echo(f"   Hook: {data['hook_type']}")
-        click.echo(f"   Count: {data['count']} failures")
+        click.echo(f"\n🔴 Error: {data['type']}", err=True)
+        click.echo(f"   Hook: {data['hook_type']}", err=True)
+        click.echo(f"   Count: {data['count']} failures", err=True)
 
         # Generate and show fix suggestion
         error_info = {
@@ -223,13 +223,13 @@ def diagnose_errors(hook_type):
         }
         suggestion = error_memory.suggest_fix(error_info)
 
-        click.echo("\n" + "-" * 80)
-        click.echo(suggestion)
-        click.echo("-" * 80)
+        click.echo("\n" + "-" * 80, err=True)
+        click.echo(suggestion, err=True)
+        click.echo("-" * 80, err=True)
 
-    click.echo("\n" + "=" * 80)
-    click.echo("After fixing issues, clear errors to retry:")
-    click.echo("  claude-mpm hook-errors clear")
+    click.echo("\n" + "=" * 80, err=True)
+    click.echo("After fixing issues, clear errors to retry:", err=True)
+    click.echo("  claude-mpm hook-errors clear", err=True)
 
 
 @hook_errors_group.command(name="status")
@@ -244,27 +244,27 @@ def show_status():
     error_memory = get_hook_error_memory()
     summary = error_memory.get_error_summary()
 
-    click.echo("\n📊 Hook Error Memory Status")
-    click.echo("=" * 80)
+    click.echo("\n📊 Hook Error Memory Status", err=True)
+    click.echo("=" * 80, err=True)
 
     if summary["total_errors"] == 0:
-        click.echo("✅ Status: Healthy (no errors recorded)")
+        click.echo("✅ Status: Healthy (no errors recorded)", err=True)
     else:
-        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded")
-        click.echo(f"   Unique errors: {summary['unique_errors']}")
+        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded", err=True)
+        click.echo(f"   Unique errors: {summary['unique_errors']}", err=True)
 
         # Show which hooks are affected
         if summary["errors_by_hook"]:
             affected_hooks = list(summary["errors_by_hook"].keys())
-            click.echo(f"   Affected hooks: {', '.join(affected_hooks)}")
+            click.echo(f"   Affected hooks: {', '.join(affected_hooks)}", err=True)
 
-    click.echo(f"\n📁 Memory file: {summary['memory_file']}")
-    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}")
+    click.echo(f"\n📁 Memory file: {summary['memory_file']}", err=True)
+    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}", err=True)
 
-    click.echo("\nCommands:")
-    click.echo("  claude-mpm hook-errors list      # View detailed errors")
-    click.echo("  claude-mpm hook-errors diagnose  # Get fix suggestions")
-    click.echo("  claude-mpm hook-errors clear     # Clear and retry")
+    click.echo("\nCommands:", err=True)
+    click.echo("  claude-mpm hook-errors list      # View detailed errors", err=True)
+    click.echo("  claude-mpm hook-errors diagnose  # Get fix suggestions", err=True)
+    click.echo("  claude-mpm hook-errors clear     # Clear and retry", err=True)
 
 
 # Register the command group

claude_mpm/cli/commands/monitor.py

@@ -118,7 +118,7 @@ class MonitorCommand(BaseCommand):
                 # Check if it's actually running
                 if not self.daemon.lifecycle.is_running():
                     return CommandResult.error_result(
-                        "Monitor daemon failed to start. Check ~/.claude-mpm/monitor-daemon.log for details."
+                        "Monitor daemon failed to start. Check ~/.claude-mpm/logs/monitor-daemon-*.log for details."
                     )
 
                 # Get the actual PID
@@ -146,7 +146,7 @@ class MonitorCommand(BaseCommand):
             pass
 
         return CommandResult.error_result(
-            "Failed to start unified monitor daemon. Check ~/.claude-mpm/monitor-daemon.log for details."
+            "Failed to start unified monitor daemon. Check ~/.claude-mpm/logs/monitor-daemon-*.log for details."
         )
 
     def _stop_monitor(self, args) -> CommandResult:

claude_mpm/cli/commands/mpm_init/core.py

@@ -688,9 +688,9 @@ class MPMInitCommand:
         return len(text) // 4
 
     def _deploy_pm_skills(self) -> None:
-        """Deploy PM skills templates to project .claude-mpm directory.
+        """Deploy PM skills templates to project .claude directory.
 
-        Copies PM skills from bundled templates to .claude-mpm/skills/pm/
+        Copies PM skills from bundled templates to .claude/skills/
         with version tracking and checksum validation.
         """
         try:

claude_mpm/cli/commands/run.py

@@ -13,7 +13,7 @@ DESIGN DECISIONS:
 - Support multiple output formats (json, yaml, table, text)
 """
 
-import subprocess
+import subprocess  # nosec B404 - required for process management
 import sys
 from datetime import datetime, timezone
 from typing import Optional
@@ -489,6 +489,18 @@ class RunCommand(BaseCommand):
         if hasattr(args, "claude_args") and args.claude_args:
             claude_args.extend(args.claude_args)
 
+        # Add --resume if flag is set
+        if getattr(args, "resume", False) and "--resume" not in claude_args:
+            claude_args.insert(0, "--resume")
+
+        # Add --chrome if flag is set
+        if getattr(args, "chrome", False) and "--chrome" not in claude_args:
+            claude_args.insert(0, "--chrome")
+
+        # Add --no-chrome if flag is set
+        if getattr(args, "no_chrome", False) and "--no-chrome" not in claude_args:
+            claude_args.insert(0, "--no-chrome")
+
         # Create runner
         runner = ClaudeRunner(
             enable_tickets=enable_tickets,
@@ -553,7 +565,7 @@ class RunCommand(BaseCommand):
                 wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
                 if wrapper_path.exists():
                     print("Starting interactive session with command interception...")
-                    subprocess.run([sys.executable, str(wrapper_path)], check=False)
+                    subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
                 else:
                     self.logger.warning(
                         "Interactive wrapper not found, falling back to normal mode"
@@ -907,6 +919,26 @@ def run_session_legacy(args):
         else:
             logger.info("[INFO]️ --resume already in claude_args")
 
+    # Add --chrome to claude_args if the flag is set
+    chrome_flag_present = getattr(args, "chrome", False)
+    if chrome_flag_present:
+        logger.info("📌 --chrome flag detected in args")
+        if "--chrome" not in raw_claude_args:
+            raw_claude_args = ["--chrome", *raw_claude_args]
+            logger.info("✅ Added --chrome to claude_args")
+        else:
+            logger.info("ℹ️ --chrome already in claude_args")
+
+    # Add --no-chrome to claude_args if the flag is set
+    no_chrome_flag_present = getattr(args, "no_chrome", False)
+    if no_chrome_flag_present:
+        logger.info("📌 --no-chrome flag detected in args")
+        if "--no-chrome" not in raw_claude_args:
+            raw_claude_args = ["--no-chrome", *raw_claude_args]
+            logger.info("✅ Added --no-chrome to claude_args")
+        else:
+            logger.info("ℹ️ --no-chrome already in claude_args")
+
     # Filter out claude-mpm specific flags before passing to Claude CLI
     logger.debug(f"Pre-filter claude_args: {raw_claude_args}")
     claude_args = filter_claude_mpm_args(raw_claude_args)
@@ -1044,7 +1076,7 @@ def run_session_legacy(args):
         wrapper_path = get_scripts_dir() / "interactive_wrapper.py"
         if wrapper_path.exists():
             print("Starting interactive session with command interception...")
-            subprocess.run([sys.executable, str(wrapper_path)], check=False)
+            subprocess.run([sys.executable, str(wrapper_path)], check=False)  # nosec B603 - trusted internal paths
         else:
             logger.warning("Interactive wrapper not found, falling back to normal mode")
             runner.run_interactive(context)

claude_mpm/cli/commands/skills.py

@@ -18,7 +18,7 @@ ARCHITECTURE:
 """
 
 import os
-import subprocess
+import subprocess  # nosec B404
 from typing import Optional
 
 from rich.console import Console
@@ -84,6 +84,7 @@ class SkillsManagementCommand(BaseCommand):
                 SkillsCommands.INFO.value: self._show_skill_info,
                 SkillsCommands.CONFIG.value: self._manage_config,
                 SkillsCommands.CONFIGURE.value: self._configure_skills,
+                SkillsCommands.SELECT.value: self._select_skills_interactive,
                 # GitHub deployment commands
                 SkillsCommands.DEPLOY_FROM_GITHUB.value: self._deploy_from_github,
                 SkillsCommands.LIST_AVAILABLE.value: self._list_available_github_skills,
@@ -504,7 +505,7 @@ class SkillsManagementCommand(BaseCommand):
                 # Open in editor
                 editor = os.environ.get("EDITOR", "nano")
                 try:
-                    subprocess.run([editor, str(config_path)], check=True)
+                    subprocess.run([editor, str(config_path)], check=True)  # nosec B603
                     console.print(
                         f"\n[green]Configuration saved to {config_path}[/green]\n"
                     )
@@ -673,33 +674,91 @@ class SkillsManagementCommand(BaseCommand):
     def _check_deployed_skills(self, args) -> CommandResult:
         """Check currently deployed skills in ~/.claude/skills/."""
         try:
-            result = self.skills_deployer.check_deployed_skills()
+            # Get deployed skills
+            deployed_result = self.skills_deployer.check_deployed_skills()
+            deployed_names = {skill["name"] for skill in deployed_result["skills"]}
 
             console.print("\n[bold cyan]Claude Code Skills Status:[/bold cyan]\n")
-            console.print(f"[dim]Directory: {result['claude_skills_dir']}[/dim]\n")
+            console.print(
+                f"[dim]Directory: {deployed_result['claude_skills_dir']}[/dim]\n"
+            )
+
+            # Fetch available skills from GitHub to get full list
+            try:
+                available_result = self.skills_deployer.list_available_skills()
+                all_skills = available_result.get("skills", [])
+            except Exception as e:
+                console.print(
+                    f"[yellow]Warning: Could not fetch available skills: {e}[/yellow]\n"
+                )
+                all_skills = []
 
-            if result["deployed_count"] == 0:
-                console.print("[yellow]No skills currently deployed.[/yellow]")
+            # Combine deployed and available skills
+            skill_map = {}
+
+            # Add available skills
+            for skill in all_skills:
+                skill_name = skill.get("name", "")
+                if skill_name:
+                    skill_map[skill_name] = {
+                        "name": skill.get("display_name")
+                        or skill_name.replace("-", " ").title(),
+                        "skill_id": skill_name,
+                        "source": "MPM Skills",
+                        "is_deployed": skill_name in deployed_names,
+                    }
+
+            # Add any deployed skills not in available list (local/custom skills)
+            for skill in deployed_result["skills"]:
+                skill_name = skill["name"]
+                if skill_name not in skill_map:
+                    skill_map[skill_name] = {
+                        "name": skill_name.replace("-", " ").title(),
+                        "skill_id": skill_name,
+                        "source": "Local",
+                        "is_deployed": True,
+                    }
+
+            if not skill_map:
+                console.print("[yellow]No skills available.[/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 matching agent management format
+            table = Table(show_header=True, header_style="bold cyan")
+            table.add_column("#", style="bright_black", width=6, no_wrap=True)
+            table.add_column(
+                "Skill ID", style="bright_black", no_wrap=True, overflow="ellipsis"
             )
+            table.add_column(
+                "Name", style="bright_cyan", no_wrap=True, overflow="ellipsis"
+            )
+            table.add_column("Source", style="bright_yellow", no_wrap=True)
+            table.add_column("Status", style="bright_black", no_wrap=True)
 
-            # 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")
+            # Sort skills by name for consistent display
+            sorted_skills = sorted(skill_map.values(), key=lambda s: s["skill_id"])
 
-            for skill in sorted(result["skills"], key=lambda s: s["name"]):
-                table.add_row(skill["name"], skill["path"])
+            for idx, skill in enumerate(sorted_skills, 1):
+                status = (
+                    "[green]Installed[/green]" if skill["is_deployed"] else "Available"
+                )
+                table.add_row(
+                    str(idx), skill["skill_id"], skill["name"], skill["source"], status
+                )
 
             console.print(table)
             console.print()
 
+            # Show summary
+            deployed_count = sum(1 for s in skill_map.values() if s["is_deployed"])
+            console.print(
+                f"[dim]Showing {len(skill_map)} skills ({deployed_count} installed, "
+                f"{len(skill_map) - deployed_count} available)[/dim]\n"
+            )
+
             return CommandResult(success=True, exit_code=0)
 
         except Exception as e:
@@ -1222,6 +1281,99 @@ class SkillsManagementCommand(BaseCommand):
             console.print(f"[dim]{traceback.format_exc()}[/dim]")
             return CommandResult(success=False, message=str(e), exit_code=1)
 
+    def _select_skills_interactive(self, args) -> CommandResult:
+        """Interactive skill selection with topic grouping.
+
+        This command provides a two-tier selection interface:
+        1. Select topic groups (toolchains) to explore
+        2. Multi-select skills within each topic group
+
+        Features:
+        - Groups skills by toolchain (universal, python, typescript, etc.)
+        - Shows skills auto-included by agent dependencies
+        - Displays token counts for each skill
+        - Updates config and runs reconciliation
+
+        Returns:
+            CommandResult with success/failure status
+        """
+        try:
+            from ...cli.interactive.skill_selector import run_skill_selector
+            from ...core.unified_config import UnifiedConfig
+            from ...services.agents.deployment.deployment_reconciler import (
+                DeploymentReconciler,
+            )
+
+            console.print("\n[bold cyan]Interactive Skill Selector[/bold cyan]\n")
+
+            # Run skill selector
+            selected_skills = run_skill_selector()
+
+            if selected_skills is None:
+                console.print("\n[yellow]Skill selection cancelled[/yellow]")
+                return CommandResult(success=True, exit_code=0)
+
+            # Update config with selected skills
+            config = UnifiedConfig()
+            config.skills.enabled = selected_skills
+
+            # Save config
+            try:
+                config.save()
+                console.print(
+                    f"\n[green]✓ Saved {len(selected_skills)} skills to configuration[/green]"
+                )
+            except Exception as e:
+                console.print(f"\n[red]Failed to save configuration: {e}[/red]")
+                return CommandResult(success=False, message=str(e), exit_code=1)
+
+            # Run reconciliation to deploy skills
+            console.print("\n[cyan]Running skill reconciliation...[/cyan]")
+            reconciler = DeploymentReconciler(config)
+
+            try:
+                from pathlib import Path
+
+                project_path = Path.cwd()
+                result = reconciler.reconcile_skills(project_path)
+
+                if result.deployed:
+                    console.print(
+                        f"  [green]✓ Deployed: {', '.join(result.deployed)}[/green]"
+                    )
+                if result.removed:
+                    console.print(
+                        f"  [yellow]✓ Removed: {', '.join(result.removed)}[/yellow]"
+                    )
+                if result.errors:
+                    for error in result.errors:
+                        console.print(f"  [red]✗ {error}[/red]")
+
+                if result.success:
+                    console.print(
+                        "\n[bold green]✓ Skill deployment complete![/bold green]"
+                    )
+                    return CommandResult(success=True, exit_code=0)
+                console.print(
+                    f"\n[yellow]⚠ Deployment had {len(result.errors)} errors[/yellow]"
+                )
+                return CommandResult(
+                    success=False,
+                    message=f"{len(result.errors)} deployment errors",
+                    exit_code=1,
+                )
+
+            except Exception as e:
+                console.print(f"\n[red]Reconciliation failed: {e}[/red]")
+                return CommandResult(success=False, message=str(e), exit_code=1)
+
+        except Exception as e:
+            console.print(f"[red]Skill selection error: {e}[/red]")
+            import traceback
+
+            console.print(f"[dim]{traceback.format_exc()}[/dim]")
+            return CommandResult(success=False, message=str(e), exit_code=1)
+
 
 def manage_skills(args) -> int:
     """