claude-mpm 4.5.8__py3-none-any.whl → 4.5.12__py3-none-any.whl

claude_mpm/core/file_utils.py

@@ -80,8 +80,8 @@ def safe_path_join(*parts: Union[str, Path]) -> Path:
     # Ensure the resolved path is under the base path
     try:
         resolved.relative_to(base)
-    except ValueError:
-        raise ValueError(f"Path traversal detected: {path}")
+    except ValueError as e:
+        raise ValueError(f"Path traversal detected: {path}") from e
 
     return resolved
 
@@ -142,7 +142,7 @@ def safe_read(
     """Safely read a file with error handling.
 
     Replaces the common pattern:
-        with open(file, 'r') as f:
+        with file.open('r') as f:
             content = f.read()
 
     Args:
@@ -641,7 +641,7 @@ def file_lock(filepath: Union[str, Path], timeout: float = 5.0):
                 if e.errno != errno.EAGAIN:
                     raise
                 if time.time() - start_time > timeout:
-                    raise TimeoutError(f"Could not acquire lock for {filepath}")
+                    raise TimeoutError(f"Could not acquire lock for {filepath}") from e
                 time.sleep(0.1)
 
         yield lock_handle
@@ -724,7 +724,7 @@ def get_file_hash(
 
     try:
         hasher = hashlib.new(algorithm)
-        with open(filepath, "rb") as f:
+        with filepath.open("rb") as f:
             for chunk in iter(lambda: f.read(8192), b""):
                 hasher.update(chunk)
         return hasher.hexdigest()

claude_mpm/core/framework/formatters/capability_generator.py

@@ -154,7 +154,7 @@ class CapabilityGenerator:
             Dictionary with agent metadata or None
         """
         try:
-            with open(agent_file) as f:
+            with agent_file.open() as f:
                 content = f.read()
 
             # Default values
@@ -244,7 +244,7 @@ class CapabilityGenerator:
             template_file = templates_dir / f"{agent_name}.json"
 
             if template_file.exists():
-                with open(template_file) as f:
+                with template_file.open() as f:
                     template_data = json.load(f)
                     return template_data.get("routing")
 
@@ -262,7 +262,7 @@ class CapabilityGenerator:
                 if alt_name != agent_name:
                     alt_file = templates_dir / f"{alt_name}.json"
                     if alt_file.exists():
-                        with open(alt_file) as f:
+                        with alt_file.open() as f:
                             template_data = json.load(f)
                             return template_data.get("routing")
 
@@ -310,7 +310,7 @@ class CapabilityGenerator:
             template_file = templates_dir / f"{agent_name}.json"
 
             if template_file.exists():
-                with open(template_file) as f:
+                with template_file.open() as f:
                     template_data = json.load(f)
                     return template_data.get("memory_routing")
 
@@ -330,7 +330,7 @@ class CapabilityGenerator:
                 if alt_name != agent_name:
                     alt_file = templates_dir / f"{alt_name}.json"
                     if alt_file.exists():
-                        with open(alt_file) as f:
+                        with alt_file.open() as f:
                             template_data = json.load(f)
                             return template_data.get("memory_routing")
 

claude_mpm/core/framework/loaders/agent_loader.py

@@ -134,7 +134,7 @@ class AgentLoader:
 
             for json_file in template_dir.glob("*.json"):
                 try:
-                    with open(json_file) as f:
+                    with json_file.open() as f:
                         template_data = json.load(f)
 
                     # Extract agent metadata

claude_mpm/core/framework/processors/metadata_processor.py

@@ -55,7 +55,7 @@ class MetadataProcessor:
             Dictionary with agent metadata or None
         """
         try:
-            with open(agent_file) as f:
+            with agent_file.open() as f:
                 content = f.read()
 
             # Default values

claude_mpm/core/framework/processors/template_processor.py

@@ -89,7 +89,7 @@ class TemplateProcessor:
         # Try exact match first
         template_file = templates_dir / f"{agent_name}.json"
         if template_file.exists():
-            with open(template_file) as f:
+            with template_file.open() as f:
                 return json.load(f)
 
         # Try alternative naming variations
@@ -97,7 +97,7 @@ class TemplateProcessor:
         for alt_name in alternative_names:
             alt_file = templates_dir / f"{alt_name}.json"
             if alt_file.exists():
-                with open(alt_file) as f:
+                with alt_file.open() as f:
                     return json.load(f)
 
         return None
@@ -218,7 +218,7 @@ class TemplateProcessor:
 
             for json_file in template_dir.glob("*.json"):
                 try:
-                    with open(json_file) as f:
+                    with json_file.open() as f:
                         template_data = json.load(f)
 
                     agent_metadata = self.extract_metadata(template_data)

claude_mpm/core/framework_loader.py

@@ -504,9 +504,9 @@ class FrameworkLoader:
             metadata["instructions_length"] = len(instructions)
 
             if loop.is_running():
-                asyncio.create_task(
+                _task = asyncio.create_task(  # noqa: RUF006
                     log_manager.log_prompt("system_prompt", instructions, metadata)
-                )
+                )  # Fire-and-forget logging
             else:
                 loop.run_until_complete(
                     log_manager.log_prompt("system_prompt", instructions, metadata)

claude_mpm/core/log_manager.py

@@ -122,6 +122,13 @@ class LogManager:
         if run_cleanup_on_startup is None:
             return  # Cleanup utility not available
 
+        # Check environment variable to skip cleanup (for configure command)
+        import os
+
+        if os.environ.get("CLAUDE_MPM_SKIP_CLEANUP", "0") == "1":
+            logger.debug("Startup cleanup skipped (CLAUDE_MPM_SKIP_CLEANUP=1)")
+            return
+
         try:
             # Get cleanup configuration
             cleanup_config = self.config.get("log_cleanup", {})
@@ -535,12 +542,12 @@ class LogManager:
 
                 if extension == ".json":
                     # JSON files also get structured metadata for consistency
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         json.dump(data, f, indent=2, ensure_ascii=False)
                 # For markdown or text files
                 elif isinstance(data, dict):
                     # Write as formatted markdown with metadata
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         f.write("---\n")
                         f.write(f"timestamp: {data.get('timestamp', 'unknown')}\n")
                         f.write(f"type: {data.get('type', 'unknown')}\n")
@@ -552,7 +559,7 @@ class LogManager:
                         f.write(data.get("content", ""))
                 else:
                     # Write content directly
-                    with open(file_path, "w", encoding="utf-8") as f:
+                    with file_path.open("w", encoding="utf-8") as f:
                         f.write(str(data))
             except Exception as e:
                 logger.error(f"Failed to write {file_path}: {e}")
@@ -581,7 +588,7 @@ class LogManager:
 
         def write_task():
             try:
-                with open(log_file, "a", encoding="utf-8") as f:
+                with log_file.open("a", encoding="utf-8") as f:
                     f.write(log_entry)
             except Exception as e:
                 logger.error(f"Failed to write log: {e}")

claude_mpm/core/logger.py

@@ -526,7 +526,7 @@ class ProjectLogger:
             self.dirs["logs_system"]
             / f"{datetime.now(timezone.utc).strftime('%Y%m%d')}.jsonl"
         )
-        with open(log_file, "a") as f:
+        with log_file.open("a") as f:
             f.write(json.dumps(log_entry) + "\n")
 
     def log_agent_invocation(
@@ -580,7 +580,7 @@ class ProjectLogger:
         daily_log = (
             agent_log_dir / f"{datetime.now(timezone.utc).strftime('%Y%m%d')}.jsonl"
         )
-        with open(daily_log, "a") as f:
+        with daily_log.open("a") as f:
             f.write(json.dumps(log_entry) + "\n")
 
     def get_session_summary(self) -> Dict[str, Any]:

claude_mpm/core/optimized_startup.py

@@ -227,7 +227,7 @@ class OptimizedStartup:
         """Parse configuration file."""
         import yaml
 
-        with open(path) as f:
+        with path.open() as f:
             return yaml.safe_load(f) or {}
 
     def _store_config(self, config: Dict[str, Any]):

claude_mpm/core/output_style_manager.py

@@ -42,7 +42,7 @@ class OutputStyleManager:
             Path(__file__).parent.parent / "agents" / "OUTPUT_STYLE.md"
         )
 
-    def _detect_claude_version(self) -> Optional[str]:  # noqa: PLR0911
+    def _detect_claude_version(self) -> Optional[str]:
         """
         Detect Claude Code version by running 'claude --version'.
         Uses global cache to avoid duplicate detection and logging.

claude_mpm/core/service_registry.py

@@ -160,10 +160,10 @@ class ServiceRegistry:
             try:
                 # Use the enhanced container's named resolution
                 return self.container.get(BaseService, name=service_type)
-            except Exception:
+            except Exception as e:
                 # Fall back to looking up class and resolving
                 if service_type not in self._services:
-                    raise KeyError(f"Service '{service_type}' not registered")
+                    raise KeyError(f"Service '{service_type}' not registered") from e
                 service_class = self._services[service_type]
                 return self.container.get(service_class)
         else:

claude_mpm/core/session_manager.py

@@ -187,7 +187,7 @@ class SessionManager:
         """Save sessions to disk."""
         session_file = self.session_dir / "active_sessions.json"
         try:
-            with open(session_file, "w") as f:
+            with session_file.open("w") as f:
                 json.dump(self.active_sessions, f, indent=2)
         except Exception as e:
             logger.error(f"Failed to save sessions: {e}")
@@ -197,7 +197,7 @@ class SessionManager:
         session_file = self.session_dir / "active_sessions.json"
         if session_file.exists():
             try:
-                with open(session_file) as f:
+                with session_file.open() as f:
                     self.active_sessions = json.load(f)
 
                 # Clean up old sessions on load (archive by default)
@@ -286,7 +286,7 @@ class SessionManager:
             backup_path = archive_dir / backup_name
 
             # Compress and backup current file
-            with open(claude_json_path, "rb") as f_in:
+            with claude_json_path.open("rb") as f_in:
                 with gzip.open(backup_path, "wb") as f_out:
                     shutil.copyfileobj(f_in, f_out)
 

claude_mpm/core/shared/config_loader.py

@@ -228,7 +228,7 @@ class ConfigLoader:
         try:
             import yaml
 
-            with open(config_file) as f:
+            with config_file.open() as f:
                 if config_file.suffix.lower() in (".yaml", ".yml"):
                     return yaml.safe_load(f) or {}
                 # Try JSON as fallback

claude_mpm/core/socketio_pool.py

@@ -594,9 +594,9 @@ class SocketIOConnectionPool:
                 timeout=2.0,
             )
 
-        except asyncio.TimeoutError:
+        except asyncio.TimeoutError as e:
             self.logger.debug("Socket.IO connection timeout")
-            raise TimeoutError("Socket.IO connection timeout")
+            raise TimeoutError("Socket.IO connection timeout") from e
         except Exception as e:
             self.logger.debug(f"Client connection failed: {e}")
             raise

claude_mpm/core/unified_agent_registry.py

@@ -728,7 +728,7 @@ class UnifiedAgentRegistry:
             },
         }
 
-        with open(output_path, "w") as f:
+        with output_path.open("w") as f:
             json.dump(export_data, f, indent=2)
 
         logger.info(f"Exported {len(self.registry)} agents to {output_path}")
@@ -737,7 +737,7 @@ class UnifiedAgentRegistry:
         """Import registry from JSON file."""
         input_path = Path(input_path)
 
-        with open(input_path) as f:
+        with input_path.open() as f:
             data = json.load(f)
 
         # Clear current registry

claude_mpm/core/unified_config.py

@@ -436,7 +436,7 @@ class ConfigurationService:
                 if config_path.exists():
                     import yaml
 
-                    with open(config_path) as f:
+                    with config_path.open() as f:
                         file_config = yaml.safe_load(f) or {}
                     config_data.update(file_config)
                     break
@@ -448,7 +448,7 @@ class ConfigurationService:
             raise ConfigurationError(
                 f"Failed to load configuration: {e}",
                 context={"error_type": type(e).__name__},
-            )
+            ) from e
 
     @property
     def config(self) -> UnifiedConfig:
@@ -515,7 +515,7 @@ class ConfigurationService:
                 return True
             raise ConfigurationError("Invalid SocketIO port range")
         except Exception as e:
-            raise ConfigurationError(f"Configuration validation failed: {e}")
+            raise ConfigurationError(f"Configuration validation failed: {e}") from e
 
     def export_to_file(self, file_path: Union[str, Path], format: str = "yaml") -> None:
         """
@@ -531,12 +531,12 @@ class ConfigurationService:
             if format.lower() == "yaml":
                 import yaml
 
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     yaml.dump(self._config.dict(), f, default_flow_style=False)
             elif format.lower() == "json":
                 import json
 
-                with open(file_path, "w") as f:
+                with file_path.open("w") as f:
                     json.dump(self._config.dict(), f, indent=2)
             else:
                 raise ConfigurationError(f"Unsupported export format: {format}")
@@ -545,4 +545,4 @@ class ConfigurationService:
             raise ConfigurationError(
                 f"Failed to export configuration: {e}",
                 context={"file_path": str(file_path), "format": format},
-            )
+            ) from e

claude_mpm/core/unified_paths.py

@@ -167,7 +167,7 @@ class PathContext:
 
     @staticmethod
     @lru_cache(maxsize=1)
-    def detect_deployment_context() -> DeploymentContext:  # noqa: PLR0911
+    def detect_deployment_context() -> DeploymentContext:
         """Detect the current deployment context.
 
         Priority order:
@@ -396,7 +396,7 @@ class UnifiedPathManager:
                     return current
                 current = current.parent
 
-            raise FileNotFoundError("Could not determine framework root")
+            raise FileNotFoundError("Could not determine framework root") from None
 
     @property
     @lru_cache(maxsize=1)

claude_mpm/dashboard/api/simple_directory.py

@@ -129,7 +129,7 @@ def has_code_files(directory_path, max_depth=5, current_depth=0):
     return False
 
 
-def should_show_item(item_name, item_path, is_directory):  # noqa: PLR0911
+def should_show_item(item_name, item_path, is_directory):
     """Determine if an item should be shown based on filtering rules"""
     # Always hide system files
     if item_name in {".DS_Store", "Thumbs.db", "desktop.ini"}:

claude_mpm/generators/agent_profile_generator.py

@@ -29,7 +29,7 @@ class AgentProfileGenerator:
         if not self.template_path.exists():
             raise FileNotFoundError(f"Template not found: {self.template_path}")
 
-        with open(self.template_path) as f:
+        with self.template_path.open() as f:
             return yaml.safe_load(f)
 
     def generate_profile(self, config: Dict[str, Any]) -> str:

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -284,11 +284,11 @@ class EventHandlers:
                 # Log the agent prompt asynchronously
                 try:
                     loop = asyncio.get_running_loop()
-                    asyncio.create_task(
+                    _task = asyncio.create_task(  # noqa: RUF006
                         log_manager.log_prompt(
                             f"agent_{agent_type}", prompt_content, metadata
                         )
-                    )
+                    )  # Fire-and-forget logging (ephemeral hook process)
                 except RuntimeError:
                     # No running loop, create one
                     loop = asyncio.new_event_loop()

claude_mpm/hooks/claude_hooks/installer.py

@@ -428,7 +428,7 @@ main "$@"
             return
 
         try:
-            with open(self.old_settings_file) as f:
+            with self.old_settings_file.open() as f:
                 old_settings = json.load(f)
 
             # Remove hooks section if present
@@ -437,7 +437,7 @@ main "$@"
                 self.logger.info(f"Removing hooks from {self.old_settings_file}")
 
                 # Write back the cleaned settings
-                with open(self.old_settings_file, "w") as f:
+                with self.old_settings_file.open("w") as f:
                     json.dump(old_settings, f, indent=2)
 
                 self.logger.info(f"Cleaned up hooks from {self.old_settings_file}")
@@ -450,7 +450,7 @@ main "$@"
 
         # Load existing settings.json or create new
         if self.settings_file.exists():
-            with open(self.settings_file) as f:
+            with self.settings_file.open() as f:
                 settings = json.load(f)
             self.logger.info(f"Found existing Claude settings at {self.settings_file}")
         else:
@@ -490,7 +490,7 @@ main "$@"
             ]
 
         # Write settings to settings.json
-        with open(self.settings_file, "w") as f:
+        with self.settings_file.open("w") as f:
             json.dump(settings, f, indent=2)
 
         self.logger.info(f"Updated Claude settings at {self.settings_file}")
@@ -564,7 +564,7 @@ main "$@"
             issues.append(f"Claude settings file not found at {self.settings_file}")
         else:
             try:
-                with open(self.settings_file) as f:
+                with self.settings_file.open() as f:
                     settings = json.load(f)
 
                 if "hooks" not in settings:
@@ -615,7 +615,7 @@ main "$@"
             # Remove from Claude settings (both old and new locations)
             for settings_path in [self.settings_file, self.old_settings_file]:
                 if settings_path.exists():
-                    with open(settings_path) as f:
+                    with settings_path.open() as f:
                         settings = json.load(f)
 
                     if "hooks" in settings:
@@ -655,7 +655,7 @@ main "$@"
                             del settings["hooks"]
 
                         # Write back settings
-                        with open(settings_path, "w") as f:
+                        with settings_path.open("w") as f:
                             json.dump(settings, f, indent=2)
 
                         self.logger.info(f"Removed hooks from {settings_path}")
@@ -709,7 +709,7 @@ main "$@"
 
         if self.settings_file.exists():
             try:
-                with open(self.settings_file) as f:
+                with self.settings_file.open() as f:
                     settings = json.load(f)
                     if "hooks" in settings:
                         status["configured_events"] = list(settings["hooks"].keys())
@@ -720,7 +720,7 @@ main "$@"
         # Also check old settings file
         if self.old_settings_file.exists():
             try:
-                with open(self.old_settings_file) as f:
+                with self.old_settings_file.open() as f:
                     old_settings = json.load(f)
                     if "hooks" in old_settings:
                         status["old_file_has_hooks"] = True

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -10,28 +10,27 @@ import os
 import re
 import sys
 from datetime import datetime, timezone
-from typing import Optional
+from typing import Any, Optional
 
 # Debug mode
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
 # Response tracking integration
-RESPONSE_TRACKING_AVAILABLE = False
-try:
-    from claude_mpm.services.response_tracker import ResponseTracker
-
-    RESPONSE_TRACKING_AVAILABLE = True
-except Exception as e:
-    if DEBUG:
-        print(f"Response tracking not available: {e}", file=sys.stderr)
-    RESPONSE_TRACKING_AVAILABLE = False
+# NOTE: ResponseTracker import moved to _initialize_response_tracking() for lazy loading
+# This prevents unnecessary import of base_agent_loader and other heavy dependencies
+# when hooks don't need response tracking
+RESPONSE_TRACKING_AVAILABLE = (
+    True  # Assume available, will check on actual initialization
+)
 
 
 class ResponseTrackingManager:
     """Manager for response tracking functionality."""
 
     def __init__(self):
-        self.response_tracker: Optional[ResponseTracker] = None
+        self.response_tracker: Optional[Any] = (
+            None  # Type hint changed to Any for lazy import
+        )
         self.response_tracking_enabled = False
         self.track_all_interactions = (
             False  # Track all Claude interactions, not just delegations
@@ -49,8 +48,14 @@ class ResponseTrackingManager:
 
         DESIGN DECISION: Check configuration to allow enabling/disabling
         response tracking without code changes.
+
+        NOTE: ResponseTracker is imported lazily here to avoid loading
+        base_agent_loader and other heavy dependencies unless actually needed.
         """
         try:
+            # Lazy import of ResponseTracker to avoid unnecessary dependency loading
+            from claude_mpm.services.response_tracker import ResponseTracker
+
             # Create configuration with optional config file using ConfigLoader
             config_file = os.environ.get("CLAUDE_PM_CONFIG_FILE")
             from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -26,14 +26,8 @@ except ImportError:
     REQUESTS_AVAILABLE = False
     requests = None
 
-# Import high-performance event emitter
-try:
-    from claude_mpm.services.monitor.event_emitter import get_event_emitter
-
-    EVENT_EMITTER_AVAILABLE = True
-except ImportError:
-    EVENT_EMITTER_AVAILABLE = False
-    get_event_emitter = None
+# Import high-performance event emitter - lazy loaded in _async_emit()
+# to reduce hook handler initialization time by ~85% (792ms -> minimal)
 
 # Import EventNormalizer for consistent event formatting
 try:
@@ -82,6 +76,9 @@ class ConnectionManagerService:
         # For backward compatibility with tests
         self.connection_pool = None  # No longer used
 
+        # Track async emit tasks to prevent garbage collection
+        self._emit_tasks: set = set()
+
         if DEBUG:
             print(
                 f"✅ HTTP connection manager initialized - endpoint: {self.http_endpoint}",
@@ -137,9 +134,6 @@ class ConnectionManagerService:
 
     def _try_async_emit(self, namespace: str, event: str, data: dict) -> bool:
         """Try to emit event using high-performance async emitter."""
-        if not EVENT_EMITTER_AVAILABLE:
-            return False
-
         try:
             # Run async emission in the current event loop or create one
             loop = None
@@ -150,8 +144,10 @@ class ConnectionManagerService:
                 pass
 
             if loop:
-                # We're in an async context, create a task
-                loop.create_task(self._async_emit(namespace, event, data))
+                # We're in an async context, create a task with tracking
+                task = loop.create_task(self._async_emit(namespace, event, data))
+                self._emit_tasks.add(task)
+                task.add_done_callback(self._emit_tasks.discard)
                 # Don't wait for completion to maintain low latency
                 if DEBUG:
                     print(f"✅ Async emit scheduled: {event}", file=sys.stderr)
@@ -170,8 +166,15 @@ class ConnectionManagerService:
     async def _async_emit(self, namespace: str, event: str, data: dict) -> bool:
         """Async helper for event emission."""
         try:
+            # Lazy load event emitter to reduce initialization overhead
+            from claude_mpm.services.monitor.event_emitter import get_event_emitter
+
             emitter = await get_event_emitter()
             return await emitter.emit_event(namespace, "claude_event", data)
+        except ImportError:
+            if DEBUG:
+                print("⚠️ Event emitter not available", file=sys.stderr)
+            return False
         except Exception as e:
             if DEBUG:
                 print(f"⚠️ Async emitter error: {e}", file=sys.stderr)

claude_mpm/hooks/claude_hooks/tool_analysis.py

@@ -138,7 +138,7 @@ def summarize_todos(todos: list) -> dict:
     }
 
 
-def classify_tool_operation(tool_name: str, tool_input: dict) -> str:  # noqa: PLR0911
+def classify_tool_operation(tool_name: str, tool_input: dict) -> str:
     """Classify the type of operation being performed."""
     if tool_name in ["Read", "LS", "Glob", "Grep", "NotebookRead"]:
         return "read"
@@ -155,7 +155,7 @@ def classify_tool_operation(tool_name: str, tool_input: dict) -> str:  # noqa: P
     return "other"
 
 
-def assess_security_risk(tool_name: str, tool_input: dict) -> str:  # noqa: PLR0911
+def assess_security_risk(tool_name: str, tool_input: dict) -> str:
     """Assess the security risk level of the tool operation."""
     if tool_name == "Bash":
         command = tool_input.get("command", "").lower()

claude_mpm/hooks/memory_integration_hook.py

@@ -234,7 +234,7 @@ class MemoryPostDelegationHook(PostDelegationHook):
             "context": "context",  # Current Technical Context
         }
 
-    def execute(self, context: HookContext) -> HookResult:  # noqa: PLR0911
+    def execute(self, context: HookContext) -> HookResult:
         """Extract and store learnings from delegation result.
 
         WHY: Capturing learnings immediately after task completion ensures we

claude_mpm/hooks/validation_hooks.py

@@ -118,7 +118,7 @@ async def validate_agent_dependencies(profile_path: Path) -> ValidationResult:
     result = ValidationResult(is_valid=True)
 
     try:
-        with open(profile_path) as f:
+        with profile_path.open() as f:
             profile_data = yaml.safe_load(f)
 
         # Check for circular dependencies