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

claude_mpm/utils/agent_dependency_loader.py

@@ -94,7 +94,7 @@ class AgentDependencyLoader:
                 config_file = config_dir / f"{agent_id}.json"
                 if config_file.exists():
                     try:
-                        with open(config_file, "r") as f:
+                        with open(config_file) as f:
                             config = json.load(f)
                             if "dependencies" in config:
                                 agent_dependencies[agent_id] = config["dependencies"]
@@ -141,11 +141,10 @@ class AgentDependencyLoader:
                     # Check if version satisfies requirement
                     if req.specifier.contains(version):
                         return True, version
-                    else:
-                        logger.debug(
-                            f"{package_name} {version} does not satisfy {req.specifier}"
-                        )
-                        return False, version
+                    logger.debug(
+                        f"{package_name} {version} does not satisfy {req.specifier}"
+                    )
+                    return False, version
 
                 except importlib.metadata.PackageNotFoundError:
                     return False, None
@@ -160,8 +159,7 @@ class AgentDependencyLoader:
 
                     if req.specifier.contains(version):
                         return True, version
-                    else:
-                        return False, version
+                    return False, version
 
                 except pkg_resources.DistributionNotFound:
                     return False, None
@@ -277,8 +275,6 @@ class AgentDependencyLoader:
             "re",
             "difflib",
             "textwrap",
-            "unicodedata",
-            "stringprep",
             "calendar",
             "locale",
             "gettext",
@@ -335,7 +331,11 @@ class AgentDependencyLoader:
         """
         try:
             result = subprocess.run(
-                ["which", command], capture_output=True, text=True, timeout=5
+                ["which", command],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
             )
             return result.returncode == 0
         except Exception:
@@ -374,15 +374,14 @@ class AgentDependencyLoader:
                         agent_result["python"]["satisfied"].append(dep_spec)
                         if dep_spec not in results["summary"]["satisfied_python"]:
                             results["summary"]["satisfied_python"].append(dep_spec)
-                    else:
-                        if version:  # Installed but wrong version
-                            agent_result["python"]["outdated"].append(
-                                f"{dep_spec} (have {version})"
-                            )
-                        else:  # Not installed
-                            agent_result["python"]["missing"].append(dep_spec)
-                            if dep_spec not in results["summary"]["missing_python"]:
-                                results["summary"]["missing_python"].append(dep_spec)
+                    elif version:  # Installed but wrong version
+                        agent_result["python"]["outdated"].append(
+                            f"{dep_spec} (have {version})"
+                        )
+                    else:  # Not installed
+                        agent_result["python"]["missing"].append(dep_spec)
+                        if dep_spec not in results["summary"]["missing_python"]:
+                            results["summary"]["missing_python"].append(dep_spec)
 
             # Check system dependencies
             if "system" in deps:
@@ -416,7 +415,6 @@ class AgentDependencyLoader:
         """
         import sys
 
-        current_version = f"{sys.version_info.major}.{sys.version_info.minor}"
         compatible = []
         incompatible = []
 
@@ -428,10 +426,10 @@ class AgentDependencyLoader:
 
                 # Known Python 3.13 incompatibilities
                 if sys.version_info >= (3, 13):
-                    if package_name in ["ydata-profiling", "pandas-profiling"]:
-                        incompatible.append(f"{dep} (requires Python <3.13)")
-                        continue
-                    elif package_name == "apache-airflow":
+                    if (
+                        package_name in ["ydata-profiling", "pandas-profiling"]
+                        or package_name == "apache-airflow"
+                    ):
                         incompatible.append(f"{dep} (requires Python <3.13)")
                         continue
 
@@ -532,10 +530,27 @@ class AgentDependencyLoader:
                 "Robust installer not available, falling back to simple installation"
             )
             try:
-                cmd = [sys.executable, "-m", "pip", "install"] + compatible
+                cmd = [sys.executable, "-m", "pip", "install"]
+
+                # Check for PEP 668 managed environment
+                import sysconfig
+
+                stdlib_path = sysconfig.get_path("stdlib")
+                marker_file = Path(stdlib_path) / "EXTERNALLY-MANAGED"
+                parent_marker = marker_file.parent.parent / "EXTERNALLY-MANAGED"
+
+                if marker_file.exists() or parent_marker.exists():
+                    logger.warning(
+                        "PEP 668 managed environment detected. "
+                        "Installing with --break-system-packages --user flags. "
+                        "Consider using a virtual environment instead."
+                    )
+                    cmd.extend(["--break-system-packages", "--user"])
+
+                cmd.extend(compatible)
 
                 result = subprocess.run(
-                    cmd, capture_output=True, text=True, timeout=300
+                    cmd, capture_output=True, text=True, timeout=300, check=False
                 )
 
                 if result.returncode == 0:
@@ -546,10 +561,9 @@ class AgentDependencyLoader:
                             f"Installed {len(compatible)} packages, skipped {len(incompatible)} incompatible",
                         )
                     return True, ""
-                else:
-                    error_msg = f"Installation failed: {result.stderr}"
-                    logger.error(error_msg)
-                    return False, error_msg
+                error_msg = f"Installation failed: {result.stderr}"
+                logger.error(error_msg)
+                return False, error_msg
 
             except Exception as e:
                 error_msg = f"Failed to install dependencies: {e}"
@@ -765,7 +779,7 @@ class AgentDependencyLoader:
             except Exception as e:
                 logger.debug(f"Could not hash agent file {agent_path}: {e}")
                 # Include error in hash to force recheck on next run
-                hash_obj.update(f"error:{agent_id}:{e}".encode("utf-8"))
+                hash_obj.update(f"error:{agent_id}:{e}".encode())
 
         return hash_obj.hexdigest()
 
@@ -780,7 +794,7 @@ class AgentDependencyLoader:
             return {}
 
         try:
-            with open(self.deployment_state_file, "r") as f:
+            with open(self.deployment_state_file) as f:
                 return json.load(f)
         except Exception as e:
             logger.debug(f"Could not load deployment state: {e}")

claude_mpm/utils/config_manager.py

@@ -6,7 +6,6 @@ configurations across different file formats (JSON, YAML, TOML).
 
 import json
 import os
-from functools import lru_cache
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
@@ -56,7 +55,7 @@ class ConfigurationManager:
         try:
             cache_key = self._get_cache_key(file_path)
             return self._cache.get(cache_key)
-        except (OSError, IOError):
+        except OSError:
             return None
 
     def _update_cache(self, file_path: Union[str, Path], config: Dict[str, Any]):
@@ -67,7 +66,7 @@ class ConfigurationManager:
         try:
             cache_key = self._get_cache_key(file_path)
             self._cache[cache_key] = config
-        except (OSError, IOError):
+        except OSError:
             pass
 
     def clear_cache(self):
@@ -100,7 +99,7 @@ class ConfigurationManager:
 
         logger.debug(f"Loading JSON configuration from {file_path}")
         try:
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, encoding="utf-8") as f:
                 config = json.load(f)
             self._update_cache(file_path, config)
             return config
@@ -143,7 +142,7 @@ class ConfigurationManager:
 
         logger.debug(f"Loading YAML configuration from {file_path}")
         try:
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, encoding="utf-8") as f:
                 config = yaml.safe_load(f) or {}
             self._update_cache(file_path, config)
             return config
@@ -186,7 +185,7 @@ class ConfigurationManager:
 
         logger.debug(f"Loading TOML configuration from {file_path}")
         try:
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(file_path, encoding="utf-8") as f:
                 config = toml.load(f)
             self._update_cache(file_path, config)
             return config
@@ -215,12 +214,11 @@ class ConfigurationManager:
 
         if suffix in [".json"]:
             return self.load_json(file_path)
-        elif suffix in [".yaml", ".yml"]:
+        if suffix in [".yaml", ".yml"]:
             return self.load_yaml(file_path)
-        elif suffix in [".toml"]:
+        if suffix in [".toml"]:
             return self.load_toml(file_path)
-        else:
-            raise ValueError(f"Unsupported configuration format: {suffix}")
+        raise ValueError(f"Unsupported configuration format: {suffix}")
 
     def save_json(
         self,
@@ -461,12 +459,11 @@ class ConfigurationManager:
                     result = result.replace(placeholder, env_value)
 
                 return result
-            elif isinstance(value, dict):
+            if isinstance(value, dict):
                 return {k: _interpolate_value(v) for k, v in value.items()}
-            elif isinstance(value, list):
+            if isinstance(value, list):
                 return [_interpolate_value(item) for item in value]
-            else:
-                return value
+            return value
 
         return _interpolate_value(config)
 

claude_mpm/utils/dependency_cache.py

@@ -66,7 +66,7 @@ class DependencyCache:
             return self._cache_data
 
         try:
-            with open(self.cache_file, "r") as f:
+            with open(self.cache_file) as f:
                 self._cache_data = json.load(f)
                 return self._cache_data
         except Exception as e:

claude_mpm/utils/dependency_manager.py

@@ -9,7 +9,6 @@ DESIGN DECISION: We use subprocess to install packages in the same environment
 that's running claude-mpm, respecting virtual environments and user setups.
 """
 
-import importlib
 import subprocess
 import sys
 from typing import List, Optional, Tuple
@@ -70,7 +69,7 @@ def install_packages(packages: List[str], logger=None) -> Tuple[bool, str]:
 
     try:
         # Use the same Python executable that's running this script
-        cmd = [sys.executable, "-m", "pip", "install"] + packages
+        cmd = [sys.executable, "-m", "pip", "install", *packages]
 
         logger.info(f"Installing packages: {packages}")
         logger.debug(f"Running command: {' '.join(cmd)}")
@@ -80,18 +79,18 @@ def install_packages(packages: List[str], logger=None) -> Tuple[bool, str]:
             cmd,
             capture_output=True,
             text=True,
-            timeout=300,  # 5 minute timeout for installation
+            timeout=300,
+            check=False,  # 5 minute timeout for installation
         )
 
         if result.returncode == 0:
             logger.info(f"Successfully installed packages: {packages}")
             return True, ""
-        else:
-            error_msg = f"pip install failed with return code {result.returncode}"
-            if result.stderr:
-                error_msg += f": {result.stderr.strip()}"
-            logger.error(error_msg)
-            return False, error_msg
+        error_msg = f"pip install failed with return code {result.returncode}"
+        if result.stderr:
+            error_msg += f": {result.stderr.strip()}"
+        logger.error(error_msg)
+        return False, error_msg
 
     except subprocess.TimeoutExpired:
         error_msg = "Package installation timed out after 5 minutes"
@@ -163,8 +162,7 @@ def ensure_socketio_dependencies(logger=None) -> Tuple[bool, str]:
 
         logger.info("Socket.IO dependencies installed and verified successfully")
         return True, ""
-    else:
-        return False, error_msg
+    return False, error_msg
 
 
 def get_pip_freeze_output() -> List[str]:
@@ -183,12 +181,12 @@ def get_pip_freeze_output() -> List[str]:
             capture_output=True,
             text=True,
             timeout=30,
+            check=False,
         )
 
         if result.returncode == 0:
             return result.stdout.strip().split("\n")
-        else:
-            return [f"pip freeze failed: {result.stderr}"]
+        return [f"pip freeze failed: {result.stderr}"]
 
     except Exception as e:
         return [f"Failed to get pip freeze output: {e}"]
@@ -206,8 +204,7 @@ def check_virtual_environment() -> Tuple[bool, str]:
     """
     # Check for virtual environment indicators
     in_venv = (
-        hasattr(sys, "base_prefix")
-        and sys.base_prefix != sys.prefix
+        (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix)
         or hasattr(sys, "real_prefix")
         or (hasattr(sys, "prefix") and "conda" in sys.prefix.lower())
     )
@@ -215,5 +212,4 @@ def check_virtual_environment() -> Tuple[bool, str]:
     if in_venv:
         venv_path = getattr(sys, "prefix", "unknown")
         return True, f"Virtual environment: {venv_path}"
-    else:
-        return False, f"System Python: {sys.prefix}"
+    return False, f"System Python: {sys.prefix}"

claude_mpm/utils/dependency_strategies.py

@@ -10,7 +10,6 @@ based on the execution context and user preferences.
 import json
 import os
 import sys
-import time
 from datetime import datetime, timedelta
 from enum import Enum
 from typing import Any, Dict, Optional, Tuple
@@ -256,16 +255,15 @@ class DependencyStrategy:
 
             if response in ["y", "yes"]:
                 return "yes"
-            elif response in ["n", "no", ""]:
+            if response in ["n", "no", ""]:
                 return "no"
-            elif response == "always":
+            if response == "always":
                 self._save_preference(DependencyMode.AUTO)
                 return "yes"
-            elif response == "never":
+            if response == "never":
                 self._save_preference(DependencyMode.OFF)
                 return "no"
-            else:
-                print("Invalid choice. Please enter: y, n, always, or never")
+            print("Invalid choice. Please enter: y, n, always, or never")
 
     def _save_preference(self, mode: DependencyMode) -> None:
         """
@@ -366,13 +364,13 @@ def lazy_check_agent_dependency(agent_id: str) -> bool:
         success, _ = loader.install_missing_dependencies(missing)
         return success
 
-    elif strategy.mode == DependencyMode.INTERACTIVE:
+    if strategy.mode == DependencyMode.INTERACTIVE:
         choice = strategy.prompt_for_installation(missing)
         if choice in ["yes"]:
             success, _ = loader.install_missing_dependencies(missing)
             return success
         return False
 
-    else:  # CHECK or OFF
-        logger.warning(f"Agent {agent_id} missing {len(missing)} dependencies")
-        return False  # Proceed anyway
+    # CHECK or OFF
+    logger.warning(f"Agent {agent_id} missing {len(missing)} dependencies")
+    return False  # Proceed anyway

claude_mpm/utils/environment_context.py

@@ -127,10 +127,7 @@ class EnvironmentContext:
                 return True
 
         # Additional heuristics for CI detection
-        if os.environ.get("BUILD_ID") or os.environ.get("BUILD_NUMBER"):
-            return True
-
-        return False
+        return bool(os.environ.get("BUILD_ID") or os.environ.get("BUILD_NUMBER"))
 
     @classmethod
     def _detect_docker(cls) -> bool:
@@ -152,7 +149,7 @@ class EnvironmentContext:
 
         # Check cgroup for docker/containerd references
         try:
-            with open("/proc/1/cgroup", "r") as f:
+            with open("/proc/1/cgroup") as f:
                 cgroup_content = f.read()
                 if "docker" in cgroup_content or "containerd" in cgroup_content:
                     return True
@@ -196,10 +193,7 @@ class EnvironmentContext:
             pass
 
         # Check for Jupyter-specific environment variables
-        if "JPY_PARENT_PID" in os.environ:
-            return True
-
-        return False
+        return "JPY_PARENT_PID" in os.environ
 
     @classmethod
     def _detect_ssh(cls) -> bool:

claude_mpm/utils/error_handler.py

@@ -6,7 +6,6 @@ Inspired by awesome-claude-code's comprehensive error handling approach.
 
 import logging
 import sys
-import traceback
 from datetime import datetime
 from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Type
@@ -31,7 +30,7 @@ class MPMError(Exception):
 
     def get_user_friendly_message(self) -> str:
         """Get a user-friendly error message."""
-        lines = [f"❌ Error: {str(self)}"]
+        lines = [f"❌ Error: {self!s}"]
 
         if self.details:
             lines.append("\nDetails:")
@@ -49,26 +48,18 @@ class MPMError(Exception):
 class AgentLoadError(MPMError):
     """Raised when agent loading fails."""
 
-    pass
-
 
 class ValidationError(MPMError):
     """Raised when validation fails."""
 
-    pass
-
 
 class ExecutionError(MPMError):
     """Raised when agent execution fails."""
 
-    pass
-
 
 class ConfigurationError(MPMError):
     """Raised when configuration is invalid."""
 
-    pass
-
 
 def handle_errors(
     error_type: Type[Exception] = Exception,
@@ -131,7 +122,7 @@ class ErrorContext:
         """Exit the context, handling any errors."""
         if exc_type is None:
             logger.debug(f"Completed operation: {self.operation}")
-            return
+            return None
 
         # Log the error with context
         logger.error(
@@ -216,8 +207,7 @@ def retry_on_error(
 
         if asyncio.iscoroutinefunction(func):
             return async_wrapper
-        else:
-            return sync_wrapper
+        return sync_wrapper
 
     return decorator
 

claude_mpm/utils/file_utils.py

@@ -61,7 +61,7 @@ def safe_read_file(path: Union[str, Path], encoding: str = "utf-8") -> str:
     path = Path(path)
     try:
         return path.read_text(encoding=encoding)
-    except FileNotFoundError as e:
+    except FileNotFoundError:
         raise FileOperationError(
             f"File not found: {path}",
             context={

claude_mpm/utils/path_operations.py

@@ -135,7 +135,7 @@ class PathOperations:
                 logger.warning(f"File not readable: {path}")
                 return default
 
-            with open(path_obj, "r", encoding=encoding) as f:
+            with open(path_obj, encoding=encoding) as f:
                 return f.read()
         except Exception as e:
             logger.error(f"Error reading file {path}: {e}")
@@ -307,13 +307,12 @@ class PathOperations:
 
             if path_obj.is_file():
                 return path_obj.stat().st_size
-            else:
-                # Calculate total size for directory
-                total = 0
-                for item in path_obj.rglob("*"):
-                    if item.is_file():
-                        total += item.stat().st_size
-                return total
+            # Calculate total size for directory
+            total = 0
+            for item in path_obj.rglob("*"):
+                if item.is_file():
+                    total += item.stat().st_size
+            return total
 
         except Exception as e:
             logger.error(f"Error getting size of {path}: {e}")
@@ -343,10 +342,7 @@ class PathOperations:
                 logger.error(f"Not a directory: {path}")
                 return []
 
-            if recursive:
-                items = path_obj.rglob(pattern)
-            else:
-                items = path_obj.glob(pattern)
+            items = path_obj.rglob(pattern) if recursive else path_obj.glob(pattern)
 
             results = []
             for item in items: