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

claude_mpm/hooks/validation_hooks.py

@@ -61,7 +61,7 @@ class ValidationHooks:
                         result.is_valid = False
             except Exception as e:
                 logger.error(f"Pre-load hook failed: {e}")
-                result.warnings.append(f"Pre-load hook failed: {str(e)}")
+                result.warnings.append(f"Pre-load hook failed: {e!s}")
 
         return result
 
@@ -79,7 +79,7 @@ class ValidationHooks:
                     result.warnings.extend(hook_result.warnings)
             except Exception as e:
                 logger.error(f"Post-load hook failed: {e}")
-                result.warnings.append(f"Post-load hook failed: {str(e)}")
+                result.warnings.append(f"Post-load hook failed: {e!s}")
 
         return result
 
@@ -107,7 +107,7 @@ class ValidationHooks:
                     result.is_valid = False
             except Exception as e:
                 logger.error(f"Pre-execute hook failed: {e}")
-                result.warnings.append(f"Pre-execute hook failed: {str(e)}")
+                result.warnings.append(f"Pre-execute hook failed: {e!s}")
 
         return result
 
@@ -118,7 +118,7 @@ async def validate_agent_dependencies(profile_path: Path) -> ValidationResult:
     result = ValidationResult(is_valid=True)
 
     try:
-        with open(profile_path, "r") as f:
+        with open(profile_path) as f:
             profile_data = yaml.safe_load(f)
 
         # Check for circular dependencies

claude_mpm/init.py

@@ -8,7 +8,8 @@ Handles creation of necessary directories and configuration files.
 import json
 import os
 import shutil
-from typing import Any, Dict, Optional
+import sys
+from typing import Dict, Optional
 
 import yaml
 
@@ -142,12 +143,10 @@ class ProjectInitializer:
 
             # Log successful creation with details
             self.logger.info(f"Initialized project directory at {self.project_dir}")
-            self.logger.debug(f"Created directories: agents, config, responses, logs")
+            self.logger.debug("Created directories: agents, config, responses, logs")
 
             # Print appropriate message to console for visibility during startup
             # BUT: Don't print to stdout when running MCP server (interferes with JSON-RPC)
-            import sys
-
             is_mcp_mode = "mcp" in sys.argv and "start" in sys.argv
 
             if not is_mcp_mode:
@@ -216,8 +215,6 @@ class ProjectInitializer:
 
                 if migrated_count > 0:
                     # Don't print to stdout when running MCP server
-                    import sys
-
                     is_mcp_mode = "mcp" in sys.argv and "start" in sys.argv
                     if not is_mcp_mode:
                         print(
@@ -254,7 +251,7 @@ class ProjectInitializer:
         """
         try:
             # Read existing JSON configuration
-            with open(old_file, "r") as f:
+            with open(old_file) as f:
                 config = json.load(f)
 
             # Write as YAML
@@ -327,8 +324,6 @@ class ProjectInitializer:
         dependencies = {}
 
         # Check Python version
-        import sys
-
         dependencies["python"] = sys.version_info >= (3, 8)
 
         # Check Claude CLI

claude_mpm/models/__init__.py

@@ -17,8 +17,8 @@ from .agent_definition import (
 __all__ = [
     "AgentDefinition",
     "AgentMetadata",
-    "AgentType",
+    "AgentPermissions",
     "AgentSection",
+    "AgentType",
     "AgentWorkflow",
-    "AgentPermissions",
 ]

claude_mpm/models/agent_session.py

@@ -12,7 +12,6 @@ chronological order for session replay and analysis.
 """
 
 import json
-import os
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
 from enum import Enum
@@ -241,29 +240,28 @@ class AgentSession:
         # Check event type patterns
         if "prompt" in event_type.lower() or event_type == "user_input":
             return EventCategory.PROMPT
-        elif "delegation" in event_type.lower() or event_type == "Task":
+        if "delegation" in event_type.lower() or event_type == "Task":
             return EventCategory.DELEGATION
-        elif "tool" in event_type.lower() or event_type in [
+        if "tool" in event_type.lower() or event_type in [
             "PreToolUse",
             "PostToolUse",
         ]:
             return EventCategory.TOOL
-        elif (
+        if (
             "file" in event_type.lower()
             or "write" in event_type.lower()
             or "read" in event_type.lower()
         ):
             return EventCategory.FILE
-        elif "todo" in event_type.lower():
+        if "todo" in event_type.lower():
             return EventCategory.TODO
-        elif "response" in event_type.lower() or event_type in ["Stop", "SubagentStop"]:
+        if "response" in event_type.lower() or event_type in ["Stop", "SubagentStop"]:
             return EventCategory.RESPONSE
-        elif "memory" in event_type.lower():
+        if "memory" in event_type.lower():
             return EventCategory.MEMORY
-        elif "status" in event_type.lower() or "session" in event_type.lower():
+        if "status" in event_type.lower() or "session" in event_type.lower():
             return EventCategory.STATUS
-        else:
-            return EventCategory.SYSTEM
+        return EventCategory.SYSTEM
 
     def _process_event(self, event: SessionEvent):
         """Process specific event types to update session state.
@@ -376,9 +374,8 @@ class AgentSession:
                 self.active_delegation.todos_modified.append(data["todos"])
 
         # Track memory updates
-        elif event.category == EventCategory.MEMORY:
-            if self.active_delegation:
-                self.active_delegation.memory_updates.append(data)
+        elif event.category == EventCategory.MEMORY and self.active_delegation:
+            self.active_delegation.memory_updates.append(data)
 
     def finalize(self):
         """Finalize the session by calculating final metrics.
@@ -534,6 +531,6 @@ class AgentSession:
 
         WHY: Enables analysis of historical sessions.
         """
-        with open(filepath, "r", encoding="utf-8") as f:
+        with open(filepath, encoding="utf-8") as f:
             data = json.load(f)
         return cls.from_dict(data)

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()