claude-mpm 4.21.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

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

@@ -155,6 +155,10 @@ class MPMInitCommand:
                 if pre_check_result.get("status") == OperationResult.ERROR:
                     return pre_check_result
 
+            # Update .gitignore to exclude claude-mpm configuration directories
+            if not review_only and not dry_run:
+                self._update_gitignore()
+
             # Build the delegation prompt
             if update_mode:
                 prompt = self._build_update_prompt(
@@ -317,7 +321,9 @@ class MPMInitCommand:
             error_msg = (
                 result.stderr
                 if result.stderr
-                else result.stdout if result.stdout else "Unknown error occurred"
+                else result.stdout
+                if result.stdout
+                else "Unknown error occurred"
             )
 
             logger.error(f"claude-mpm run failed: {error_msg}")
@@ -344,7 +350,7 @@ class MPMInitCommand:
         warnings = []
 
         # Run comprehensive project readiness check
-        ready, actions = self.organizer.ensure_project_ready(
+        _ready, actions = self.organizer.ensure_project_ready(
             auto_organize=organize_files,
             safe_mode=True,  # Only perform safe operations by default
         )
@@ -393,6 +399,48 @@ class MPMInitCommand:
             "warnings": warnings,
         }
 
+    def _update_gitignore(self) -> None:
+        """Update .gitignore to exclude claude-mpm configuration directories.
+
+        Ensures that claude-mpm configuration directories are added to .gitignore
+        to prevent them from being committed to version control.
+
+        This is a non-destructive operation that:
+        - Creates .gitignore if it doesn't exist
+        - Appends missing entries only (never duplicates)
+        - Preserves all existing content
+
+        Standard entries added:
+        - .claude-mpm/: Main configuration directory
+        - .claude/agents/: Agent runtime files
+        """
+        from claude_mpm.utils.gitignore import ensure_claude_mpm_gitignore
+
+        try:
+            result = ensure_claude_mpm_gitignore(str(self.project_path))
+
+            if result.get("status") == "success":
+                if result.get("added"):
+                    self.console.print(
+                        f"[green]✓[/green] Updated .gitignore: {', '.join(result['added'])}"
+                    )
+                    logger.info(f"Added to .gitignore: {result['added']}")
+                elif result.get("existing"):
+                    logger.debug(f".gitignore already contains: {result['existing']}")
+            else:
+                # Non-critical error - log but don't fail initialization
+                logger.warning(
+                    f"Could not update .gitignore: {result.get('error', 'Unknown error')}"
+                )
+                self.console.print(
+                    f"[yellow]⚠️  Could not update .gitignore: {result.get('error')}[/yellow]"
+                )
+
+        except Exception as e:
+            # Non-critical error - log but don't fail initialization
+            logger.warning(f"Error updating .gitignore: {e}")
+            self.console.print(f"[yellow]⚠️  Could not update .gitignore: {e}[/yellow]")
+
     def _build_initialization_prompt(
         self,
         project_type: Optional[str] = None,

claude_mpm/cli/commands/mpm_init/git_activity.py

@@ -218,14 +218,14 @@ def export_activity_report(project_path: Path, report: Dict, export_path: str) -
     content = f"""# Activity Report
 
 **Generated**: {timestamp}
-**Analysis Period**: {report.get('period', 'Last 30 days')}
+**Analysis Period**: {report.get("period", "Last 30 days")}
 
 ## Summary
 
-- **Total Commits**: {summary.get('total_commits', 0)}
-- **Active Contributors**: {summary.get('total_authors', 0)}
-- **Files Modified**: {summary.get('files_changed', 0)}
-- **Current Branch**: {summary.get('current_branch', 'unknown')}
+- **Total Commits**: {summary.get("total_commits", 0)}
+- **Active Contributors**: {summary.get("total_authors", 0)}
+- **Files Modified**: {summary.get("files_changed", 0)}
+- **Current Branch**: {summary.get("current_branch", "unknown")}
 """
 
     if summary.get("has_uncommitted"):
@@ -301,13 +301,13 @@ def append_activity_notes(claude_md_path: Path, report: Dict) -> None:
 ## 📈 Recent Activity Summary
 
 **Last Updated**: {timestamp}
-**Analysis Period**: {report.get('period', 'Last 30 days')}
+**Analysis Period**: {report.get("period", "Last 30 days")}
 
 ### Activity Metrics
-- **Commits**: {summary.get('total_commits', 0)}
-- **Contributors**: {summary.get('total_authors', 0)}
-- **Files Changed**: {summary.get('files_changed', 0)}
-- **Current Branch**: {summary.get('current_branch', 'unknown')}
+- **Commits**: {summary.get("total_commits", 0)}
+- **Contributors**: {summary.get("total_authors", 0)}
+- **Files Changed**: {summary.get("files_changed", 0)}
+- **Current Branch**: {summary.get("current_branch", "unknown")}
 """
 
     if summary.get("has_uncommitted"):