claude-mpm 4.6.1__py3-none-any.whl → 4.7.1__py3-none-any.whl

claude_mpm/cli/commands/cleanup.py

@@ -538,7 +538,7 @@ def _cleanup_memory_original(args):
             )
             print(f"💾 Saved: {format_size(original_size - new_size)}")
         else:
-            print("ℹ️  No conversations were old enough to clean up")
+            print("[INFO]️  No conversations were old enough to clean up")
             print("💡 Try using --days with a smaller value to clean more aggressively")
 
     except Exception as e:

claude_mpm/cli/commands/mcp_setup_external.py

@@ -527,11 +527,11 @@ class MCPExternalServicesSetup:
         module_name = service_info.get("module_name", service_name.replace("-", "_"))
         if not self._check_python_package(module_name):
             print(f"   ⚠️ Python package {service_info['package_name']} not installed")
-            print(f"   ℹ️ Installing {service_info['package_name']}...")
+            print(f"   [INFO]️ Installing {service_info['package_name']}...")
             if not self._install_python_package(service_info["package_name"]):
                 print(f"   ❌ Failed to install {service_info['package_name']}")
                 print(
-                    f"   ℹ️ Install manually with: pip install {service_info['package_name']}"
+                    f"   [INFO]️ Install manually with: pip install {service_info['package_name']}"
                 )
                 return False
 

claude_mpm/cli/commands/memory.py

@@ -39,7 +39,7 @@ class MemoryManagementCommand(MemoryCommand):
             config_loader = ConfigLoader()
             config = config_loader.load_main_config()
             # Use CLAUDE_MPM_USER_PWD if available, otherwise use current working directory
-            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", os.getcwd())
+            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", Path.cwd())
             current_dir = Path(user_pwd)
             self._memory_manager = AgentMemoryManager(config, current_dir)
         return self._memory_manager

claude_mpm/cli/commands/mpm_init.py

@@ -436,7 +436,7 @@ The final CLAUDE.md should be a comprehensive, well-organized guide that any AI
                 console.print(f"  • {pattern}")
 
         if analysis.get("custom_sections"):
-            console.print("\n[blue]ℹ️  Custom sections found:[/blue]")
+            console.print("\n[blue][INFO]️  Custom sections found:[/blue]")
             for section in analysis["custom_sections"][:5]:
                 console.print(f"  • {section}")
 
@@ -912,10 +912,9 @@ preserving valuable project-specific information while refreshing standard secti
                     )
             finally:
                 # Clean up temporary file
-                import os
 
                 with contextlib.suppress(Exception):
-                    os.unlink(prompt_file)
+                    Path(prompt_file).unlink()
 
             # Display output if verbose
             if verbose and result.stdout:
@@ -965,7 +964,9 @@ preserving valuable project-specific information while refreshing standard secti
             if "libmamba" in error_msg:
                 lines = error_msg.split("\n")
                 error_lines = [
-                    l for l in lines if not l.startswith("warning") and l.strip()
+                    line
+                    for line in lines
+                    if not line.startswith("warning") and line.strip()
                 ]
                 error_msg = "\n".join(error_lines) if error_lines else error_msg
 

claude_mpm/cli/commands/run.py

@@ -326,7 +326,7 @@ class RunCommand(BaseCommand):
                         self.logger.warning(f"Session {resume_session_id} not found")
                 else:
                     self.logger.info("No recent interactive sessions found")
-                    print("ℹ️  No recent interactive sessions found to resume")
+                    print("[INFO]️  No recent interactive sessions found to resume")
             else:
                 # Resume specific session by ID
                 resume_session_id = args.mpm_resume
@@ -654,7 +654,7 @@ def _handle_reload_agents(logger):
                 print(f"🔄 Cleaned {removed_count} claude-mpm system agents")
             else:
                 logger.info("No system agents found to clean")
-                print("ℹ️  No system agents found - already clean")
+                print("[INFO]️  No system agents found - already clean")
 
             if preserved_agents:
                 logger.info(f"Preserved {len(preserved_agents)} user-created agents")
@@ -774,7 +774,7 @@ def run_session_legacy(args):
                     logger.warning(f"Session {resume_session_id} not found")
             else:
                 logger.info("No recent interactive sessions found")
-                print("ℹ️  No recent interactive sessions found to resume")
+                print("[INFO]️  No recent interactive sessions found to resume")
         else:
             # Resume specific session by ID
             resume_session_id = args.mpm_resume
@@ -947,7 +947,7 @@ def run_session_legacy(args):
             raw_claude_args = ["--resume", *raw_claude_args]
             logger.info("✅ Added --resume to claude_args")
         else:
-            logger.info("ℹ️ --resume already in claude_args")
+            logger.info("[INFO]️ --resume already in claude_args")
 
     # Filter out claude-mpm specific flags before passing to Claude CLI
     logger.debug(f"Pre-filter claude_args: {raw_claude_args}")

claude_mpm/cli/shared/argument_patterns.py

@@ -20,65 +20,72 @@ class CommonArguments:
         "help": "Enable verbose output",
     }
 
-    QUIET = {
+    QUIET: ClassVar[Dict[str, Any]] = {
         "flags": ["-q", "--quiet"],
         "action": "store_true",
         "help": "Suppress non-error output",
     }
 
-    DEBUG = {
+    DEBUG: ClassVar[Dict[str, Any]] = {
         "flags": ["--debug"],
         "action": "store_true",
         "help": "Enable debug logging",
     }
 
     # Configuration arguments
-    CONFIG_FILE = {
+    CONFIG_FILE: ClassVar[Dict[str, Any]] = {
         "flags": ["-c", "--config"],
         "type": Path,
         "help": "Path to configuration file",
     }
 
-    CONFIG_DIR = {
+    CONFIG_DIR: ClassVar[Dict[str, Any]] = {
         "flags": ["--config-dir"],
         "type": Path,
         "help": "Configuration directory path",
     }
 
     # Output arguments
-    OUTPUT_FORMAT = {
+    OUTPUT_FORMAT: ClassVar[Dict[str, Any]] = {
         "flags": ["-f", "--format"],
         "choices": ["json", "yaml", "table", "text"],
         "default": "text",
         "help": "Output format",
     }
 
-    OUTPUT_FILE = {
+    OUTPUT_FILE: ClassVar[Dict[str, Any]] = {
         "flags": ["-o", "--output"],
         "type": Path,
         "help": "Output file path",
     }
 
     # Common flags
-    FORCE = {
+    FORCE: ClassVar[Dict[str, Any]] = {
         "flags": ["--force"],
         "action": "store_true",
         "help": "Force operation without confirmation",
     }
 
-    DRY_RUN = {
+    DRY_RUN: ClassVar[Dict[str, Any]] = {
         "flags": ["--dry-run"],
         "action": "store_true",
         "help": "Show what would be done without executing",
     }
 
     # Agent-related arguments
-    AGENT_NAME = {"flags": ["--agent"], "help": "Agent name or pattern"}
+    AGENT_NAME: ClassVar[Dict[str, Any]] = {
+        "flags": ["--agent"],
+        "help": "Agent name or pattern",
+    }
 
-    AGENT_DIR = {"flags": ["--agent-dir"], "type": Path, "help": "Agent directory path"}
+    AGENT_DIR: ClassVar[Dict[str, Any]] = {
+        "flags": ["--agent-dir"],
+        "type": Path,
+        "help": "Agent directory path",
+    }
 
     # Memory-related arguments
-    MEMORY_DIR = {
+    MEMORY_DIR: ClassVar[Dict[str, Any]] = {
         "flags": ["--memory-dir"],
         "type": Path,
         "help": "Memory directory path",

claude_mpm/cli/shared/base_command.py

@@ -73,7 +73,7 @@ class BaseCommand(ABC):
         """Get working directory (respects CLAUDE_MPM_USER_PWD)."""
         if self._working_dir is None:
             # Use CLAUDE_MPM_USER_PWD if available (when called via shell script)
-            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", os.getcwd())
+            user_pwd = os.environ.get("CLAUDE_MPM_USER_PWD", Path.cwd())
             self._working_dir = Path(user_pwd)
         return self._working_dir
 

claude_mpm/config/experimental_features.py

@@ -12,7 +12,7 @@ gradual rollout of experimental features while maintaining stability in producti
 
 import json
 import os
-from typing import Dict, Optional
+from typing import ClassVar, Dict, Optional
 
 
 class ExperimentalFeatures:
@@ -26,7 +26,7 @@ class ExperimentalFeatures:
     """
 
     # Default feature flags
-    DEFAULTS = {
+    DEFAULTS: ClassVar[Dict[str, bool]] = {
         "enable_mcp_gateway": False,  # MCP Gateway is experimental
         "enable_advanced_aggregation": False,  # Advanced aggregation features
         "show_experimental_warnings": True,  # Show warnings for experimental features
@@ -34,7 +34,7 @@ class ExperimentalFeatures:
     }
 
     # Warning messages for experimental features
-    WARNINGS = {
+    WARNINGS: ClassVar[Dict[str, str]] = {
         "mcp_gateway": (
             "⚠️  EXPERIMENTAL FEATURE: MCP Gateway is in early access.\n"
             "   Tool integration may be unstable. Not recommended for production use."

claude_mpm/config/socketio_config.py

@@ -186,7 +186,7 @@ class ConfigManager:
     def detect_environment(self) -> str:
         """Detect the current deployment environment."""
         # Check for Docker
-        if os.path.exists("/.dockerenv") or os.getenv("DOCKER_CONTAINER"):
+        if Path("/.dockerenv").exists() or os.getenv("DOCKER_CONTAINER"):
             return "docker"
 
         # Check for production indicators

claude_mpm/core/cache.py

@@ -288,10 +288,10 @@ class FileSystemCache:
             """Read file from disk."""
             try:
                 if "b" in mode:
-                    with open(file_path, mode) as f:
+                    with Path(file_path).open(mode) as f:
                         return f.read()
                 else:
-                    with open(file_path, mode, encoding=encoding) as f:
+                    with Path(file_path).open(mode, encoding=encoding) as f:
                         return f.read()
             except Exception as e:
                 self._logger.error(f"Failed to read file {file_path}: {e}")

claude_mpm/core/claude_runner.py

@@ -462,13 +462,11 @@ class ClaudeRunner:
                         if (
                             "author: claude-mpm-project" in existing_content
                             or "source: project" in existing_content
-                        ):
-                            # Compare modification times
-                            if target_file.stat().st_mtime >= json_file.stat().st_mtime:
-                                needs_update = False
-                                self.logger.debug(
-                                    f"Project agent {agent_name} is up to date"
-                                )
+                        ) and target_file.stat().st_mtime >= json_file.stat().st_mtime:
+                            needs_update = False
+                            self.logger.debug(
+                                f"Project agent {agent_name} is up to date"
+                            )
 
                     if needs_update:
                         # Build the agent markdown using the pre-initialized service and base agent data

claude_mpm/core/container.py

@@ -538,10 +538,16 @@ class DIContainer(IServiceContainer):
 
             elif registration.lifetime == ServiceLifetime.SCOPED:
                 # Check current scope
-                if self._current_scope:
-                    instance = self._current_scope.get_scoped_instance(service_type)
-                    if instance is not None:
-                        return instance
+                if (
+                    self._current_scope
+                    and (
+                        instance := self._current_scope.get_scoped_instance(
+                            service_type
+                        )
+                    )
+                    is not None
+                ):
+                    return instance
 
             # Mark as resolving
             self._resolving.add(service_type)

claude_mpm/core/file_utils.py

@@ -173,10 +173,10 @@ def safe_read(
 
     try:
         if "b" in mode:
-            with open(filepath, mode) as f:
+            with Path(filepath).open(mode) as f:
                 return f.read()
         else:
-            with open(filepath, mode, encoding=encoding) as f:
+            with Path(filepath).open(mode, encoding=encoding) as f:
                 return f.read()
     except (OSError, UnicodeDecodeError) as e:
         logger.error(f"Error reading file {filepath}: {e}")
@@ -206,7 +206,9 @@ def safe_read_lines(
         return []
 
     try:
-        with open(filepath, encoding=encoding) as f:
+        with Path(filepath).open(
+            encoding=encoding,
+        ) as f:
             lines = []
             for i, line in enumerate(f):
                 if max_lines is not None and i >= max_lines:
@@ -320,10 +322,10 @@ def safe_write(
 
     try:
         if "b" in mode:
-            with open(filepath, mode) as f:
+            with Path(filepath).open(mode) as f:
                 f.write(content)
         else:
-            with open(filepath, mode, encoding=encoding) as f:
+            with Path(filepath).open(mode, encoding=encoding) as f:
                 f.write(content)
         return True
     except OSError as e:
@@ -368,14 +370,14 @@ def atomic_write(
                 f.write(content)
 
         # Atomic rename
-        os.replace(temp_path, filepath)
+        Path(temp_path).replace(filepath)
         return True
 
     except OSError as e:
         logger.error(f"Error in atomic write to {filepath}: {e}")
         # Clean up temporary file
         with suppress(Exception):
-            os.unlink(temp_path)
+            Path(temp_path).unlink()
         return False
 
 
@@ -634,7 +636,7 @@ def file_lock(filepath: Union[str, Path], timeout: float = 5.0):
 
         while True:
             try:
-                lock_handle = open(lock_file, "w")
+                lock_handle = Path(lock_file).open("w")
                 fcntl.flock(lock_handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
                 break
             except OSError as e:

claude_mpm/core/framework/formatters/context_generator.py

@@ -6,6 +6,7 @@ import os
 import platform
 import time as time_module
 from datetime import datetime, timezone
+from pathlib import Path
 
 from claude_mpm.core.logging_utils import get_logger
 
@@ -117,7 +118,7 @@ class ContextGenerator:
 
                 # Add home directory if available
                 try:
-                    home_dir = os.path.expanduser("~")
+                    home_dir = Path("~").expanduser()
                     if home_dir and home_dir != "~":
                         context_lines.append(f"**Home Directory**: {home_dir}\n")
                 except Exception:
@@ -168,7 +169,7 @@ class ContextGenerator:
         """
         try:
             # Add current working directory
-            cwd = os.getcwd()
+            cwd = Path.cwd()
             if cwd:
                 context_lines.append(f"**Working Directory**: {cwd}\n")
         except Exception:

claude_mpm/core/framework/loaders/agent_loader.py

@@ -100,13 +100,17 @@ class AgentLoader:
                 agents[agent_name] = agent_content
 
         # If we used templates dir, also check main dir for base_agent.md
-        if agents_dir == templates_dir and main_dir and main_dir.exists():
-            if "base_agent" not in agents:
-                base_agent_file = main_dir / "base_agent.md"
-                if base_agent_file.exists():
-                    agent_name, agent_content = self.load_single_agent(base_agent_file)
-                    if agent_name and agent_content:
-                        agents[agent_name] = agent_content
+        if (
+            agents_dir == templates_dir
+            and main_dir
+            and main_dir.exists()
+            and "base_agent" not in agents
+        ):
+            base_agent_file = main_dir / "base_agent.md"
+            if base_agent_file.exists():
+                agent_name, agent_content = self.load_single_agent(base_agent_file)
+                if agent_name and agent_content:
+                    agents[agent_name] = agent_content
 
         return agents
 

claude_mpm/core/injectable_service.py

@@ -182,14 +182,17 @@ class InjectableService(BaseService, ABC):
                 continue
 
             attr = getattr(self, attr_name, None)
-            if attr and hasattr(attr, "start") and hasattr(attr, "running"):
-                # It's a service that needs to be started
-                if not attr.running:
-                    try:
-                        await attr.start()
-                        logger.debug(f"Started dependency {attr_name}")
-                    except Exception as e:
-                        logger.warning(f"Failed to start dependency {attr_name}: {e}")
+            if (
+                attr
+                and hasattr(attr, "start")
+                and hasattr(attr, "running")
+                and not attr.running
+            ):
+                try:
+                    await attr.start()
+                    logger.debug(f"Started dependency {attr_name}")
+                except Exception as e:
+                    logger.warning(f"Failed to start dependency {attr_name}: {e}")
 
     def __repr__(self) -> str:
         """Enhanced string representation showing dependencies."""

claude_mpm/core/interactive_session.py

@@ -8,6 +8,7 @@ import contextlib
 import os
 import subprocess
 import uuid
+from pathlib import Path
 from typing import Any, Dict, Optional, Tuple
 
 from claude_mpm.core.logger import get_logger
@@ -35,7 +36,7 @@ class InteractiveSession:
         self.runner = runner
         self.logger = get_logger("interactive_session")
         self.session_id = None
-        self.original_cwd = os.getcwd()
+        self.original_cwd = Path.cwd()
 
         # Initialize response tracking for interactive sessions
         # WHY: Interactive sessions need response logging just like oneshot sessions.
@@ -225,7 +226,7 @@ class InteractiveSession:
         """
         try:
             # Restore original directory
-            if self.original_cwd and os.path.exists(self.original_cwd):
+            if self.original_cwd and Path(self.original_cwd).exists():
                 with contextlib.suppress(OSError):
                     os.chdir(self.original_cwd)
 
@@ -278,7 +279,7 @@ class InteractiveSession:
             self.runner.websocket_server.session_started(
                 session_id=self.session_id,
                 launch_method=self.runner.launch_method,
-                working_dir=os.getcwd(),
+                working_dir=Path.cwd(),
             )
             return True, None
 
@@ -392,7 +393,7 @@ class InteractiveSession:
             self.logger.info("✅ VERIFIED: --resume flag IS included in final command")
             self.logger.debug(f"--resume position in command: {cmd.index('--resume')}")
         else:
-            self.logger.debug("ℹ️ --resume flag NOT included in final command")
+            self.logger.debug("[INFO]️ --resume flag NOT included in final command")
 
         return cmd
 

claude_mpm/core/oneshot_session.py

@@ -9,6 +9,7 @@ import os
 import subprocess
 import time
 import uuid
+from pathlib import Path
 from typing import Any, Dict, Optional, Tuple
 
 from claude_mpm.core.logger import get_logger
@@ -97,7 +98,7 @@ class OneshotSession:
             infrastructure["env"]["CLAUDE_WORKSPACE"] = user_pwd
 
             try:
-                self.original_cwd = os.getcwd()
+                self.original_cwd = Path.cwd()
                 os.chdir(user_pwd)
                 infrastructure["working_dir_changed"] = True
                 self.logger.info(f"Changed working directory to: {user_pwd}")
@@ -242,7 +243,7 @@ class OneshotSession:
             self.runner.websocket_server.session_started(
                 session_id=self.session_id,
                 launch_method="oneshot",
-                working_dir=os.getcwd(),
+                working_dir=Path.cwd(),
             )
         except (ImportError, ConnectionError, Exception) as e:
             self.logger.warning(f"Socket.IO connection failed: {e}")

claude_mpm/core/pm_hook_interceptor.py

@@ -139,10 +139,13 @@ class PMHookInterceptor:
 
         # Look for todos in positional args
         for arg in args:
-            if isinstance(arg, list) and arg and isinstance(arg[0], dict):
-                # Check if this looks like a todos list
-                if "content" in arg[0] or "id" in arg[0]:
-                    return arg
+            if (
+                isinstance(arg, list)
+                and arg
+                and isinstance(arg[0], dict)
+                and ("content" in arg[0] or "id" in arg[0])
+            ):
+                return arg
 
         return []
 
@@ -168,11 +171,14 @@ class PMHookInterceptor:
         # Update positional args if todos was passed positionally
         args_list = list(args)
         for i, arg in enumerate(args_list):
-            if isinstance(arg, list) and arg and isinstance(arg[0], dict):
-                # Check if this looks like a todos list
-                if "content" in arg[0] or "id" in arg[0]:
-                    args_list[i] = modified_todos
-                    return tuple(args_list), kwargs
+            if (
+                isinstance(arg, list)
+                and arg
+                and isinstance(arg[0], dict)
+                and ("content" in arg[0] or "id" in arg[0])
+            ):
+                args_list[i] = modified_todos
+                return tuple(args_list), kwargs
 
         # If we can't find where todos was passed, add as keyword argument
         kwargs = kwargs.copy()

claude_mpm/core/unified_paths.py

@@ -83,11 +83,12 @@ class PathContext:
             # Check if we're in a src/ directory structure with pyproject.toml
             current = module_path
             for _ in range(5):  # Check up to 5 levels up
-                if (current / "pyproject.toml").exists():
-                    # Found pyproject.toml, check if this looks like a development setup
-                    if (current / "src" / "claude_mpm").exists():
-                        logger.debug(f"Found development installation at {current}")
-                        return True
+                if (current / "pyproject.toml").exists() and (
+                    current / "src" / "claude_mpm"
+                ).exists():
+                    # Found pyproject.toml with development setup
+                    logger.debug(f"Found development installation at {current}")
+                    return True
                 if current == current.parent:
                     break
                 current = current.parent