claude-mpm 4.25.10__py3-none-any.whl → 5.1.8__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/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/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/postmortem.py

@@ -0,0 +1,401 @@
+"""
+Postmortem command implementation for claude-mpm.
+
+WHY: Provide a comprehensive analysis tool to help users identify, categorize,
+and fix errors encountered during their session, with automated improvements
+for framework code and suggestions for user code.
+
+DESIGN DECISIONS:
+- Leverages existing FailureTracker for error data
+- Categorizes errors by source (script/skill/agent/user)
+- Provides action-specific handling (auto-fix/update/PR/suggest)
+- Supports dry-run mode for safety
+"""
+
+import sys
+from pathlib import Path
+
+from claude_mpm.core.logging_utils import get_logger
+from claude_mpm.services.analysis import get_postmortem_service
+from claude_mpm.services.analysis.postmortem_reporter import PostmortemReporter
+
+logger = get_logger(__name__)
+
+
+def add_postmortem_parser(subparsers):
+    """Add postmortem command parser.
+
+    WHY: This command helps users analyze session errors and generate
+    actionable improvement suggestions based on error source.
+    """
+    parser = subparsers.add_parser(
+        "postmortem",
+        aliases=["pm-analysis"],
+        help="Analyze session errors and suggest improvements",
+        description="Perform comprehensive analysis of errors encountered during the session",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview analysis without making changes (default for destructive operations)",
+    )
+
+    parser.add_argument(
+        "--auto-fix",
+        action="store_true",
+        help="Automatically apply fixes to scripts and skills",
+    )
+
+    parser.add_argument(
+        "--create-prs",
+        action="store_true",
+        help="Create pull requests for agent improvements",
+    )
+
+    parser.add_argument(
+        "--session-id",
+        type=str,
+        help="Analyze specific session (default: current session)",
+    )
+
+    parser.add_argument(
+        "--format",
+        choices=["terminal", "json", "markdown"],
+        default="terminal",
+        help="Output format (default: terminal)",
+    )
+
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        help="Save report to file",
+    )
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Include detailed error traces and analysis",
+    )
+
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="Disable colored output",
+    )
+
+    parser.set_defaults(func=postmortem_command)
+
+
+def run_postmortem(args):
+    """Main entry point for postmortem command (used by CLI).
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for warnings, 2 for errors)
+    """
+    return postmortem_command(args)
+
+
+def postmortem_command(args):
+    """Execute the postmortem command.
+
+    WHY: Provides comprehensive error analysis with categorization and
+    actionable improvements, helping users understand and fix issues
+    encountered during their session.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, 1 for warnings, 2 for errors)
+    """
+    logger.info("Starting postmortem analysis")
+
+    # Get postmortem service
+    service = get_postmortem_service()
+
+    try:
+        # Analyze session
+        report = service.analyze_session(session_id=args.session_id)
+
+        # Handle output file
+        output_file = args.output
+        if output_file:
+            # Ensure file extension matches format
+            if args.format == "json" and not str(output_file).endswith(".json"):
+                output_file = Path(str(output_file) + ".json")
+            elif args.format == "markdown" and not str(output_file).endswith(".md"):
+                output_file = Path(str(output_file) + ".md")
+
+            # Create parent directories
+            output_file = output_file.absolute()
+            output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Determine output format
+        output_format = args.format
+
+        # Create reporter
+        reporter = PostmortemReporter(
+            use_color=not args.no_color,
+            verbose=args.verbose,
+        )
+
+        # Output results
+        if output_file:
+            # Save to file
+            try:
+                with output_file.open("w") as f:
+                    original_output = reporter.output
+                    reporter.output = f
+                    reporter.report(report, format=output_format)
+                    reporter.output = original_output
+
+                print(f"✅ Report saved to: {output_file}")
+
+                # Print brief summary to terminal
+                if report.total_errors > 0:
+                    print(f"\n{report.total_errors} error(s) analyzed")
+                    print(
+                        f"{report.stats['total_actions']} improvement action(s) generated"
+                    )
+                else:
+                    print("\n✅ No errors detected in session!")
+
+            except Exception as e:
+                logger.error(f"Failed to save report: {e}")
+                print(f"❌ Failed to save report: {e!s}")
+                # Still output to terminal
+                reporter.report(report, format="terminal")
+        else:
+            # Output to terminal
+            reporter.report(report, format=output_format)
+
+        # Apply fixes if requested
+        if args.auto_fix and not args.dry_run:
+            exit_code = _apply_auto_fixes(report, args.verbose)
+            if exit_code != 0:
+                return exit_code
+
+        # Create PRs if requested
+        if args.create_prs and not args.dry_run:
+            exit_code = _create_prs(report, args.verbose)
+            if exit_code != 0:
+                return exit_code
+
+        # Dry-run message
+        if args.dry_run and (args.auto_fix or args.create_prs):
+            print("\n🔍 Dry-run mode: No changes applied")
+            print("   Remove --dry-run to apply changes")
+
+        # Determine exit code
+        if report.total_errors == 0:
+            return 0  # No errors
+
+        if report.stats.get("critical_priority", 0) > 0:
+            return 2  # Critical errors found
+
+        return 1  # Non-critical errors found
+
+    except KeyboardInterrupt:
+        print("\nPostmortem analysis interrupted by user")
+        return 130
+
+    except Exception as e:
+        logger.error(f"Postmortem analysis failed: {e}", exc_info=True)
+        print(f"\n❌ Postmortem analysis failed: {e!s}")
+        if args.verbose:
+            import traceback
+
+            traceback.print_exc()
+        return 2
+
+
+def _apply_auto_fixes(report, verbose: bool) -> int:
+    """Apply auto-fix actions from report.
+
+    Args:
+        report: Postmortem report
+        verbose: Show detailed output
+
+    Returns:
+        Exit code (0 for success, non-zero for errors)
+    """
+    from claude_mpm.services.analysis import ActionType
+
+    auto_fix_actions = report.get_actions_by_type(ActionType.AUTO_FIX)
+
+    if not auto_fix_actions:
+        print("\n✅ No auto-fixable errors found")
+        return 0
+
+    print(f"\n🔧 Applying {len(auto_fix_actions)} auto-fix action(s)...")
+
+    import subprocess
+
+    success_count = 0
+    fail_count = 0
+
+    for i, action in enumerate(auto_fix_actions, 1):
+        print(f"\n[{i}/{len(auto_fix_actions)}] {action.description}")
+
+        # Run each command
+        for cmd in action.commands:
+            if verbose:
+                print(f"  Running: {cmd}")
+
+            try:
+                result = subprocess.run(
+                    cmd,
+                    check=False,
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                )
+
+                if result.returncode == 0:
+                    action.status = "completed"
+                    if verbose:
+                        print(f"  ✅ Success: {cmd}")
+                else:
+                    action.status = "failed"
+                    action.error_message = result.stderr or result.stdout
+                    print(f"  ❌ Failed: {cmd}")
+                    if verbose and result.stderr:
+                        print(f"     {result.stderr}")
+                    fail_count += 1
+                    break  # Stop on first failure for this action
+
+            except subprocess.TimeoutExpired:
+                action.status = "failed"
+                action.error_message = "Command timed out"
+                print(f"  ❌ Timeout: {cmd}")
+                fail_count += 1
+                break
+
+            except Exception as e:
+                action.status = "failed"
+                action.error_message = str(e)
+                print(f"  ❌ Error: {e}")
+                fail_count += 1
+                break
+
+        if action.status == "completed":
+            success_count += 1
+
+    # Summary
+    print("\n📊 Auto-fix Results:")
+    print(f"  ✅ Successful: {success_count}")
+    print(f"  ❌ Failed: {fail_count}")
+
+    return 0 if fail_count == 0 else 1
+
+
+def _create_prs(report, verbose: bool) -> int:
+    """Create PRs for agent improvements.
+
+    Args:
+        report: Postmortem report
+        verbose: Show detailed output
+
+    Returns:
+        Exit code (0 for success, non-zero for errors)
+    """
+    from claude_mpm.services.analysis import ActionType
+
+    pr_actions = report.get_actions_by_type(ActionType.CREATE_PR)
+
+    if not pr_actions:
+        print("\n✅ No PR actions needed")
+        return 0
+
+    print(f"\n🤖 Creating {len(pr_actions)} PR(s) for agent improvements...")
+
+    # Check if we're in the agent cache git repo
+    agent_cache_path = Path.home() / ".claude-mpm" / "cache" / "remote-agents"
+
+    if not agent_cache_path.exists():
+        print(f"❌ Agent cache not found at: {agent_cache_path}")
+        print("   Run 'claude-mpm agents sync' first")
+        return 2
+
+    success_count = 0
+    fail_count = 0
+
+    for i, action in enumerate(pr_actions, 1):
+        print(f"\n[{i}/{len(pr_actions)}] {action.description}")
+
+        try:
+            # Check if file is in agent cache
+            analysis = action.error_analysis
+            if not analysis.affected_file:
+                print("  ⚠️  Cannot determine affected file, skipping")
+                action.status = "failed"
+                action.error_message = "No affected file identified"
+                fail_count += 1
+                continue
+
+            # For MVP, print PR template instead of actually creating
+            # Full implementation would use GitHub CLI or API
+            print("  📝 PR Template Generated:")
+            print(f"     Branch: {action.pr_branch}")
+            print(f"     Title: {action.pr_title}")
+
+            if verbose:
+                print("\n--- PR Body ---")
+                print(action.pr_body)
+                print("--- End PR Body ---\n")
+
+            print("\n  ℹ️  To create PR manually:")
+            print(f"     cd {agent_cache_path}")
+            print(f"     git checkout -b {action.pr_branch}")
+            print(f"     # Make your changes to {analysis.affected_file}")
+            print(f"     git add {analysis.affected_file}")
+            print(f'     git commit -m "{action.pr_title}"')
+            print(f"     git push origin {action.pr_branch}")
+            print(
+                f'     gh pr create --title "{action.pr_title}" --body-file pr_body.md'
+            )
+
+            action.status = "completed"
+            success_count += 1
+
+        except Exception as e:
+            logger.error(f"Failed to create PR: {e}")
+            print(f"  ❌ Error: {e}")
+            action.status = "failed"
+            action.error_message = str(e)
+            fail_count += 1
+
+    # Summary
+    print("\n📊 PR Creation Results:")
+    print(f"  ✅ Templates generated: {success_count}")
+    print(f"  ❌ Failed: {fail_count}")
+
+    return 0 if fail_count == 0 else 1
+
+
+# Optional: Standalone execution for testing
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Claude MPM Postmortem Analysis")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--auto-fix", action="store_true")
+    parser.add_argument("--create-prs", action="store_true")
+    parser.add_argument("--session-id", type=str)
+    parser.add_argument(
+        "--format", choices=["terminal", "json", "markdown"], default="terminal"
+    )
+    parser.add_argument("--output", "-o", type=Path)
+    parser.add_argument("--verbose", "-v", action="store_true")
+    parser.add_argument("--no-color", action="store_true")
+
+    args = parser.parse_args()
+
+    sys.exit(postmortem_command(args))

claude_mpm/cli/commands/run.py

@@ -569,41 +569,6 @@ class RunCommand(BaseCommand):
             return False
 
 
-def _ensure_mcp_services_configured(logger):
-    """
-    Ensure MCP services are configured in .mcp.json on startup.
-
-    This function automatically configures the core MCP services
-    (mcp-vector-search, mcp-browser, mcp-ticketer) if they're not
-    already configured in the project's .mcp.json file.
-
-    Args:
-        logger: Logger instance for output
-    """
-    try:
-        from ...services.mcp_config_manager import MCPConfigManager
-
-        logger.debug("Checking MCP service configuration...")
-        manager = MCPConfigManager()
-
-        # Check and auto-configure missing MCP services
-        success, message = manager.ensure_mcp_services_configured()
-
-        if success:
-            if "already configured" not in message.lower():
-                logger.info(message)
-                print(f"✅ {message}")
-            else:
-                logger.debug(message)
-        else:
-            logger.warning(f"MCP auto-configuration issue: {message}")
-            # Don't fail the session, just warn
-
-    except Exception as e:
-        logger.debug(f"MCP auto-configuration skipped: {e}")
-        # Don't fail the session if auto-configuration fails
-
-
 def _handle_reload_agents(logger):
     """
     Handle the --reload-agents flag by deleting all local claude-mpm system agents.
@@ -738,10 +703,7 @@ def run_session_legacy(args):
     if getattr(args, "reload_agents", False):
         _handle_reload_agents(logger)
 
-    # Auto-configure MCP services on startup
-    _ensure_mcp_services_configured(logger)
-
-    # Trigger vector search indexing after MCP is configured
+    # Trigger vector search indexing
     try:
         from ...cli.startup_logging import start_vector_search_indexing