claude-mpm 4.1.1__py3-none-any.whl → 4.1.3__py3-none-any.whl

claude_mpm/scripts/mcp_server.py

@@ -5,14 +5,17 @@ This script launches the MCP gateway server for Claude Code integration.
 It handles proper Python path setup and error reporting to stderr.
 """
 
-import sys
-import os
 import logging
+import os
+import sys
 
 # Since we're now in src/claude_mpm/scripts/, we need to go up 3 levels to reach the project root
 # Then down into src to add it to the path
-project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
-sys.path.insert(0, os.path.join(project_root, 'src'))
+project_root = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), "..", "..", "..")
+)
+sys.path.insert(0, os.path.join(project_root, "src"))
+
 
 def setup_logging():
     """Configure logging to stderr to avoid interfering with stdio protocol."""
@@ -22,25 +25,29 @@ def setup_logging():
         stream=sys.stderr,
     )
 
+
 def main():
     """Main entry point for the MCP server launcher."""
     try:
         # Setup logging first
         setup_logging()
         logger = logging.getLogger("MCPLauncher")
-        
+
         # Import modules after path setup
         try:
-            from claude_mpm.services.mcp_gateway.server.stdio_server import SimpleMCPServer
             import asyncio
+
+            from claude_mpm.services.mcp_gateway.server.stdio_server import (
+                SimpleMCPServer,
+            )
         except ImportError as e:
             logger.error(f"Failed to import required modules: {e}")
             logger.error("Make sure claude-mpm is properly installed")
             sys.exit(1)
-        
+
         # Create and run server
         logger.info("Starting MCP Gateway Server...")
-        
+
         async def run_server():
             """Async function to run the server."""
             try:
@@ -49,10 +56,10 @@ def main():
             except Exception as e:
                 logger.error(f"Server runtime error: {e}")
                 raise
-        
+
         # Run the async server
         asyncio.run(run_server())
-        
+
     except KeyboardInterrupt:
         # Clean shutdown on Ctrl+C
         logger.info("Server shutdown requested")
@@ -61,8 +68,10 @@ def main():
         # Log any unexpected errors
         logger.error(f"Unexpected error: {e}")
         import traceback
+
         traceback.print_exc(file=sys.stderr)
         sys.exit(1)
 
+
 if __name__ == "__main__":
-    main()
+    main()

claude_mpm/scripts/mcp_wrapper.py

@@ -10,7 +10,6 @@ for the pyproject.toml scripts configuration.
 """
 
 import sys
-import os
 from pathlib import Path
 
 
@@ -20,20 +19,21 @@ def entry_point():
     current_file = Path(__file__).resolve()
     project_root = current_file.parent.parent.parent.parent
     wrapper_script = project_root / "scripts" / "mcp_wrapper.py"
-    
+
     if not wrapper_script.exists():
         print(f"Error: Wrapper script not found at {wrapper_script}", file=sys.stderr)
         sys.exit(1)
-    
+
     # Add the scripts directory to path and import the wrapper
     scripts_dir = str(wrapper_script.parent)
     if scripts_dir not in sys.path:
         sys.path.insert(0, scripts_dir)
-    
+
     # Import and run the wrapper
     import mcp_wrapper
+
     mcp_wrapper.main()
 
 
 if __name__ == "__main__":
-    entry_point()
+    entry_point()

claude_mpm/scripts/mpm_doctor.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""
+MPM Doctor operational script.
+
+WHY: This script provides the core functionality for the /mpm-doctor slash command.
+All operational logic is contained here, while the CLI integration remains in the
+command parser and interactive session handler.
+
+DESIGN DECISIONS:
+- Centralized diagnostic execution
+- Support for multiple output formats
+- Configurable check selection
+- Lightweight wrapper around DiagnosticRunner
+"""
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..services.diagnostics import DiagnosticRunner, DoctorReporter
+
+
+def run_diagnostics(
+    verbose: bool = False,
+    fix: bool = False,
+    checks: Optional[List[str]] = None,
+    parallel: bool = False,
+    output_format: str = "terminal",
+    no_color: bool = False,
+) -> Dict[str, Any]:
+    """
+    Execute MPM diagnostics with the specified configuration.
+
+    WHY: Provides a single entry point for all diagnostic operations,
+    whether called from CLI, interactive mode, or programmatically.
+
+    Args:
+        verbose: Show detailed diagnostic information
+        fix: Attempt to fix issues automatically
+        checks: List of specific checks to run (None for all)
+        parallel: Run checks in parallel for faster execution
+        output_format: Output format ("terminal", "json", "markdown")
+        no_color: Disable colored output
+
+    Returns:
+        Dictionary containing:
+        - success: bool - whether diagnostics completed successfully
+        - summary: DiagnosticSummary object
+        - error_count: int - number of errors found
+        - warning_count: int - number of warnings found
+        - message: str - optional error message if failed
+    """
+    logger = logging.getLogger(__name__)
+
+    # Create diagnostic runner
+    runner = DiagnosticRunner(verbose=verbose, fix=fix)
+
+    # Run diagnostics
+    try:
+        if checks:
+            logger.info(f"Running specific checks: {', '.join(checks)}")
+            summary = runner.run_specific_checks(checks)
+        elif parallel:
+            logger.info("Running diagnostics in parallel mode")
+            summary = runner.run_diagnostics_parallel()
+        else:
+            logger.info("Running comprehensive diagnostics")
+            summary = runner.run_diagnostics()
+
+    except KeyboardInterrupt:
+        return {
+            "success": False,
+            "summary": None,
+            "error_count": 0,
+            "warning_count": 0,
+            "message": "Diagnostics interrupted by user",
+        }
+    except Exception as e:
+        logger.error(f"Diagnostic failed: {e}")
+        return {
+            "success": False,
+            "summary": None,
+            "error_count": 1,
+            "warning_count": 0,
+            "message": f"Diagnostic failed: {e!s}",
+        }
+
+    # Return success with summary
+    return {
+        "success": True,
+        "summary": summary,
+        "error_count": summary.error_count,
+        "warning_count": summary.warning_count,
+        "message": None,
+    }
+
+
+def format_output(
+    summary,
+    output_format: str = "terminal",
+    verbose: bool = False,
+    no_color: bool = False,
+) -> str:
+    """
+    Format diagnostic summary for output.
+
+    Args:
+        summary: DiagnosticSummary object
+        output_format: Output format ("terminal", "json", "markdown")
+        verbose: Show detailed information
+        no_color: Disable colored output
+
+    Returns:
+        Formatted output string
+    """
+    # Create reporter
+    reporter = DoctorReporter(use_color=not no_color, verbose=verbose)
+
+    # Capture output as string for non-terminal formats
+    if output_format != "terminal":
+        import io
+        import sys
+
+        # Capture stdout
+        old_stdout = sys.stdout
+        sys.stdout = buffer = io.StringIO()
+
+        try:
+            reporter.report(summary, format=output_format)
+            output = buffer.getvalue()
+        finally:
+            sys.stdout = old_stdout
+
+        return output
+    # For terminal format, just report directly
+    reporter.report(summary, format=output_format)
+    return ""
+
+
+def run_doctor_slash_command(args: List[str]) -> bool:
+    """
+    Execute the /mpm-doctor slash command.
+
+    WHY: Provides a simplified interface for the interactive mode slash command,
+    parsing basic arguments and returning a simple success/failure result.
+
+    Args:
+        args: Command arguments (e.g., ['--verbose', '--no-color'])
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    # Parse arguments
+    verbose = "--verbose" in args or "-v" in args
+    no_color = "--no-color" in args
+    fix = "--fix" in args
+    parallel = "--parallel" in args
+
+    # Extract specific checks if provided
+    checks = None
+    if "--checks" in args:
+        try:
+            idx = args.index("--checks")
+            if idx + 1 < len(args):
+                # Get all arguments after --checks until next flag
+                checks = []
+                for i in range(idx + 1, len(args)):
+                    if args[i].startswith("-"):
+                        break
+                    checks.append(args[i])
+        except (ValueError, IndexError):
+            pass
+
+    # Print header
+    print("\n" + "=" * 60)
+    print("Claude MPM Doctor Report")
+    print("=" * 60)
+
+    # Run diagnostics
+    result = run_diagnostics(
+        verbose=verbose,
+        fix=fix,
+        checks=checks,
+        parallel=parallel,
+        output_format="terminal",
+        no_color=no_color,
+    )
+
+    # Handle results
+    if not result["success"]:
+        print(f"\n❌ {result['message']}")
+        if verbose and result.get("message", "").startswith("Diagnostic failed"):
+            import traceback
+
+            traceback.print_exc()
+        return False
+
+    # Format and display output
+    format_output(
+        result["summary"], output_format="terminal", verbose=verbose, no_color=no_color
+    )
+
+    # Return based on status
+    return result["error_count"] == 0
+
+
+def main():
+    """
+    Main entry point for standalone execution.
+
+    WHY: Allows the script to be run directly for testing or debugging.
+    """
+    parser = argparse.ArgumentParser(
+        description="Claude MPM Doctor - Diagnostic Tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Show detailed diagnostic information",
+    )
+
+    parser.add_argument(
+        "--json", action="store_true", help="Output results in JSON format"
+    )
+
+    parser.add_argument(
+        "--markdown", action="store_true", help="Output results in Markdown format"
+    )
+
+    parser.add_argument(
+        "--fix",
+        action="store_true",
+        help="Attempt to fix issues automatically (experimental)",
+    )
+
+    parser.add_argument(
+        "--checks",
+        nargs="+",
+        choices=[
+            "installation",
+            "configuration",
+            "filesystem",
+            "claude",
+            "agents",
+            "mcp",
+            "monitor",
+            "common",
+        ],
+        help="Run only specific checks",
+    )
+
+    parser.add_argument(
+        "--parallel",
+        action="store_true",
+        help="Run checks in parallel for faster execution",
+    )
+
+    parser.add_argument(
+        "--no-color", action="store_true", help="Disable colored output"
+    )
+
+    parser.add_argument("--output", "-o", type=Path, help="Save output to file")
+
+    args = parser.parse_args()
+
+    # Determine output format
+    if args.json:
+        output_format = "json"
+    elif args.markdown:
+        output_format = "markdown"
+    else:
+        output_format = "terminal"
+
+    # Run diagnostics
+    result = run_diagnostics(
+        verbose=args.verbose,
+        fix=args.fix,
+        checks=args.checks,
+        parallel=args.parallel,
+        output_format=output_format,
+        no_color=args.no_color,
+    )
+
+    # Handle failure
+    if not result["success"]:
+        print(f"\n❌ {result['message']}")
+        sys.exit(2)
+
+    # Format output
+    output = format_output(
+        result["summary"],
+        output_format=output_format,
+        verbose=args.verbose,
+        no_color=args.no_color,
+    )
+
+    # Save to file if requested
+    if args.output:
+        try:
+            args.output.write_text(output)
+            print(f"Report saved to: {args.output}")
+        except Exception as e:
+            print(f"❌ Failed to save report: {e!s}")
+            sys.exit(2)
+
+    # Determine exit code
+    if result["error_count"] > 0:
+        sys.exit(2)  # Errors found
+    elif result["warning_count"] > 0:
+        sys.exit(1)  # Warnings found
+    else:
+        sys.exit(0)  # All OK
+
+
+if __name__ == "__main__":
+    main()

claude_mpm/scripts/socketio_daemon.py

@@ -4,7 +4,6 @@ Pure Python daemon management for Socket.IO server.
 No external dependencies required.
 """
 
-import json
 import os
 import signal
 import subprocess
@@ -12,60 +11,64 @@ import sys
 import time
 from pathlib import Path
 
+
 # Detect and use virtual environment Python if available
 def get_python_executable():
     """
     Get the appropriate Python executable, preferring virtual environment.
-    
+
     WHY: The daemon must use the same Python environment as the parent process
     to ensure all dependencies are available. System Python won't have the
     required packages installed.
     """
     # First, check if we're already in a virtual environment
-    if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+    if hasattr(sys, "real_prefix") or (
+        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+    ):
         # We're in a virtual environment, use its Python
         return sys.executable
-    
+
     # Check for common virtual environment indicators
     # 1. VIRTUAL_ENV environment variable (most common)
-    venv_path = os.environ.get('VIRTUAL_ENV')
+    venv_path = os.environ.get("VIRTUAL_ENV")
     if venv_path:
-        venv_python = Path(venv_path) / 'bin' / 'python'
+        venv_python = Path(venv_path) / "bin" / "python"
         if venv_python.exists():
             return str(venv_python)
-    
+
     # 2. Check if current executable is in a venv directory structure
     exe_path = Path(sys.executable).resolve()
     for parent in exe_path.parents:
         # Check for common venv directory names
-        if parent.name in ('venv', '.venv', 'env', '.env'):
+        if parent.name in ("venv", ".venv", "env", ".env"):
             # This looks like a virtual environment
             return sys.executable
-        
+
         # Check for typical venv structure (bin/python or Scripts/python.exe)
-        if parent.name == 'bin' and (parent.parent / 'pyvenv.cfg').exists():
+        if parent.name == "bin" and (parent.parent / "pyvenv.cfg").exists():
             return sys.executable
-        if parent.name == 'Scripts' and (parent.parent / 'pyvenv.cfg').exists():
+        if parent.name == "Scripts" and (parent.parent / "pyvenv.cfg").exists():
             return sys.executable
-    
+
     # 3. Try to detect project-specific venv
     # Look for venv in the project root (going up from script location)
     script_path = Path(__file__).resolve()
     for parent in script_path.parents:
         # Stop at src or when we've gone too far up
-        if parent.name == 'src' or not (parent / 'src').exists():
+        if parent.name == "src" or not (parent / "src").exists():
             # Check for venv directories
-            for venv_name in ('venv', '.venv', 'env', '.env'):
+            for venv_name in ("venv", ".venv", "env", ".env"):
                 venv_dir = parent / venv_name
                 if venv_dir.exists():
-                    venv_python = venv_dir / 'bin' / 'python'
+                    venv_python = venv_dir / "bin" / "python"
                     if venv_python.exists():
                         return str(venv_python)
             break
-    
+
     # Fall back to current Python executable
     return sys.executable
 
+
 # Store the detected Python executable for daemon usage
 PYTHON_EXECUTABLE = get_python_executable()
 
@@ -242,7 +245,9 @@ def start_server():
     )
     print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python executable: {sys.executable}")
     print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python version: {sys.version}")
-    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python path: {sys.path[:3]}...")  # Show first 3 entries
+    print(
+        f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] Python path: {sys.path[:3]}..."
+    )  # Show first 3 entries
     server = SocketIOServer(host="localhost", port=selected_port)
 
     # Handle signals
@@ -281,7 +286,7 @@ def stop_server():
     """Stop the Socket.IO daemon server."""
     if not is_running():
         print("Socket.IO daemon server is not running.")
-        print(f"Check for other servers: socketio_server_manager.py status")
+        print("Check for other servers: socketio_server_manager.py status")
         return
 
     try:
@@ -351,7 +356,7 @@ def status_server():
         # Show instance information
         instance = port_manager.get_instance_by_port(current_port)
         if instance:
-            print(f"\n📊 Instance Information:")
+            print("\n📊 Instance Information:")
             print(f"   • Port: {instance.get('port')}")
             print(f"   • Started: {time.ctime(instance.get('start_time', 0))}")
             print(f"   • Instance ID: {instance.get('instance_id')}")
@@ -370,19 +375,17 @@ def status_server():
             if response.status_code == 200:
                 data = response.json()
                 if "server_id" in data and data.get("server_id") != "daemon-socketio":
-                    print(
-                        f"\n⚠️  POTENTIAL CONFLICT: HTTP-managed server also detected"
-                    )
+                    print("\n⚠️  POTENTIAL CONFLICT: HTTP-managed server also detected")
                     print(f"   Server ID: {data.get('server_id')}")
-                    print(f"   Use 'socketio_server_manager.py diagnose' to resolve")
+                    print("   Use 'socketio_server_manager.py diagnose' to resolve")
         except:
             pass
 
     else:
         print("Socket.IO daemon server is not running")
-        print(f"\n🔧 Start Commands:")
+        print("\n🔧 Start Commands:")
         print(f"   • Daemon: {__file__} start")
-        print(f"   • HTTP-managed: socketio_server_manager.py start")
+        print("   • HTTP-managed: socketio_server_manager.py start")
 
 
 def list_instances():