claude-mpm 4.20.3__py3-none-any.whl → 5.1.8__py3-none-any.whl

claude_mpm/cli/commands/configure_agent_display.py

@@ -228,8 +228,8 @@ class AgentDisplay:
 [bold]Model:[/bold] {model}
 [bold]Agent Version:[/bold] {agent_version}
 [bold]Schema Version:[/bold] {schema_version}
-[bold]Tags:[/bold] {', '.join(tags) if tags else 'None'}
-[bold]Tools:[/bold] {', '.join(tools[:5]) if tools else 'None'}{'...' if len(tools) > 5 else ''}
+[bold]Tags:[/bold] {", ".join(tags) if tags else "None"}
+[bold]Tools:[/bold] {", ".join(tools[:5]) if tools else "None"}{"..." if len(tools) > 5 else ""}
 """
                     except Exception:
                         pass
@@ -237,9 +237,9 @@ class AgentDisplay:
                 # Create detail panel
                 detail_text = f"""
 [bold]Name:[/bold] {agent.name}
-[bold]Status:[/bold] {'[green]Enabled[/green]' if self.agent_manager.is_agent_enabled(agent.name) else '[red]Disabled[/red]'}
+[bold]Status:[/bold] {"[green]Enabled[/green]" if self.agent_manager.is_agent_enabled(agent.name) else "[red]Disabled[/red]"}
 [bold]Template Path:[/bold] {template_path}
-[bold]Is System Template:[/bold] {'Yes' if str(template_path).startswith(str(self.agent_manager.templates_dir)) else 'No (Custom)'}
+[bold]Is System Template:[/bold] {"Yes" if str(template_path).startswith(str(self.agent_manager.templates_dir)) else "No (Custom)"}
 {extra_info}
                 """
 

claude_mpm/cli/commands/configure_navigation.py

@@ -14,12 +14,13 @@ DESIGN DECISIONS:
 import os
 from pathlib import Path
 
+import questionary
+from questionary import Style
 from rich.box import ROUNDED
 from rich.columns import Columns
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Prompt
-from rich.table import Table
 from rich.text import Text
 
 
@@ -33,6 +34,16 @@ class ConfigNavigation:
     - Claude MPM launch integration
     """
 
+    # Questionary style matching Rich cyan theme
+    QUESTIONARY_STYLE = Style(
+        [
+            ("selected", "fg:cyan bold"),
+            ("pointer", "fg:cyan bold"),
+            ("highlighted", "fg:cyan"),
+            ("question", "fg:cyan bold"),
+        ]
+    )
+
     def __init__(self, console: Console, project_dir: Path):
         """Initialize navigation handler.
 
@@ -81,56 +92,62 @@ class ConfigNavigation:
         self.console.print()
 
     def show_main_menu(self) -> str:
-        """Show the main menu and get user choice.
+        """Show the main menu and get user choice with arrow-key navigation.
 
         Displays main configuration menu with options:
-        1. Agent Management
-        2. Skills Management
-        3. Template Editing
-        4. Behavior Files
-        5. Startup Configuration
-        6. Switch Scope
-        7. Version Info
-        l. Save & Launch
-        q. Quit
+        - Agent Management
+        - Skills Management
+        - Template Editing
+        - Behavior Files
+        - Startup Configuration
+        - Switch Scope
+        - Version Info
+        - Save & Launch
+        - Quit
 
         Returns:
-            User's menu choice (lowercase, stripped)
+            User's menu choice mapped to original key (1-7, l, q) for
+            backward compatibility with existing code
         """
-        menu_items = [
-            ("1", "Agent Management", "Enable/disable agents and customize settings"),
-            ("2", "Skills Management", "Configure skills for agents"),
-            ("3", "Template Editing", "Edit agent JSON templates"),
-            ("4", "Behavior Files", "Manage identity and workflow configurations"),
-            (
-                "5",
-                "Startup Configuration",
-                "Configure MCP services and agents to start",
-            ),
-            ("6", "Switch Scope", f"Current: {self.current_scope}"),
-            ("7", "Version Info", "Display MPM and Claude versions"),
-            ("l", "Save & Launch", "Save all changes and start Claude MPM"),
-            ("q", "Quit", "Exit without launching"),
-        ]
-
-        table = Table(show_header=False, box=None, padding=(0, 2))
-        table.add_column("Key", style="bold blue", width=4)  # Bolder shortcuts
-        table.add_column("Option", style="bold", width=24)  # Wider for titles
-        table.add_column("Description", style="")  # Use default terminal color
-
-        for key, option, desc in menu_items:
-            table.add_row(f"\\[{key}]", option, desc)
-
-        menu_panel = Panel(
-            table, title="[bold]Main Menu[/bold]", box=ROUNDED, style="green"
-        )
-
-        self.console.print(menu_panel)
-        self.console.print()
-
-        choice = Prompt.ask("[bold blue]Select an option[/bold blue]", default="q")
-        # Strip whitespace to handle leading/trailing spaces
-        return choice.strip().lower()
+        try:
+            choice = questionary.select(
+                "Main Menu:",
+                choices=[
+                    "Agent Management",
+                    "Skills Management",
+                    "Template Editing",
+                    "Behavior Files",
+                    "Startup Configuration",
+                    f"Switch Scope (Current: {self.current_scope})",
+                    "Version Info",
+                    questionary.Separator(),
+                    "Save & Launch Claude MPM",
+                    "Quit",
+                ],
+                style=self.QUESTIONARY_STYLE,
+            ).ask()
+
+            if choice is None:
+                return "q"
+
+            # Map natural language choices back to original key-based system
+            # for backward compatibility
+            choice_map = {
+                "Agent Management": "1",
+                "Skills Management": "2",
+                "Template Editing": "3",
+                "Behavior Files": "4",
+                "Startup Configuration": "5",
+                f"Switch Scope (Current: {self.current_scope})": "6",
+                "Version Info": "7",
+                "Save & Launch Claude MPM": "l",
+                "Quit": "q",
+            }
+
+            return choice_map.get(choice, "q")
+
+        except KeyboardInterrupt:
+            return "q"
 
     def switch_scope(self) -> None:
         """Switch between project and user scope.

claude_mpm/cli/commands/debug.py

@@ -693,9 +693,9 @@ def debug_hooks(args, logger):
                     max_time = max(times)
 
                     print(f"\n   {hook.name}:")
-                    print(f"     Average: {avg_time*1000:.2f}ms")
-                    print(f"     Min: {min_time*1000:.2f}ms")
-                    print(f"     Max: {max_time*1000:.2f}ms")
+                    print(f"     Average: {avg_time * 1000:.2f}ms")
+                    print(f"     Min: {min_time * 1000:.2f}ms")
+                    print(f"     Max: {max_time * 1000:.2f}ms")
 
         else:
             # Default: show summary
@@ -767,7 +767,7 @@ def debug_cache(args, logger):
             print(f"   Location: {cache_dir}")
             print(f"   Total Files: {file_count}")
             print(
-                f"   Total Size: {total_size:,} bytes ({total_size/1024/1024:.2f} MB)"
+                f"   Total Size: {total_size:,} bytes ({total_size / 1024 / 1024:.2f} MB)"
             )
 
             print("\n📁 Categories:")
@@ -871,7 +871,7 @@ def debug_cache(args, logger):
 
                 print(f"Location: {cache_dir}")
                 print(f"Files: {file_count}")
-                print(f"Size: {total_size:,} bytes ({total_size/1024/1024:.2f} MB)")
+                print(f"Size: {total_size:,} bytes ({total_size / 1024 / 1024:.2f} MB)")
             else:
                 print("No cache found")
 
@@ -998,22 +998,22 @@ def debug_performance(args, logger):
             # Memory info
             mem = psutil.virtual_memory()
             print("\n💾 Memory:")
-            print(f"   Total: {mem.total/1024/1024/1024:.2f} GB")
-            print(f"   Used: {mem.used/1024/1024/1024:.2f} GB ({mem.percent}%)")
-            print(f"   Available: {mem.available/1024/1024/1024:.2f} GB")
+            print(f"   Total: {mem.total / 1024 / 1024 / 1024:.2f} GB")
+            print(f"   Used: {mem.used / 1024 / 1024 / 1024:.2f} GB ({mem.percent}%)")
+            print(f"   Available: {mem.available / 1024 / 1024 / 1024:.2f} GB")
 
             # Disk info
             disk = psutil.disk_usage("/")
             print("\n💿 Disk:")
-            print(f"   Total: {disk.total/1024/1024/1024:.2f} GB")
-            print(f"   Used: {disk.used/1024/1024/1024:.2f} GB ({disk.percent}%)")
-            print(f"   Free: {disk.free/1024/1024/1024:.2f} GB")
+            print(f"   Total: {disk.total / 1024 / 1024 / 1024:.2f} GB")
+            print(f"   Used: {disk.used / 1024 / 1024 / 1024:.2f} GB ({disk.percent}%)")
+            print(f"   Free: {disk.free / 1024 / 1024 / 1024:.2f} GB")
 
             # Process info
             process = psutil.Process()
             print("\n📦 Current Process:")
             print(f"   PID: {process.pid}")
-            print(f"   Memory: {process.memory_info().rss/1024/1024:.2f} MB")
+            print(f"   Memory: {process.memory_info().rss / 1024 / 1024:.2f} MB")
             print(f"   CPU: {process.cpu_percent()}%")
             print(f"   Threads: {process.num_threads()}")
 

claude_mpm/cli/commands/doctor.py

@@ -60,6 +60,7 @@ def add_doctor_parser(subparsers):
             "filesystem",
             "claude",
             "agents",
+            "agent-sources",
             "mcp",
             "monitor",
             "common",
@@ -116,6 +117,8 @@ def doctor_command(args):
         Exit code (0 for success, 1 for warnings, 2 for errors)
     """
     # Configure logging
+    from datetime import datetime, timezone
+
     from claude_mpm.core.logging_utils import get_logger
 
     logger = get_logger(__name__)
@@ -123,13 +126,18 @@ def doctor_command(args):
     # Handle output file parameter - support both --output and --output-file
     output_file = args.output or args.output_file
     if output_file is not None:
-        # If output_file is specified without a path, use default
+        # If output_file is specified without a path, use default with timestamp
         if str(output_file) == ".":
-            output_file = Path("mpm-doctor-report.md")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+            output_file = Path(f"mpm-doctor-report-{timestamp}.md")
         elif not str(output_file).endswith((".md", ".json", ".txt")):
             # Add .md extension if no extension provided
             output_file = Path(str(output_file) + ".md")
 
+        # Create parent directories if needed
+        output_file = output_file.absolute()
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
     # Determine output format
     if args.json:
         output_format = "json"

claude_mpm/cli/commands/hook_errors.py

@@ -0,0 +1,277 @@
+"""CLI commands for managing hook error memory.
+
+WHY this command is needed:
+- Users need visibility into what hooks are failing
+- Must be able to clear error memory to retry failed hooks
+- Provides diagnostics for troubleshooting
+- Makes error memory accessible without manual file editing
+"""
+
+import json
+from pathlib import Path
+
+import click
+
+from claude_mpm.core.hook_error_memory import get_hook_error_memory
+
+
+@click.group(name="hook-errors")
+def hook_errors_group():
+    """Manage hook error memory and diagnostics.
+
+    The hook error memory system tracks failing hooks to prevent
+    repeated execution of known-failing operations.
+    """
+
+
+@hook_errors_group.command(name="list")
+@click.option(
+    "--format",
+    type=click.Choice(["table", "json"], case_sensitive=False),
+    default="table",
+    help="Output format (table or json)",
+)
+@click.option(
+    "--hook-type",
+    help="Filter by hook type (e.g., PreToolUse, PostToolUse)",
+)
+def list_errors(format, hook_type):
+    """List all recorded hook errors.
+
+    Shows errors that have been detected during hook execution,
+    including failure counts and last seen timestamps.
+
+    Examples:
+        claude-mpm hook-errors list
+        claude-mpm hook-errors list --format json
+        claude-mpm hook-errors list --hook-type PreToolUse
+    """
+    error_memory = get_hook_error_memory()
+
+    # Filter errors if hook type specified
+    errors = error_memory.errors
+    if hook_type:
+        errors = {
+            key: data for key, data in errors.items() if data["hook_type"] == hook_type
+        }
+
+    if not errors:
+        if hook_type:
+            click.echo(f"No errors recorded for hook type: {hook_type}")
+        else:
+            click.echo("No errors recorded. Hook system is healthy! ✅")
+        return
+
+    if format == "json":
+        # JSON output
+        click.echo(json.dumps(errors, indent=2))
+    else:
+        # Table output
+        click.echo("\n" + "=" * 80)
+        click.echo("Hook Error Memory Report")
+        click.echo("=" * 80)
+
+        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("\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")
+
+
+@hook_errors_group.command(name="summary")
+def show_summary():
+    """Show summary statistics of hook errors.
+
+    Provides overview of error counts by type and hook type.
+
+    Example:
+        claude-mpm hook-errors summary
+    """
+    error_memory = get_hook_error_memory()
+    summary = error_memory.get_error_summary()
+
+    if summary["total_errors"] == 0:
+        click.echo("No errors recorded. Hook system is healthy! ✅")
+        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']}")
+
+    if summary["errors_by_type"]:
+        click.echo("\n🔍 Errors by Type:")
+        for error_type, count in summary["errors_by_type"].items():
+            click.echo(f"   {error_type}: {count}")
+
+    if summary["errors_by_hook"]:
+        click.echo("\n🎣 Errors by Hook Type:")
+        for hook_type, count in summary["errors_by_hook"].items():
+            click.echo(f"   {hook_type}: {count}")
+
+    click.echo(f"\n📁 Memory File: {summary['memory_file']}")
+    click.echo("\nFor detailed list: claude-mpm hook-errors list")
+
+
+@hook_errors_group.command(name="clear")
+@click.option(
+    "--hook-type",
+    help="Clear errors only for specific hook type",
+)
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    help="Skip confirmation prompt",
+)
+def clear_errors(hook_type, yes):
+    """Clear hook error memory to allow retry.
+
+    This removes error records, allowing previously failing hooks
+    to be executed again. Use this after fixing the underlying issue.
+
+    Examples:
+        claude-mpm hook-errors clear
+        claude-mpm hook-errors clear --hook-type PreToolUse
+        claude-mpm hook-errors clear -y  # Skip confirmation
+    """
+    error_memory = get_hook_error_memory()
+
+    # Count errors to be cleared
+    if hook_type:
+        count = sum(
+            1 for data in error_memory.errors.values() if data["hook_type"] == hook_type
+        )
+        scope = f"for hook type '{hook_type}'"
+    else:
+        count = len(error_memory.errors)
+        scope = "all hook types"
+
+    if count == 0:
+        click.echo(f"No errors to clear {scope}.")
+        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.")
+            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.")
+
+
+@hook_errors_group.command(name="diagnose")
+@click.argument("hook_type", required=False)
+def diagnose_errors(hook_type):
+    """Diagnose hook errors and suggest fixes.
+
+    Provides detailed diagnostics and actionable suggestions for
+    resolving hook errors.
+
+    Arguments:
+        HOOK_TYPE: Optional hook type to diagnose (e.g., PreToolUse)
+
+    Examples:
+        claude-mpm hook-errors diagnose
+        claude-mpm hook-errors diagnose PreToolUse
+    """
+    error_memory = get_hook_error_memory()
+
+    # Filter errors if hook type specified
+    errors = error_memory.errors
+    if hook_type:
+        errors = {
+            key: data for key, data in errors.items() if data["hook_type"] == hook_type
+        }
+
+    if not errors:
+        if hook_type:
+            click.echo(f"No errors to diagnose for hook type: {hook_type}")
+        else:
+            click.echo("No errors to diagnose. Hook system is healthy! ✅")
+        return
+
+    click.echo("\n" + "=" * 80)
+    click.echo("Hook Error Diagnostics")
+    click.echo("=" * 80)
+
+    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")
+
+        # Generate and show fix suggestion
+        error_info = {
+            "type": data["type"],
+            "details": data["details"],
+            "match": data["match"],
+        }
+        suggestion = error_memory.suggest_fix(error_info)
+
+        click.echo("\n" + "-" * 80)
+        click.echo(suggestion)
+        click.echo("-" * 80)
+
+    click.echo("\n" + "=" * 80)
+    click.echo("After fixing issues, clear errors to retry:")
+    click.echo("  claude-mpm hook-errors clear")
+
+
+@hook_errors_group.command(name="status")
+def show_status():
+    """Show hook error memory status.
+
+    Quick overview of hook error system state.
+
+    Example:
+        claude-mpm hook-errors status
+    """
+    error_memory = get_hook_error_memory()
+    summary = error_memory.get_error_summary()
+
+    click.echo("\n📊 Hook Error Memory Status")
+    click.echo("=" * 80)
+
+    if summary["total_errors"] == 0:
+        click.echo("✅ Status: Healthy (no errors recorded)")
+    else:
+        click.echo(f"⚠️  Status: {summary['total_errors']} error(s) recorded")
+        click.echo(f"   Unique errors: {summary['unique_errors']}")
+
+        # 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"\n📁 Memory file: {summary['memory_file']}")
+    click.echo(f"   Exists: {Path(summary['memory_file']).exists()}")
+
+    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")
+
+
+# Register the command group
+def register_commands(cli):
+    """Register hook error commands with CLI.
+
+    Args:
+        cli: Click CLI group to register commands with
+    """
+    cli.add_command(hook_errors_group)

claude_mpm/cli/commands/local_deploy.py

@@ -25,10 +25,7 @@ from rich.text import Text
 
 from claude_mpm.core.enums import ServiceState
 
-from ...services.local_ops import (
-    StartConfig,
-    UnifiedLocalOpsManager,
-)
+from ...services.local_ops import StartConfig, UnifiedLocalOpsManager
 from ..shared import BaseCommand, CommandResult
 
 

claude_mpm/cli/commands/mcp_install_commands.py

@@ -295,7 +295,7 @@ class MCPInstallCommands:
 
                     # Create backup
                     backup_path = config_path.with_suffix(
-                        f'.backup.{datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")}.json'
+                        f".backup.{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
                     )
                     try:
                         config_path.rename(backup_path)

claude_mpm/cli/commands/mpm_init/__init__.py

@@ -0,0 +1,73 @@
+"""MPM initialization command package.
+
+This package provides comprehensive project initialization and update capabilities
+for Claude Code and Claude MPM. It includes:
+
+- Core command class (MPMInitCommand) for orchestrating initialization
+- Click CLI commands for command-line interface
+- Modular components for prompts, display, git analysis, and modes
+- Support for multiple initialization modes (create, update, review, quick-update, catchup)
+
+Main Components:
+- core.py: MPMInitCommand class - main initialization orchestrator
+- mpm_init_cli.py: Click command definitions and CLI entry points
+- prompts.py: Prompt building functions for agent delegation
+- display.py: Display and UI helper functions
+- git_activity.py: Git history analysis and context building
+- modes.py: Mode-specific handlers (review, dry-run, quick-update, etc.)
+
+Public API:
+- MPMInitCommand: Main command class (from core)
+- mpm_init: Click command group (from mpm_init_cli)
+
+Example Usage:
+    # Programmatic usage
+    from claude_mpm.cli.commands.mpm_init import MPMInitCommand
+    command = MPMInitCommand(project_path)
+    result = command.initialize_project()
+
+    # CLI usage (via Click)
+    from claude_mpm.cli.commands.mpm_init import mpm_init
+    # Command is registered with Click and invoked via CLI
+"""
+
+# Import core components for re-export
+from .core import MPMInitCommand
+
+# Import the Click command group - this must be imported from parent level
+# to avoid circular dependencies, as mpm_init_cli imports from core
+# We'll handle this via late import in __all__
+
+__all__ = [
+    # Main command class
+    "MPMInitCommand",
+    "core",
+    # Internal modules (for internal package use)
+    "display",
+    "git_activity",
+    "modes",
+    # Click CLI command (imported via __getattr__ to avoid circular import)
+    "mpm_init",
+    "prompts",
+]
+
+
+def __getattr__(name):
+    """Lazy import to avoid circular dependencies.
+
+    This allows importing mpm_init Click command without importing
+    mpm_init_cli at module load time, which would cause circular imports.
+    """
+    if name == "mpm_init":
+        # Lazy import the Click command group
+        from ..mpm_init_cli import mpm_init as _mpm_init
+
+        return _mpm_init
+
+    # For internal module imports, import them directly
+    if name in ("display", "git_activity", "prompts", "modes", "core"):
+        import importlib
+
+        return importlib.import_module(f".{name}", __package__)
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")