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

claude_mpm/core/hook_manager.py

@@ -12,6 +12,7 @@ WHY this is needed:
 - Ensures consistent event streaming to Socket.IO dashboard
 """
 
+import contextlib
 import json
 import os
 import queue
@@ -22,7 +23,6 @@ from datetime import datetime
 from typing import Any, Dict, Optional
 
 from ..core.logger import get_logger
-from .config_constants import ConfigConstants
 from .hook_performance_config import get_hook_performance_config
 from .unified_paths import get_package_root
 
@@ -45,14 +45,16 @@ class HookManager:
         # Initialize background hook processing for async execution
         self.performance_config = get_hook_performance_config()
         queue_config = self.performance_config.get_queue_config()
-        self.hook_queue = queue.Queue(maxsize=queue_config['maxsize'])
+        self.hook_queue = queue.Queue(maxsize=queue_config["maxsize"])
         self.background_thread = None
         self.shutdown_event = threading.Event()
 
         # Start background processing if hook handler is available
         if self.hook_handler_path:
             self._start_background_processor()
-            self.logger.debug(f"Hook handler found with async processing: {self.hook_handler_path}")
+            self.logger.debug(
+                f"Hook handler found with async processing: {self.hook_handler_path}"
+            )
         else:
             self.logger.debug("Hook handler not found - hooks will be skipped")
 
@@ -68,6 +70,7 @@ class HookManager:
 
     def _start_background_processor(self):
         """Start background thread to process hooks asynchronously."""
+
         def process_hooks():
             """Background thread function to process hook queue."""
             while not self.shutdown_event.is_set():
@@ -88,9 +91,7 @@ class HookManager:
                     self.logger.error(f"Hook processing error: {e}")
 
         self.background_thread = threading.Thread(
-            target=process_hooks,
-            name="hook-processor",
-            daemon=True
+            target=process_hooks, name="hook-processor", daemon=True
         )
         self.background_thread.start()
         self.logger.debug("Started background hook processor thread")
@@ -98,14 +99,14 @@ class HookManager:
     def _execute_hook_sync(self, hook_data: Dict[str, Any]):
         """Execute a single hook synchronously in the background thread."""
         try:
-            hook_type = hook_data['hook_type']
-            event_data = hook_data['event_data']
+            hook_type = hook_data["hook_type"]
+            event_data = hook_data["event_data"]
 
             # Create the hook event
             hook_event = {
                 "hook_event_name": hook_type,
                 "session_id": self.session_id,
-                "timestamp": hook_data.get('timestamp', datetime.utcnow().isoformat()),
+                "timestamp": hook_data.get("timestamp", datetime.utcnow().isoformat()),
                 **event_data,
             }
 
@@ -121,6 +122,7 @@ class HookManager:
                 capture_output=True,
                 env=env,
                 timeout=self.performance_config.background_timeout,
+                check=False,
             )
 
             if result.returncode != 0:
@@ -129,7 +131,9 @@ class HookManager:
                     self.logger.debug(f"Hook stderr: {result.stderr}")
 
         except subprocess.TimeoutExpired:
-            self.logger.debug(f"Hook {hook_data.get('hook_type', 'unknown')} timed out in background")
+            self.logger.debug(
+                f"Hook {hook_data.get('hook_type', 'unknown')} timed out in background"
+            )
         except Exception as e:
             self.logger.debug(f"Background hook execution error: {e}")
 
@@ -138,10 +142,8 @@ class HookManager:
         if self.background_thread and self.background_thread.is_alive():
             self.shutdown_event.set()
             # Signal shutdown by putting None in queue
-            try:
+            with contextlib.suppress(queue.Full):
                 self.hook_queue.put_nowait(None)
-            except queue.Full:
-                pass
 
             # Wait for thread to finish
             self.background_thread.join(timeout=2.0)
@@ -157,15 +159,14 @@ class HookManager:
 
             if hook_handler.exists():
                 return hook_handler
-            else:
-                self.logger.warning(f"Hook handler not found at: {hook_handler}")
-                return None
+            self.logger.warning(f"Hook handler not found at: {hook_handler}")
+            return None
         except Exception as e:
             self.logger.error(f"Error finding hook handler: {e}")
             return None
 
     def trigger_pre_tool_hook(
-        self, tool_name: str, tool_args: Dict[str, Any] = None
+        self, tool_name: str, tool_args: Optional[Dict[str, Any]] = None
     ) -> bool:
         """Trigger PreToolUse hook event.
 
@@ -247,14 +248,16 @@ class HookManager:
         try:
             # Queue hook for background processing
             hook_data = {
-                'hook_type': hook_type,
-                'event_data': event_data,
-                'timestamp': datetime.utcnow().isoformat()
+                "hook_type": hook_type,
+                "event_data": event_data,
+                "timestamp": datetime.utcnow().isoformat(),
             }
 
             # Try to queue without blocking
             self.hook_queue.put_nowait(hook_data)
-            self.logger.debug(f"Successfully queued {hook_type} hook for background processing")
+            self.logger.debug(
+                f"Successfully queued {hook_type} hook for background processing"
+            )
             return True
 
         except queue.Full:
@@ -276,6 +279,7 @@ def get_hook_manager() -> HookManager:
         _hook_manager = HookManager()
         # Register cleanup on exit
         import atexit
+
         atexit.register(_cleanup_hook_manager)
     return _hook_manager
 
@@ -290,7 +294,7 @@ def _cleanup_hook_manager():
 
 def trigger_tool_hooks(
     tool_name: str,
-    tool_args: Dict[str, Any] = None,
+    tool_args: Optional[Dict[str, Any]] = None,
     result: Any = None,
     exit_code: int = 0,
 ):

claude_mpm/core/hook_performance_config.py

@@ -10,72 +10,83 @@ from typing import Dict, Optional
 
 class HookPerformanceConfig:
     """Configuration for hook performance optimization."""
-    
+
     def __init__(self):
         """Initialize hook performance configuration from environment."""
         self._load_config()
-    
+
     def _load_config(self):
         """Load configuration from environment variables."""
         # Performance mode - disables all hooks for maximum speed
-        self.performance_mode = os.getenv('CLAUDE_MPM_PERFORMANCE_MODE', 'false').lower() == 'true'
-        
+        self.performance_mode = (
+            os.getenv("CLAUDE_MPM_PERFORMANCE_MODE", "false").lower() == "true"
+        )
+
         # Individual hook type controls
-        self.enable_pre_tool_hooks = os.getenv('CLAUDE_MPM_HOOKS_PRE_TOOL', 'true').lower() == 'true'
-        self.enable_post_tool_hooks = os.getenv('CLAUDE_MPM_HOOKS_POST_TOOL', 'true').lower() == 'true'
-        self.enable_user_prompt_hooks = os.getenv('CLAUDE_MPM_HOOKS_USER_PROMPT', 'true').lower() == 'true'
-        self.enable_delegation_hooks = os.getenv('CLAUDE_MPM_HOOKS_DELEGATION', 'true').lower() == 'true'
-        
+        self.enable_pre_tool_hooks = (
+            os.getenv("CLAUDE_MPM_HOOKS_PRE_TOOL", "true").lower() == "true"
+        )
+        self.enable_post_tool_hooks = (
+            os.getenv("CLAUDE_MPM_HOOKS_POST_TOOL", "true").lower() == "true"
+        )
+        self.enable_user_prompt_hooks = (
+            os.getenv("CLAUDE_MPM_HOOKS_USER_PROMPT", "true").lower() == "true"
+        )
+        self.enable_delegation_hooks = (
+            os.getenv("CLAUDE_MPM_HOOKS_DELEGATION", "true").lower() == "true"
+        )
+
         # Background processing settings
-        self.queue_size = int(os.getenv('CLAUDE_MPM_HOOK_QUEUE_SIZE', '1000'))
-        self.background_timeout = float(os.getenv('CLAUDE_MPM_HOOK_BG_TIMEOUT', '2.0'))
-        
+        self.queue_size = int(os.getenv("CLAUDE_MPM_HOOK_QUEUE_SIZE", "1000"))
+        self.background_timeout = float(os.getenv("CLAUDE_MPM_HOOK_BG_TIMEOUT", "2.0"))
+
         # Batching settings (for future implementation)
-        self.enable_batching = os.getenv('CLAUDE_MPM_HOOK_BATCHING', 'false').lower() == 'true'
-        self.batch_size = int(os.getenv('CLAUDE_MPM_HOOK_BATCH_SIZE', '10'))
-        self.batch_timeout_ms = int(os.getenv('CLAUDE_MPM_HOOK_BATCH_TIMEOUT_MS', '100'))
-    
+        self.enable_batching = (
+            os.getenv("CLAUDE_MPM_HOOK_BATCHING", "false").lower() == "true"
+        )
+        self.batch_size = int(os.getenv("CLAUDE_MPM_HOOK_BATCH_SIZE", "10"))
+        self.batch_timeout_ms = int(
+            os.getenv("CLAUDE_MPM_HOOK_BATCH_TIMEOUT_MS", "100")
+        )
+
     def is_hook_enabled(self, hook_type: str) -> bool:
         """Check if a specific hook type is enabled.
-        
+
         Args:
             hook_type: Type of hook (PreToolUse, PostToolUse, UserPromptSubmit, etc.)
-            
+
         Returns:
             bool: True if hook should be processed
         """
         if self.performance_mode:
             return False
-        
+
         hook_type_lower = hook_type.lower()
-        
-        if 'pretool' in hook_type_lower or 'pre_tool' in hook_type_lower:
+
+        if "pretool" in hook_type_lower or "pre_tool" in hook_type_lower:
             return self.enable_pre_tool_hooks
-        elif 'posttool' in hook_type_lower or 'post_tool' in hook_type_lower:
+        if "posttool" in hook_type_lower or "post_tool" in hook_type_lower:
             return self.enable_post_tool_hooks
-        elif 'userprompt' in hook_type_lower or 'user_prompt' in hook_type_lower:
+        if "userprompt" in hook_type_lower or "user_prompt" in hook_type_lower:
             return self.enable_user_prompt_hooks
-        elif 'delegation' in hook_type_lower:
+        if "delegation" in hook_type_lower:
             return self.enable_delegation_hooks
-        
+
         # Default to enabled for unknown hook types
         return True
-    
+
     def get_queue_config(self) -> Dict[str, int]:
         """Get queue configuration for background processing."""
-        return {
-            'maxsize': self.queue_size,
-            'timeout': self.background_timeout
-        }
-    
+        return {"maxsize": self.queue_size, "timeout": self.background_timeout}
+
     def get_batch_config(self) -> Dict[str, any]:
         """Get batching configuration (for future use)."""
         return {
-            'enabled': self.enable_batching,
-            'batch_size': self.batch_size,
-            'timeout_ms': self.batch_timeout_ms
+            "enabled": self.enable_batching,
+            "batch_size": self.batch_size,
+            "timeout_ms": self.batch_timeout_ms,
         }
-    
+
     def print_config(self) -> str:
         """Return a string representation of current configuration."""
         config_lines = [
@@ -106,11 +117,11 @@ def get_hook_performance_config() -> HookPerformanceConfig:
 
 def set_performance_mode(enabled: bool):
     """Enable or disable performance mode programmatically.
-    
+
     Args:
         enabled: True to enable performance mode (disable all hooks)
     """
-    os.environ['CLAUDE_MPM_PERFORMANCE_MODE'] = 'true' if enabled else 'false'
+    os.environ["CLAUDE_MPM_PERFORMANCE_MODE"] = "true" if enabled else "false"
     # Reload configuration
     global _hook_config
     _hook_config = None
@@ -123,14 +134,14 @@ def is_performance_mode() -> bool:
 
 # Environment variable documentation for users
 ENVIRONMENT_VARIABLES = {
-    'CLAUDE_MPM_PERFORMANCE_MODE': 'Set to "true" to disable all hooks for maximum performance',
-    'CLAUDE_MPM_HOOKS_PRE_TOOL': 'Set to "false" to disable pre-tool hooks',
-    'CLAUDE_MPM_HOOKS_POST_TOOL': 'Set to "false" to disable post-tool hooks',
-    'CLAUDE_MPM_HOOKS_USER_PROMPT': 'Set to "false" to disable user prompt hooks',
-    'CLAUDE_MPM_HOOKS_DELEGATION': 'Set to "false" to disable delegation hooks',
-    'CLAUDE_MPM_HOOK_QUEUE_SIZE': 'Maximum number of hooks in background queue (default: 1000)',
-    'CLAUDE_MPM_HOOK_BG_TIMEOUT': 'Timeout for background hook processing in seconds (default: 2.0)',
-    'CLAUDE_MPM_HOOK_BATCHING': 'Set to "true" to enable hook batching (experimental)',
-    'CLAUDE_MPM_HOOK_BATCH_SIZE': 'Number of hooks to batch together (default: 10)',
-    'CLAUDE_MPM_HOOK_BATCH_TIMEOUT_MS': 'Batch timeout in milliseconds (default: 100)',
+    "CLAUDE_MPM_PERFORMANCE_MODE": 'Set to "true" to disable all hooks for maximum performance',
+    "CLAUDE_MPM_HOOKS_PRE_TOOL": 'Set to "false" to disable pre-tool hooks',
+    "CLAUDE_MPM_HOOKS_POST_TOOL": 'Set to "false" to disable post-tool hooks',
+    "CLAUDE_MPM_HOOKS_USER_PROMPT": 'Set to "false" to disable user prompt hooks',
+    "CLAUDE_MPM_HOOKS_DELEGATION": 'Set to "false" to disable delegation hooks',
+    "CLAUDE_MPM_HOOK_QUEUE_SIZE": "Maximum number of hooks in background queue (default: 1000)",
+    "CLAUDE_MPM_HOOK_BG_TIMEOUT": "Timeout for background hook processing in seconds (default: 2.0)",
+    "CLAUDE_MPM_HOOK_BATCHING": 'Set to "true" to enable hook batching (experimental)',
+    "CLAUDE_MPM_HOOK_BATCH_SIZE": "Number of hooks to batch together (default: 10)",
+    "CLAUDE_MPM_HOOK_BATCH_TIMEOUT_MS": "Batch timeout in milliseconds (default: 100)",
 }

claude_mpm/core/injectable_service.py

@@ -199,7 +199,7 @@ class InjectableService(BaseService, ABC):
         deps = []
         annotations = getattr(self.__class__, "__annotations__", {})
 
-        for attr_name, attr_type in annotations.items():
+        for attr_name, _attr_type in annotations.items():
             if hasattr(self, attr_name) and not attr_name.startswith("_"):
                 deps.append(
                     f"{attr_name}={getattr(self, attr_name).__class__.__name__}"

claude_mpm/core/interactive_session.py

@@ -4,11 +4,10 @@ This module provides the InteractiveSession class that manages Claude's interact
 with proper separation of concerns and reduced complexity.
 """
 
+import contextlib
 import os
 import subprocess
-import sys
 import uuid
-from datetime import datetime
 from typing import Any, Dict, Optional, Tuple
 
 from claude_mpm.core.logger import get_logger
@@ -134,7 +133,6 @@ class InteractiveSession:
 
             # Deploy project-specific agents
             self.runner.deploy_project_agents_to_claude()
-            
 
             # Build command
             cmd = self._build_claude_command()
@@ -186,8 +184,7 @@ class InteractiveSession:
             # Launch using selected method
             if self.runner.launch_method == "subprocess":
                 return self._launch_subprocess_mode(cmd, env)
-            else:
-                return self._launch_exec_mode(cmd, env)
+            return self._launch_exec_mode(cmd, env)
 
         except FileNotFoundError as e:
             self._handle_launch_error("FileNotFoundError", e)
@@ -206,7 +203,11 @@ class InteractiveSession:
             return self._attempt_fallback_launch(environment)
 
     def process_interactive_command(self, prompt: str) -> Optional[bool]:
-        """Process special interactive commands like /agents and /mpm-doctor.
+        """Process special interactive commands.
+
+        NOTE: As of v4.1.2, MPM slash commands are deployed as markdown files
+        to ~/.claude/commands and handled directly by Claude Code.
+        This method is kept for potential future use with non-Claude commands.
 
         Args:
             prompt: User input command
@@ -214,21 +215,7 @@ class InteractiveSession:
         Returns:
             Optional[bool]: True if handled, False if error, None if not a special command
         """
-        # Parse command and arguments
-        parts = prompt.strip().split()
-        if not parts:
-            return None
-            
-        command = parts[0]
-        args = parts[1:]
-        
-        # Check for special commands
-        if command == "/agents":
-            return self._show_available_agents()
-        elif command == "/mpm-doctor":
-            return self._run_doctor_diagnostics(args)
-
-        # Not a special command
+        # Currently no commands are intercepted - all MPM commands are handled by Claude Code
         return None
 
     def cleanup_interactive_session(self) -> None:
@@ -239,10 +226,8 @@ class InteractiveSession:
         try:
             # Restore original directory
             if self.original_cwd and os.path.exists(self.original_cwd):
-                try:
+                with contextlib.suppress(OSError):
                     os.chdir(self.original_cwd)
-                except OSError:
-                    pass
 
             # Close WebSocket if connected
             if self.runner.websocket_server:
@@ -307,7 +292,7 @@ class InteractiveSession:
     def _display_welcome_message(self) -> None:
         """Display the interactive session welcome message."""
         version_str = self.runner._get_version()
-        
+
         # Get output style status
         output_style_info = self._get_output_style_info()
 
@@ -320,40 +305,47 @@ class InteractiveSession:
             print(f"\033[32m│\033[0m   {output_style_info:<49}\033[32m│\033[0m")
         print("\033[32m│                                                   │\033[0m")
         print(
-            "\033[32m│\033[0m   Commands:                                       \033[32m│\033[0m"
+            "\033[32m│\033[0m   MPM Commands (via Claude Code):                 \033[32m│\033[0m"
+        )
+        print(
+            "\033[32m│\033[0m     /mpm        - MPM overview and help           \033[32m│\033[0m"
         )
         print(
-            "\033[32m│\033[0m     /agents      - Show available agents          \033[32m│\033[0m"
+            "\033[32m│\033[0m     /mpm-agents - Show available agents           \033[32m│\033[0m"
         )
         print(
-            "\033[32m│\033[0m     /mpm-doctor  - Run diagnostic checks          \033[32m│\033[0m"
+            "\033[32m│\033[0m     /mpm-doctor - Run diagnostic checks           \033[32m│\033[0m"
         )
+        print(
+            "\033[32m│\033[0m     Type / for autocomplete in Claude Code        \033[32m│\033[0m"
+        )
+
         print("\033[32m╰───────────────────────────────────────────────────╯\033[0m")
         print("")  # Add blank line after box
-    
-    
+
     def _get_output_style_info(self) -> Optional[str]:
         """Get output style status for display."""
         try:
             # Check if output style manager is available through framework loader
-            if hasattr(self.runner, 'framework_loader') and self.runner.framework_loader:
-                if hasattr(self.runner.framework_loader, 'output_style_manager'):
-                    osm = self.runner.framework_loader.output_style_manager
-                    if osm:
-                        if osm.claude_version and osm.supports_output_styles():
-                            # Check if claude-mpm style is active
-                            settings_file = osm.settings_file
-                            if settings_file.exists():
-                                import json
-                                settings = json.loads(settings_file.read_text())
-                                active_style = settings.get("activeOutputStyle")
-                                if active_style == "claude-mpm":
-                                    return "Output Style: claude-mpm ✅"
-                                else:
-                                    return f"Output Style: {active_style or 'none'}"
-                            return "Output Style: Available"
-                        else:
-                            return "Output Style: Injected (legacy)"
+            if (
+                hasattr(self.runner, "framework_loader")
+                and self.runner.framework_loader
+            ) and hasattr(self.runner.framework_loader, "output_style_manager"):
+                osm = self.runner.framework_loader.output_style_manager
+                if osm:
+                    if osm.claude_version and osm.supports_output_styles():
+                        # Check if claude-mpm style is active
+                        settings_file = osm.settings_file
+                        if settings_file.exists():
+                            import json
+
+                            settings = json.loads(settings_file.read_text())
+                            active_style = settings.get("activeOutputStyle")
+                            if active_style == "claude-mpm":
+                                return "Output Style: claude-mpm ✅"
+                            return f"Output Style: {active_style or 'none'}"
+                        return "Output Style: Available"
+                    return "Output Style: Injected (legacy)"
         except Exception:
             pass
         return None
@@ -365,7 +357,9 @@ class InteractiveSession:
 
         if has_resume:
             # When resuming, use minimal command to avoid interfering with conversation selection
-            self.logger.info("🔄 Resume mode detected - using minimal Claude command to preserve conversation selection")
+            self.logger.info(
+                "🔄 Resume mode detected - using minimal Claude command to preserve conversation selection"
+            )
             cmd = ["claude"]
 
             # Add only the claude_args (which includes --resume)
@@ -374,26 +368,25 @@ class InteractiveSession:
                 self.logger.info(f"Resume command: {cmd}")
 
             return cmd
-        else:
-            # Normal mode - full command with all claude-mpm enhancements
-            cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+        # Normal mode - full command with all claude-mpm enhancements
+        cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
 
-            # Add custom arguments
-            if self.runner.claude_args:
-                # Enhanced debug logging for --resume flag verification
-                self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
-                cmd.extend(self.runner.claude_args)
+        # Add custom arguments
+        if self.runner.claude_args:
+            # Enhanced debug logging for --resume flag verification
+            self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
+            cmd.extend(self.runner.claude_args)
 
-            # Add system instructions
-            from claude_mpm.core.claude_runner import create_simple_context
+        # Add system instructions
+        from claude_mpm.core.claude_runner import create_simple_context
 
-            system_prompt = self.runner._create_system_prompt()
-            if system_prompt and system_prompt != create_simple_context():
-                cmd.extend(["--append-system-prompt", system_prompt])
+        system_prompt = self.runner._create_system_prompt()
+        if system_prompt and system_prompt != create_simple_context():
+            cmd.extend(["--append-system-prompt", system_prompt])
 
         # Final command verification
         # self.logger.info(f"Final Claude command built: {' '.join(cmd)}")
-        
+
         # Explicit --resume flag verification
         if "--resume" in cmd:
             self.logger.info("✅ VERIFIED: --resume flag IS included in final command")
@@ -520,7 +513,9 @@ class InteractiveSession:
             cmd = environment["command"]
             env = environment["environment"]
 
-            result = subprocess.run(cmd, stdin=None, stdout=None, stderr=None, env=env)
+            result = subprocess.run(
+                cmd, stdin=None, stdout=None, stderr=None, env=env, check=False
+            )
 
             if result.returncode == 0:
                 if self.runner.project_logger:
@@ -530,9 +525,8 @@ class InteractiveSession:
                         component="session",
                     )
                 return True
-            else:
-                print(f"⚠️  Claude exited with code {result.returncode}")
-                return False
+            print(f"⚠️  Claude exited with code {result.returncode}")
+            return False
 
         except FileNotFoundError:
             print("❌ Fallback failed: Claude CLI not found in PATH")
@@ -546,88 +540,3 @@ class InteractiveSession:
         except Exception as e:
             print(f"❌ Fallback failed with unexpected error: {e}")
             return False
-
-    def _show_available_agents(self) -> bool:
-        """Show available agents in the system."""
-        try:
-            from claude_mpm.cli.utils import get_agent_versions_display
-
-            agent_versions = get_agent_versions_display()
-
-            if agent_versions:
-                print(agent_versions)
-            else:
-                print("No deployed agents found")
-                print("\nTo deploy agents, run: claude-mpm --mpm:agents deploy")
-
-            return True
-
-        except ImportError:
-            print("Error: CLI module not available")
-            return False
-        except Exception as e:
-            print(f"Error getting agent versions: {e}")
-            return False
-
-    def _run_doctor_diagnostics(self, args: list) -> bool:
-        """Run doctor diagnostics from interactive mode.
-        
-        Args:
-            args: Command arguments (e.g., ['--verbose'])
-            
-        Returns:
-            bool: True if successful, False otherwise
-        """
-        try:
-            from claude_mpm.services.diagnostics import DiagnosticRunner, DoctorReporter
-            
-            # Parse arguments
-            verbose = "--verbose" in args or "-v" in args
-            no_color = "--no-color" in args
-            
-            # Print header
-            print("\n" + "="*60)
-            print("Claude MPM Doctor Report")
-            print("="*60)
-            
-            # Create diagnostic runner
-            runner = DiagnosticRunner(verbose=verbose)
-            
-            # Run diagnostics
-            try:
-                summary = runner.run_diagnostics()
-            except KeyboardInterrupt:
-                print("\nDiagnostics interrupted by user")
-                return False
-            except Exception as e:
-                print(f"\n❌ Diagnostic failed: {str(e)}")
-                if verbose:
-                    import traceback
-                    traceback.print_exc()
-                return False
-            
-            # Create reporter
-            reporter = DoctorReporter(
-                use_color=not no_color,
-                verbose=verbose
-            )
-            
-            # Display results in terminal format
-            reporter.report(summary, format="terminal")
-            
-            # Return based on status
-            if summary.error_count > 0:
-                return False
-            
-            return True
-            
-        except ImportError as e:
-            print(f"Error: Diagnostics module not available: {e}")
-            print("Please ensure claude-mpm is properly installed")
-            return False
-        except Exception as e:
-            print(f"Error running diagnostics: {e}")
-            if "--verbose" in args or "-v" in args:
-                import traceback
-                traceback.print_exc()
-            return False