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

claude_mpm/cli/commands/commander.py

@@ -0,0 +1,46 @@
+"""Commander command handler for CLI."""
+
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def handle_commander_command(args) -> int:
+    """Handle the commander command.
+
+    Args:
+        args: Parsed command line arguments with:
+            - port: Port for internal services (default: 8765)
+            - state_dir: Optional state directory path
+            - debug: Enable debug logging
+
+    Returns:
+        Exit code (0 for success, 1 for error)
+    """
+    try:
+        # Import here to avoid circular dependencies
+        from claude_mpm.commander.chat.cli import run_commander
+
+        # Setup debug logging if requested
+        if getattr(args, "debug", False):
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            )
+
+        # Get arguments
+        port = getattr(args, "port", 8765)
+        state_dir = getattr(args, "state_dir", None)
+
+        # Run commander
+        asyncio.run(run_commander(port=port, state_dir=state_dir))
+
+        return 0
+
+    except KeyboardInterrupt:
+        logger.info("Commander interrupted by user")
+        return 0
+    except Exception as e:
+        logger.error(f"Commander error: {e}", exc_info=True)
+        return 1

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/executor.py

@@ -127,6 +127,14 @@ def execute_command(command: str, args) -> int:
         result = handle_verify(args)
         return result if result is not None else 0
 
+    # Handle commander command with lazy import
+    if command == "commander":
+        # Lazy import to avoid loading unless needed
+        from .commands.commander import handle_commander_command
+
+        result = handle_commander_command(args)
+        return result if result is not None else 0
+
     # Handle skill-source command with lazy import
     if command == "skill-source":
         # Lazy import to avoid loading unless needed
@@ -206,35 +214,127 @@ def execute_command(command: str, args) -> int:
             "status": show_status,
         }
 
-        # Get handler and invoke
+        # Get handler and call it with argument list (same pattern as autotodos)
         handler = handlers.get(subcommand)
         if handler:
-            # Build Click context programmatically
-            import click
+            try:
+                # Build argument list for Click command based on subcommand
+                click_args = []
+
+                # list command: --format, --hook-type
+                if subcommand == "list":
+                    if hasattr(args, "format") and args.format:
+                        click_args.extend(["--format", args.format])
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                # clear command: --hook-type, -y
+                elif subcommand == "clear":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.extend(["--hook-type", args.hook_type])
+                    if hasattr(args, "yes") and args.yes:
+                        click_args.append("-y")
+                # diagnose command: hook_type (positional argument)
+                elif subcommand == "diagnose":
+                    if hasattr(args, "hook_type") and args.hook_type:
+                        click_args.append(args.hook_type)
+                # status and summary commands: no options
+
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
+                return 0
+            except SystemExit as e:
+                return e.code if e.code is not None else 0
+            except Exception as e:
+                print(f"Error: {e}")
+                return 1
+        else:
+            print(f"Unknown hook-errors subcommand: {subcommand}")
+            return 1
 
-            ctx = click.Context(command=handler)
+    # Handle autotodos command with lazy import
+    if command == "autotodos":
+        # Lazy import to avoid loading unless needed
+        from .commands.autotodos import (
+            clear_autotodos,
+            inject_autotodos,
+            list_autotodos,
+            list_pm_violations,
+            scan_delegation_patterns,
+            show_autotodos_status,
+        )
 
-            # Prepare keyword arguments from args
-            kwargs = {}
-            if hasattr(args, "format"):
-                kwargs["format"] = args.format
-            if hasattr(args, "hook_type"):
-                kwargs["hook_type"] = args.hook_type
-            if hasattr(args, "yes"):
-                kwargs["yes"] = args.yes
+        # Get subcommand
+        subcommand = getattr(args, "autotodos_command", "status")
+        if not subcommand:
+            subcommand = "status"
 
+        # Map subcommands to functions
+        handlers = {
+            "list": list_autotodos,
+            "inject": inject_autotodos,
+            "clear": clear_autotodos,
+            "status": show_autotodos_status,
+            "scan": scan_delegation_patterns,
+            "violations": list_pm_violations,
+        }
+
+        # Get handler and call it with standalone_mode=False
+        handler = handlers.get(subcommand)
+        if handler:
             try:
-                # Invoke handler with arguments
-                with ctx:
-                    handler.invoke(ctx, **kwargs)
+                # Build argument list for Click command
+                click_args = []
+
+                if subcommand == "list":
+                    fmt = getattr(args, "format", "table")
+                    click_args = ["--format", fmt]
+                elif subcommand == "inject":
+                    output = getattr(args, "output", None)
+                    if output:
+                        click_args = ["--output", output]
+                elif subcommand == "clear":
+                    error_key = getattr(args, "error_key", None)
+                    event_type = getattr(args, "event_type", "all")
+                    if error_key:
+                        click_args.append("--error-key")
+                        click_args.append(error_key)
+                    if event_type != "all":
+                        click_args.append("--event-type")
+                        click_args.append(event_type)
+                    if getattr(args, "yes", False):
+                        click_args.append("-y")
+                elif subcommand == "scan":
+                    text = getattr(args, "text", None)
+                    file = getattr(args, "file", None)
+                    fmt = getattr(args, "format", "table")
+                    save = getattr(args, "save", False)
+
+                    if text:
+                        click_args.append(text)
+                    if file:
+                        click_args.extend(["--file", file])
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+                    if save:
+                        click_args.append("--save")
+                elif subcommand == "violations":
+                    fmt = getattr(args, "format", "table")
+                    if fmt != "table":
+                        click_args.extend(["--format", fmt])
+
+                # Call Click command with argument list and standalone_mode=False
+                handler(click_args, standalone_mode=False)
                 return 0
             except SystemExit as e:
                 return e.code if e.code is not None else 0
             except Exception as e:
                 print(f"Error: {e}")
+                import traceback
+
+                traceback.print_exc()
                 return 1
         else:
-            print(f"Unknown hook-errors subcommand: {subcommand}")
+            print(f"Unknown autotodos subcommand: {subcommand}")
             return 1
 
     # Map stable commands to their implementations
@@ -260,6 +360,7 @@ def execute_command(command: str, args) -> int:
         CLICommands.SKILLS.value: manage_skills,
         "debug": manage_debug,  # Add debug command
         "mpm-init": None,  # Will be handled separately with lazy import
+        "commander": None,  # Will be handled separately with lazy import
     }
 
     # Execute command if found
@@ -287,6 +388,8 @@ def execute_command(command: str, args) -> int:
         "local-deploy",
         "skill-source",
         "agent-source",
+        "hook-errors",
+        "autotodos",
     ]
 
     suggestion = suggest_similar_commands(command, all_commands)

claude_mpm/cli/parsers/base_parser.py

@@ -125,7 +125,7 @@ def _get_enhanced_version(base_version: str) -> str:
 
         if enhanced and enhanced != base_version:
             return enhanced
-    except Exception:
+    except Exception:  # nosec B110
         # If anything fails, fall back to base version
         pass
 
@@ -297,6 +297,16 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         action="store_true",
         help="Force refresh agents and skills from remote repos, bypassing ETag cache",
     )
+    run_group.add_argument(
+        "--chrome",
+        action="store_true",
+        help="Enable Claude in Chrome integration (passed to Claude Code)",
+    )
+    run_group.add_argument(
+        "--no-chrome",
+        action="store_true",
+        help="Disable Claude in Chrome integration (passed to Claude Code)",
+    )
 
     # Dependency checking options (for backward compatibility at top level)
     dep_group_top = parser.add_argument_group(
@@ -492,6 +502,13 @@ def create_parser(
     except ImportError:
         pass
 
+    try:
+        from .commander_parser import add_commander_subparser
+
+        add_commander_subparser(subparsers)
+    except ImportError:
+        pass
+
     # Add uninstall command parser
     try:
         from ..commands.uninstall import add_uninstall_parser
@@ -607,6 +624,59 @@ def create_parser(
             help="Skip confirmation prompts",
         )
 
+        # Add autotodos command for auto-generating todos from hook errors
+        autotodos_parser = subparsers.add_parser(
+            "autotodos",
+            help="Auto-generate todos from hook errors and delegation patterns",
+        )
+        autotodos_parser.add_argument(
+            "autotodos_command",
+            nargs="?",
+            choices=["list", "inject", "clear", "status", "scan", "violations"],
+            help="AutoTodos subcommand",
+        )
+        autotodos_parser.add_argument(
+            "text",
+            nargs="?",
+            help="Text to scan for delegation patterns (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "--format",
+            choices=["table", "json"],
+            default="table",
+            help="Output format for list/scan commands",
+        )
+        autotodos_parser.add_argument(
+            "--output",
+            help="Output file path for inject command",
+        )
+        autotodos_parser.add_argument(
+            "--error-key",
+            help="Specific error key to clear",
+        )
+        autotodos_parser.add_argument(
+            "--event-type",
+            choices=["error", "violation", "all"],
+            default="all",
+            help="Type of events to clear (clear command only)",
+        )
+        autotodos_parser.add_argument(
+            "--file",
+            "-f",
+            help="Scan text from file (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "--save",
+            action="store_true",
+            help="Save detections to event log (scan command only)",
+        )
+        autotodos_parser.add_argument(
+            "-y",
+            "--yes",
+            action="store_true",
+            help="Skip confirmation prompts",
+        )
+
         # Add summarize command
         from ..commands.summarize import add_summarize_parser