claude-mpm 4.3.19__py3-none-any.whl → 4.3.22__py3-none-any.whl

claude_mpm/services/response_tracker.py

@@ -18,14 +18,14 @@ DESIGN DECISIONS:
 - Handles agent name normalization for consistent tracking
 """
 
-import logging
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.config import Config
 from claude_mpm.core.shared.config_loader import ConfigLoader
 
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+logger = get_logger(__name__)
 
 
 class ResponseTracker:

claude_mpm/services/socketio/handlers/connection.py

@@ -11,8 +11,12 @@ import time
 from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional
 
+from claude_mpm.core.logging_utils import get_logger
+
 from .base import BaseEventHandler
 
+logger = get_logger(__name__)
+
 
 def timeout_handler(timeout_seconds: float = 5.0):
     """Decorator to add timeout protection to async handlers.
@@ -39,49 +43,26 @@ def timeout_handler(timeout_seconds: float = 5.0):
 
                 elapsed = time.time() - start_time
                 if elapsed > timeout_seconds * 0.8:  # Warn if close to timeout
-                    # Try to get logger from closure scope or fallback to print
-                    try:
-                        import logging
-
-                        logger = logging.getLogger(__name__)
-                        logger.warning(
-                            f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
-                            f"(close to {timeout_seconds}s timeout)"
-                        )
-                    except Exception:
-                        print(
-                            f"⚠️ Handler {handler_name} took {elapsed:.2f}s (close to {timeout_seconds}s timeout)"
-                        )
+                    logger.warning(
+                        f"⚠️ Handler {handler_name} took {elapsed:.2f}s "
+                        f"(close to {timeout_seconds}s timeout)"
+                    )
 
                 return result
 
             except asyncio.TimeoutError:
                 elapsed = time.time() - start_time
-                # Try to get logger from closure scope or fallback to print
-                try:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.error(
-                        f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
-                    )
-                except Exception:
-                    print(f"❌ Handler {handler_name} timed out after {elapsed:.2f}s")
+                logger.error(
+                    f"❌ Handler {handler_name} timed out after {elapsed:.2f}s"
+                )
 
                 return None
 
             except Exception as e:
                 elapsed = time.time() - start_time
-                # Try to get logger from closure scope or fallback to print
-                try:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.error(
-                        f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
-                    )
-                except Exception:
-                    print(f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}")
+                logger.error(
+                    f"❌ Handler {handler_name} failed after {elapsed:.2f}s: {e}"
+                )
                 raise
 
         return wrapper

claude_mpm/services/socketio/server/eventbus_integration.py

@@ -7,7 +7,6 @@ WHY this integration module:
 - Provides clean separation of concerns
 """
 
-import logging
 from datetime import datetime, timezone
 from typing import Optional
 
@@ -15,7 +14,8 @@ from claude_mpm.services.event_bus import EventBus
 from claude_mpm.services.event_bus.config import get_config
 from claude_mpm.services.event_bus.direct_relay import DirectSocketIORelay
 
-logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+logger = get_logger(__name__)
 
 
 class EventBusIntegration:

claude_mpm/services/version_control/version_parser.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 """
 Enhanced version parsing system with multiple source support and fallback mechanisms.
 
@@ -17,13 +15,17 @@ The system includes caching for performance and validation for data integrity.
 
 import contextlib
 import json
-import logging
 import re
 import subprocess
 from datetime import datetime, timedelta, timezone
 from functools import lru_cache
+from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+from claude_mpm.core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
 
 class VersionSource:
     """Enumeration of version sources with priority ordering."""
@@ -104,7 +106,6 @@ class EnhancedVersionParser:
         """
         self.project_root = project_root or Path.cwd()
         self.cache_ttl = cache_ttl
-        self.logger = logging.getLogger(__name__)
         self._cache: Dict[str, Tuple[datetime, any]] = {}
 
         # Compile regex patterns once for efficiency

claude_mpm/storage/state_storage.py

@@ -16,7 +16,6 @@ import fcntl
 import gzip
 import hashlib
 import json
-import logging
 import os
 import pickle
 import platform
@@ -39,7 +38,8 @@ class StateStorage:
         self.storage_dir.mkdir(parents=True, exist_ok=True)
 
         # Logging
-        self.logger = logging.getLogger(__name__)
+from claude_mpm.core.logging_utils import get_logger
+logger = get_logger(__name__)
 
         # File locking support (Unix-like systems)
         self.supports_locking = platform.system() != "Windows"

claude_mpm/utils/agent_dependency_loader.py

@@ -31,6 +31,22 @@ class AgentDependencyLoader:
     and being used, rather than all possible agents.
     """
 
+    # Optional database packages - if one fails, try alternatives
+    OPTIONAL_DB_PACKAGES = {
+        "mysqlclient": ["pymysql"],  # PyMySQL is a pure Python alternative
+        "psycopg2": ["psycopg2-binary"],  # Binary version doesn't require compilation
+        "cx_Oracle": [],  # No good alternative, mark as optional
+    }
+
+    # Packages that commonly fail compilation on certain platforms
+    COMPILATION_PRONE = [
+        "mysqlclient",  # Requires MySQL development headers
+        "psycopg2",  # Requires PostgreSQL development headers (use psycopg2-binary instead)
+        "cx_Oracle",  # Requires Oracle client libraries
+        "pycairo",  # Requires Cairo development headers
+        "lxml",  # Can fail if libxml2 dev headers missing
+    ]
+
     def __init__(self, auto_install: bool = False):
         """
         Initialize the agent dependency loader.
@@ -44,6 +60,7 @@ class AgentDependencyLoader:
         self.agent_dependencies: Dict[str, Dict] = {}
         self.missing_dependencies: Dict[str, List[str]] = {}
         self.checked_packages: Set[str] = set()
+        self.optional_failed: Dict[str, str] = {}  # Track optional packages that failed
         self.deployment_state_file = (
             Path.cwd() / ".claude" / "agents" / ".mpm_deployment_state"
         )
@@ -130,6 +147,11 @@ class AgentDependencyLoader:
                 self.checked_packages.add(package_name)
                 return True, "built-in"
 
+            # Check if this is an optional package that already failed
+            if package_name in self.optional_failed:
+                logger.debug(f"Skipping optional package {package_name} (previously failed)")
+                return True, "optional-skipped"
+
             # Try to import and check version
             try:
                 import importlib.metadata
@@ -147,6 +169,20 @@ class AgentDependencyLoader:
                     return False, version
 
                 except importlib.metadata.PackageNotFoundError:
+                    # Check if there's an alternative for this optional package
+                    if package_name in self.OPTIONAL_DB_PACKAGES:
+                        for alternative in self.OPTIONAL_DB_PACKAGES[package_name]:
+                            try:
+                                alt_version = importlib.metadata.version(alternative)
+                                logger.info(f"Using {alternative} as alternative to {package_name}")
+                                self.checked_packages.add(package_name)
+                                return True, f"{alternative}:{alt_version}"
+                            except importlib.metadata.PackageNotFoundError:
+                                continue
+                        # If no alternatives work, mark as optional failure
+                        self.optional_failed[package_name] = "No alternatives available"
+                        logger.warning(f"Optional package {package_name} not found, marking as optional")
+                        return True, "optional-not-found"
                     return False, None
 
             except ImportError:
@@ -162,6 +198,19 @@ class AgentDependencyLoader:
                     return False, version
 
                 except pkg_resources.DistributionNotFound:
+                    # Check alternatives for optional packages
+                    if package_name in self.OPTIONAL_DB_PACKAGES:
+                        for alternative in self.OPTIONAL_DB_PACKAGES[package_name]:
+                            try:
+                                alt_version = pkg_resources.get_distribution(alternative).version
+                                logger.info(f"Using {alternative} as alternative to {package_name}")
+                                self.checked_packages.add(package_name)
+                                return True, f"{alternative}:{alt_version}"
+                            except pkg_resources.DistributionNotFound:
+                                continue
+                        self.optional_failed[package_name] = "No alternatives available"
+                        logger.warning(f"Optional package {package_name} not found, marking as optional")
+                        return True, "optional-not-found"
                     return False, None
 
         except InvalidRequirement as e: