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

claude_mpm/core/claude_runner.py

@@ -1,47 +1,22 @@
 """Claude runner with both exec and subprocess launch methods."""
 
-import json
 import os
-import subprocess
-import sys
-import time
-import uuid
-from datetime import datetime
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
-
-from claude_mpm.config.paths import paths
+from typing import Optional
 
 # Core imports that don't cause circular dependencies
-from claude_mpm.core.config import Config
-from claude_mpm.core.container import ServiceLifetime, get_container
+from claude_mpm.core.container import get_container
 from claude_mpm.core.interfaces import (
     AgentDeploymentInterface,
-    HookServiceInterface,
-    TicketManagerInterface,
 )
-from claude_mpm.core.logger import ProjectLogger, get_project_logger
 from claude_mpm.core.logging_config import (
     get_logger,
-    log_operation,
-    log_performance_context,
 )
 from claude_mpm.services.core.interfaces import (
-    AgentCapabilitiesInterface,
-    CommandHandlerInterface,
-    MemoryHookInterface,
     RunnerConfigurationInterface,
-    SessionManagementInterface,
-    SubprocessLauncherInterface,
-    SystemInstructionsInterface,
-    UtilityServiceInterface,
-    VersionServiceInterface,
 )
 
 # Type checking imports to avoid circular dependencies
-if TYPE_CHECKING:
-    from claude_mpm.services.agents.deployment import AgentDeploymentService
-    from claude_mpm.services.hook_service import HookService
 
 
 class ClaudeRunner:
@@ -125,9 +100,7 @@ class ClaudeRunner:
         try:
             self.deployment_service = container.get(AgentDeploymentInterface)
         except Exception as e:
-            self.logger.error(
-                f"Failed to resolve AgentDeploymentService", exc_info=True
-            )
+            self.logger.error("Failed to resolve AgentDeploymentService", exc_info=True)
             raise RuntimeError(
                 f"Agent deployment service initialization failed: {e}"
             ) from e
@@ -213,7 +186,7 @@ class ClaudeRunner:
         # Deploy output style early (before Claude Code launches)
         # This ensures the "Claude MPM" output style is active on startup
         self._deploy_output_style()
-        
+
         # Create session log file using configuration service
         self.session_log_file = self.configuration_service.create_session_log_file(
             self.project_logger, self.log_level, config_data
@@ -260,15 +233,14 @@ class ClaudeRunner:
                 # Set Claude environment
                 self.deployment_service.set_claude_environment()
                 return True
-            else:
-                self.logger.info("All agents already up to date")
-                if self.project_logger:
-                    self.project_logger.log_system(
-                        "All agents already up to date",
-                        level="INFO",
-                        component="deployment",
-                    )
-                return True
+            self.logger.info("All agents already up to date")
+            if self.project_logger:
+                self.project_logger.log_system(
+                    "All agents already up to date",
+                    level="INFO",
+                    component="deployment",
+                )
+            return True
 
         except PermissionError as e:
             error_msg = f"Permission denied deploying agents to .claude/agents/: {e}"
@@ -366,15 +338,14 @@ class ClaudeRunner:
                     self.logger.info(f"Updated {updated_count} agents in project")
 
                 return True
-            elif results.get("skipped", []):
+            if results.get("skipped", []):
                 # Agents already exist and are current
                 self.logger.debug(
                     f"Project agents up to date: {len(results['skipped'])} agents"
                 )
                 return True
-            else:
-                self.logger.warning("No agents deployed to project")
-                return False
+            self.logger.warning("No agents deployed to project")
+            return False
 
         except Exception as e:
             self.logger.error(f"Failed to ensure project agents: {e}")
@@ -502,8 +473,13 @@ class ClaudeRunner:
                     if needs_update:
                         # Build the agent markdown using the pre-initialized service and base agent data
                         # Use template_builder service instead of removed _build_agent_markdown method
-                        agent_content = project_deployment.template_builder.build_agent_markdown(
-                            agent_name, json_file, base_agent_data, source_info="project"
+                        agent_content = (
+                            project_deployment.template_builder.build_agent_markdown(
+                                agent_name,
+                                json_file,
+                                base_agent_data,
+                                source_info="project",
+                            )
                         )
 
                         # Mark as project agent
@@ -584,15 +560,13 @@ class ClaudeRunner:
         """
         if self.session_management_service:
             return self.session_management_service.run_oneshot_session(prompt, context)
-        else:
-            self.logger.error("Session management service not available")
-            print("Error: Session management service not available")
-            return False
+        self.logger.error("Session management service not available")
+        print("Error: Session management service not available")
+        return False
 
     def _extract_tickets(self, text: str):
         """Extract tickets from Claude's response (disabled - use claude-mpm tickets CLI)."""
         # Ticket extraction disabled - users should use claude-mpm tickets CLI commands
-        pass
 
     def _load_system_instructions(self) -> Optional[str]:
         """Load and process system instructions.
@@ -601,12 +575,11 @@ class ClaudeRunner:
         """
         if self.system_instructions_service:
             return self.system_instructions_service.load_system_instructions()
-        else:
-            # Fallback if service is not available
-            self.logger.warning(
-                "System instructions service not available, using basic fallback"
-            )
-            return None
+        # Fallback if service is not available
+        self.logger.warning(
+            "System instructions service not available, using basic fallback"
+        )
+        return None
 
     def _process_base_pm_content(self, base_pm_content: str) -> str:
         """Process BASE_PM.md content with dynamic injections.
@@ -617,12 +590,11 @@ class ClaudeRunner:
             return self.system_instructions_service.process_base_pm_content(
                 base_pm_content
             )
-        else:
-            # Fallback if service is not available
-            self.logger.warning(
-                "System instructions service not available for BASE_PM processing"
-            )
-            return base_pm_content
+        # Fallback if service is not available
+        self.logger.warning(
+            "System instructions service not available for BASE_PM processing"
+        )
+        return base_pm_content
 
     def _strip_metadata_comments(self, content: str) -> str:
         """Strip HTML metadata comments from content.
@@ -631,12 +603,11 @@ class ClaudeRunner:
         """
         if self.system_instructions_service:
             return self.system_instructions_service.strip_metadata_comments(content)
-        else:
-            # Fallback if service is not available
-            self.logger.warning(
-                "System instructions service not available for metadata stripping"
-            )
-            return content
+        # Fallback if service is not available
+        self.logger.warning(
+            "System instructions service not available for metadata stripping"
+        )
+        return content
 
     def _generate_deployed_agent_capabilities(self) -> str:
         """Generate agent capabilities from deployed agents.
@@ -647,20 +618,16 @@ class ClaudeRunner:
             return (
                 self.agent_capabilities_service.generate_deployed_agent_capabilities()
             )
-        else:
-            # Fallback if service is not available
-            self.logger.warning(
-                "Agent capabilities service not available, using fallback"
-            )
-            return self._get_fallback_capabilities()
+        # Fallback if service is not available
+        self.logger.warning("Agent capabilities service not available, using fallback")
+        return self._get_fallback_capabilities()
 
     def _get_fallback_capabilities(self) -> str:
         """Return fallback agent capabilities when deployed agents can't be read."""
         # Delegate to the service if available, otherwise use basic fallback
         if self.agent_capabilities_service:
             return self.agent_capabilities_service._get_fallback_capabilities()
-        else:
-            return """
+        return """
 ## Available Agent Capabilities
 
 You have the following specialized agents available for delegation:
@@ -682,28 +649,24 @@ Use these agents to delegate specialized work via the Task tool.
             return self.system_instructions_service.create_system_prompt(
                 self.system_instructions
             )
-        else:
-            # Fallback if service is not available
-            if self.system_instructions:
-                return self.system_instructions
-            else:
-                return create_simple_context()
+        # Fallback if service is not available
+        if self.system_instructions:
+            return self.system_instructions
+        return create_simple_context()
 
     def _contains_delegation(self, text: str) -> bool:
         """Check if text contains signs of agent delegation using the utility service."""
         if self.utility_service:
             return self.utility_service.contains_delegation(text)
-        else:
-            # Fallback if service not available
-            return False
+        # Fallback if service not available
+        return False
 
     def _extract_agent_from_response(self, text: str) -> Optional[str]:
         """Try to extract agent name from delegation response using the utility service."""
         if self.utility_service:
             return self.utility_service.extract_agent_from_response(text)
-        else:
-            # Fallback if service not available
-            return None
+        # Fallback if service not available
+        return None
 
     def _handle_mpm_command(self, prompt: str) -> bool:
         """Handle /mpm: commands using the command handler service.
@@ -712,10 +675,9 @@ Use these agents to delegate specialized work via the Task tool.
         """
         if self.command_handler_service:
             return self.command_handler_service.handle_mpm_command(prompt)
-        else:
-            # Fallback if service not available
-            print("Command handler service not available")
-            return False
+        # Fallback if service not available
+        print("Command handler service not available")
+        return False
 
     def _log_session_event(self, event_data: dict):
         """Log an event to the session log file using the utility service."""
@@ -732,23 +694,22 @@ Use these agents to delegate specialized work via the Task tool.
         """
         if self.version_service:
             return self.version_service.get_version()
-        else:
-            # Fallback if service not available
-            return "v0.0.0"
+        # Fallback if service not available
+        return "v0.0.0"
 
     def _deploy_output_style(self) -> None:
         """Deploy the Claude MPM output style before Claude Code launches.
-        
+
         This method ensures the output style is set to "Claude MPM" on startup
         by deploying the style file and updating Claude Code settings.
         Only works for Claude Code >= 1.0.83.
         """
         try:
             from claude_mpm.core.output_style_manager import OutputStyleManager
-            
+
             # Create OutputStyleManager instance
             output_style_manager = OutputStyleManager()
-            
+
             # Check if Claude Code supports output styles
             if not output_style_manager.supports_output_styles():
                 self.logger.debug(
@@ -756,48 +717,59 @@ Use these agents to delegate specialized work via the Task tool.
                     "does not support output styles (requires >= 1.0.83)"
                 )
                 return
-            
+
             # Check if output style is already deployed and active
             settings_file = Path.home() / ".claude" / "settings.json"
             if settings_file.exists():
                 try:
                     import json
+
                     settings = json.loads(settings_file.read_text())
                     if settings.get("activeOutputStyle") == "claude-mpm":
                         # Already active, check if file exists
-                        output_style_file = Path.home() / ".claude" / "output-styles" / "claude-mpm.md"
+                        output_style_file = (
+                            Path.home() / ".claude" / "output-styles" / "claude-mpm.md"
+                        )
                         if output_style_file.exists():
-                            self.logger.debug("Output style 'Claude MPM' already deployed and active")
+                            self.logger.debug(
+                                "Output style 'Claude MPM' already deployed and active"
+                            )
                             return
                 except Exception:
                     pass  # Continue with deployment if we can't read settings
-            
+
             # Read the OUTPUT_STYLE.md content if it exists
-            output_style_path = Path(__file__).parent.parent / "agents" / "OUTPUT_STYLE.md"
-            
+            output_style_path = (
+                Path(__file__).parent.parent / "agents" / "OUTPUT_STYLE.md"
+            )
+
             if output_style_path.exists():
                 # Use existing OUTPUT_STYLE.md content
                 output_style_content = output_style_path.read_text()
                 self.logger.debug("Using existing OUTPUT_STYLE.md content")
             else:
                 # Extract output style content from framework instructions
-                output_style_content = output_style_manager.extract_output_style_content()
+                output_style_content = (
+                    output_style_manager.extract_output_style_content()
+                )
                 self.logger.debug("Extracted output style from framework instructions")
-            
+
             # Deploy the output style
             deployed = output_style_manager.deploy_output_style(output_style_content)
-            
+
             if deployed:
-                self.logger.info("✅ Output style 'Claude MPM' deployed and activated on startup")
+                self.logger.info(
+                    "✅ Output style 'Claude MPM' deployed and activated on startup"
+                )
                 if self.project_logger:
                     self.project_logger.log_system(
                         "Output style 'Claude MPM' deployed and activated on startup",
                         level="INFO",
-                        component="output_style"
+                        component="output_style",
                     )
             else:
                 self.logger.warning("Failed to deploy output style")
-                
+
         except ImportError as e:
             self.logger.warning(f"Could not import OutputStyleManager: {e}")
         except Exception as e:
@@ -806,8 +778,8 @@ Use these agents to delegate specialized work via the Task tool.
             if self.project_logger:
                 self.project_logger.log_system(
                     f"Output style deployment error: {e}",
-                    level="WARNING", 
-                    component="output_style"
+                    level="WARNING",
+                    component="output_style",
                 )
 
     def _launch_subprocess_interactive(self, cmd: list, env: dict):

claude_mpm/core/config.py

@@ -37,12 +37,14 @@ class Config:
 
     _instance = None
     _initialized = False
-    _success_logged = False  # Class-level flag to track if success message was already logged
+    _success_logged = (
+        False  # Class-level flag to track if success message was already logged
+    )
     _lock = threading.Lock()  # Thread safety for singleton initialization
 
     def __new__(cls, *args, **kwargs):
         """Implement singleton pattern to ensure single configuration instance.
-        
+
         WHY: Configuration was being loaded 11 times during startup, once for each service.
         This singleton pattern ensures configuration is loaded only once and reused.
         Thread-safe implementation prevents race conditions during concurrent initialization.
@@ -54,7 +56,9 @@ class Config:
                     cls._instance = super().__new__(cls)
                     logger.info("Creating new Config singleton instance")
                 else:
-                    logger.debug("Reusing existing Config singleton instance (concurrent init)")
+                    logger.debug(
+                        "Reusing existing Config singleton instance (concurrent init)"
+                    )
         else:
             logger.debug("Reusing existing Config singleton instance")
         return cls._instance
@@ -79,23 +83,25 @@ class Config:
             logger.debug("Config already initialized, skipping re-initialization")
             # If someone tries to load a different config file after initialization,
             # log a debug message but don't reload
-            if config_file and str(config_file) != getattr(self, '_loaded_from', None):
+            if config_file and str(config_file) != getattr(self, "_loaded_from", None):
                 logger.debug(
                     f"Ignoring config_file parameter '{config_file}' - "
                     f"configuration already loaded from '{getattr(self, '_loaded_from', 'defaults')}'"
                 )
             return
-        
+
         # Thread-safe initialization - acquire lock for ENTIRE initialization process
         with Config._lock:
             # Double-check pattern - check again inside the lock
             if Config._initialized:
-                logger.debug("Config already initialized (concurrent), skipping re-initialization")
+                logger.debug(
+                    "Config already initialized (concurrent), skipping re-initialization"
+                )
                 return
-            
+
             Config._initialized = True
             logger.info("Initializing Config singleton for the first time")
-            
+
             # Initialize instance variables inside the lock to ensure thread safety
             self._config: Dict[str, Any] = {}
             self._env_prefix = env_prefix
@@ -121,7 +127,9 @@ class Config:
                 if default_config.exists():
                     self.load_file(default_config, is_initial_load=True)
                     self._loaded_from = str(default_config)
-                elif (alt_config := Path.cwd() / ".claude-mpm" / "configuration.yml").exists():
+                elif (
+                    alt_config := Path.cwd() / ".claude-mpm" / "configuration.yml"
+                ).exists():
                     # Also try .yml extension (using walrus operator for cleaner code)
                     self.load_file(alt_config, is_initial_load=True)
                     self._loaded_from = str(alt_config)
@@ -133,21 +141,27 @@ class Config:
             # Apply defaults
             self._apply_defaults()
 
-    def load_file(self, file_path: Union[str, Path], is_initial_load: bool = True) -> None:
+    def load_file(
+        self, file_path: Union[str, Path], is_initial_load: bool = True
+    ) -> None:
         """Load configuration from file with enhanced error handling.
 
         WHY: Configuration loading failures can cause silent issues. We need
         to provide clear, actionable error messages to help users fix problems.
-        
+
         Args:
             file_path: Path to the configuration file
             is_initial_load: Whether this is the initial configuration load (for logging control)
         """
         file_path = Path(file_path)
-        
+
         # Check if we've already loaded from this exact file to prevent duplicate messages
-        if hasattr(self, '_actual_loaded_file') and self._actual_loaded_file == str(file_path):
-            logger.debug(f"Configuration already loaded from {file_path}, skipping reload")
+        if hasattr(self, "_actual_loaded_file") and self._actual_loaded_file == str(
+            file_path
+        ):
+            logger.debug(
+                f"Configuration already loaded from {file_path}, skipping reload"
+            )
             return
 
         if not file_path.exists():
@@ -177,7 +191,7 @@ class Config:
                 self._config = self._config_mgr.merge_configs(self._config, file_config)
                 # Track that we've successfully loaded from this file
                 self._actual_loaded_file = str(file_path)
-                
+
                 # Only log success message once using class-level flag to avoid duplicate messages
                 # Check if we should log success message (thread-safe for reads after initialization)
                 if is_initial_load:
@@ -185,10 +199,14 @@ class Config:
                         # Set flag IMMEDIATELY before logging to prevent any possibility of duplicate
                         # messages. No lock needed here since we're already inside __init__ lock
                         Config._success_logged = True
-                        logger.info(f"✓ Successfully loaded configuration from {file_path}")
+                        logger.info(
+                            f"✓ Successfully loaded configuration from {file_path}"
+                        )
                     else:
                         # Configuration already successfully loaded before, just debug log
-                        logger.debug(f"Configuration already loaded, skipping success message for {file_path}")
+                        logger.debug(
+                            f"Configuration already loaded, skipping success message for {file_path}"
+                        )
                 else:
                     # Not initial load (shouldn't happen in normal flow, but handle gracefully)
                     logger.debug(f"Configuration reloaded from {file_path}")
@@ -225,7 +243,7 @@ class Config:
             logger.info("TIP: Validate your JSON at https://jsonlint.com/")
             self._config["_load_error"] = str(e)
 
-        except (OSError, IOError, PermissionError) as e:
+        except (OSError, PermissionError) as e:
             raise FileOperationError(
                 f"Failed to read configuration file: {e}",
                 context={
@@ -285,15 +303,14 @@ class Config:
         # Boolean conversion
         if value.lower() in ("true", "yes", "1", "on"):
             return True
-        elif value.lower() in ("false", "no", "0", "off"):
+        if value.lower() in ("false", "no", "0", "off"):
             return False
 
         # Numeric conversion
         try:
             if "." in value:
                 return float(value)
-            else:
-                return int(value)
+            return int(value)
         except ValueError:
             pass
 
@@ -580,7 +597,7 @@ class Config:
 
             logger.info(f"Configuration saved to {file_path}")
 
-        except (OSError, IOError, PermissionError) as e:
+        except (OSError, PermissionError) as e:
             raise FileOperationError(
                 f"Failed to write configuration file: {e}",
                 context={
@@ -809,7 +826,7 @@ class Config:
             if "enabled" in memory_config and not isinstance(
                 memory_config["enabled"], bool
             ):
-                errors.append(f"memory.enabled must be boolean")
+                errors.append("memory.enabled must be boolean")
 
             # Check limits
             limits = memory_config.get("limits", {})
@@ -850,7 +867,7 @@ class Config:
         """
         is_valid, errors, warnings = self.validate_configuration()
 
-        status = {
+        return {
             "valid": is_valid,
             "errors": errors,
             "warnings": warnings,
@@ -862,16 +879,14 @@ class Config:
             "memory_enabled": self.get("memory.enabled", False),
         }
 
-        return status
-
     def __repr__(self) -> str:
         """String representation of configuration."""
         return f"<Config({len(self._config)} keys)>"
-    
+
     @classmethod
     def reset_singleton(cls):
         """Reset the singleton instance (mainly for testing purposes).
-        
+
         WHY: During testing, we may need to reset the singleton to test different
         configurations. This method allows controlled reset of the singleton state.
         """

claude_mpm/core/config_aliases.py

@@ -15,7 +15,6 @@ Aliases are stored in ~/.claude-mpm/config_aliases.json
 
 import json
 import logging
-import os
 from typing import Dict, List, Optional, Tuple
 
 from ..utils.config_manager import ConfigurationManager
@@ -27,26 +26,18 @@ logger = logging.getLogger(__name__)
 class ConfigAliasError(Exception):
     """Base exception for configuration alias errors."""
 
-    pass
-
 
 class AliasNotFoundError(ConfigAliasError):
     """Raised when attempting to resolve a non-existent alias."""
 
-    pass
-
 
 class DuplicateAliasError(ConfigAliasError):
     """Raised when attempting to create an alias that already exists."""
 
-    pass
-
 
 class InvalidDirectoryError(ConfigAliasError):
     """Raised when a directory path is invalid or cannot be created."""
 
-    pass
-
 
 class ConfigAliasManager:
     """