claude-mpm 4.6.0__py3-none-any.whl → 4.7.0__py3-none-any.whl

claude_mpm/dashboard/api/simple_directory.py

@@ -1,6 +1,5 @@
 """Simple directory listing API with proper filtering to match main code explorer"""
 
-import os
 from pathlib import Path
 
 from aiohttp import web
@@ -104,19 +103,19 @@ def has_code_files(directory_path, max_depth=5, current_depth=0):
         return False
 
     try:
-        for item in os.listdir(directory_path):
+        for item in list(Path(directory_path).iterdir()):
             # Skip hidden files/dirs unless in exceptions
             if item.startswith(".") and item not in DOTFILE_EXCEPTIONS:
                 continue
 
-            item_path = os.path.join(directory_path, item)
+            item_path = Path(directory_path) / item
 
-            if os.path.isfile(item_path):
+            if Path(item_path).is_file():
                 # Check if it's a code file
-                ext = os.path.splitext(item)[1].lower()
+                ext = Path(item).suffix.lower()
                 if ext in CODE_EXTENSIONS:
                     return True
-            elif os.path.isdir(item_path):
+            elif Path(item_path).is_dir():
                 # Skip certain directories
                 if item in SKIP_DIRS or item.endswith(".egg-info"):
                     continue
@@ -153,9 +152,9 @@ def should_show_item(item_name, item_path, is_directory):
         if not has_code_files(item_path, max_depth=3):
             # Check if it has any visible subdirectories
             try:
-                for subitem in os.listdir(item_path):
-                    subitem_path = os.path.join(item_path, subitem)
-                    if os.path.isdir(subitem_path):
+                for subitem in list(Path(item_path).iterdir()):
+                    subitem_path = Path(item_path) / subitem
+                    if Path(subitem_path).is_dir():
                         if not subitem.startswith(".") and subitem not in SKIP_DIRS:
                             return True
                 return False
@@ -163,7 +162,7 @@ def should_show_item(item_name, item_path, is_directory):
                 return False
     else:
         # For files, check if it's a code file or documentation
-        ext = os.path.splitext(item_name)[1].lower()
+        ext = Path(item_name).suffix.lower()
         if ext in CODE_EXTENSIONS:
             return True
 
@@ -189,12 +188,12 @@ async def list_directory(request):
     path = request.query.get("path", ".")
 
     # Convert to absolute path
-    abs_path = os.path.abspath(os.path.expanduser(path))
+    abs_path = Path(Path(path).resolve().expanduser())
 
     result = {
         "path": abs_path,
-        "exists": os.path.exists(abs_path),
-        "is_directory": os.path.isdir(abs_path),
+        "exists": Path(abs_path).exists(),
+        "is_directory": Path(abs_path).is_dir(),
         "contents": [],
         "filtered": True,  # Indicate that filtering is applied
         "filter_info": "Showing only code files and directories with code",
@@ -206,11 +205,11 @@ async def list_directory(request):
             gitignore_mgr = GitignoreManager()
 
             # List all items
-            items = os.listdir(abs_path)
+            items = list(Path(abs_path).iterdir())
 
             for item in items:
-                item_path = os.path.join(abs_path, item)
-                is_directory = os.path.isdir(item_path)
+                item_path = Path(abs_path) / item
+                is_directory = Path(item_path).is_dir()
 
                 # Check if item should be ignored by gitignore
                 if gitignore_mgr.should_ignore(Path(item_path), Path(abs_path)):
@@ -226,7 +225,7 @@ async def list_directory(request):
                         "name": item,
                         "path": item_path,
                         "is_directory": is_directory,
-                        "is_file": os.path.isfile(item_path),
+                        "is_file": Path(item_path).is_file(),
                         "is_code_file": not is_directory
                         and any(item.endswith(ext) for ext in CODE_EXTENSIONS),
                     }

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -10,6 +10,7 @@ import re
 import subprocess
 import sys
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional
 
 # Import tool analysis with fallback for direct execution
@@ -309,7 +310,7 @@ class EventHandlers:
         """Get git branch for the given directory with caching."""
         # Use current working directory if not specified
         if not working_dir:
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
 
         # Check cache first (cache for 30 seconds)
         current_time = datetime.now(timezone.utc).timestamp()
@@ -325,7 +326,7 @@ class EventHandlers:
         # Try to get git branch
         try:
             # Change to the working directory temporarily
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             os.chdir(working_dir)
 
             # Run git command to get current branch

claude_mpm/hooks/claude_hooks/hook_handler_eventbus.py

@@ -224,7 +224,7 @@ class HookHandler:
         """Get git branch for the given directory with caching."""
         # Use current working directory if not specified
         if not working_dir:
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
 
         # Check cache first (cache for 30 seconds)
         current_time = time.time()
@@ -240,7 +240,7 @@ class HookHandler:
         # Try to get git branch
         try:
             # Change to the working directory temporarily
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             os.chdir(working_dir)
 
             # Run git command to get current branch

claude_mpm/hooks/claude_hooks/hook_handler_original.py

@@ -313,7 +313,7 @@ class ClaudeHookHandler:
         """
         # Use current working directory if not specified
         if not working_dir:
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
 
         # Check cache first (cache for 30 seconds)
         current_time = datetime.now(timezone.utc).timestamp()
@@ -329,7 +329,7 @@ class ClaudeHookHandler:
         # Try to get git branch
         try:
             # Change to the working directory temporarily
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             os.chdir(working_dir)
 
             # Run git command to get current branch

claude_mpm/hooks/claude_hooks/installer.py

@@ -37,7 +37,7 @@ find_claude_mpm() {
             cmd_path=$(readlink -f "$cmd_path")
         fi
         # Extract the base directory (usually site-packages or venv)
-        local base_dir=$(python3 -c "import claude_mpm; import os; print(os.path.dirname(os.path.dirname(claude_mpm.__file__)))" 2>/dev/null)
+        local base_dir=$(python3 -c "import claude_mpm; import os; print(Path(os.path.dirname(claude_mpm.__file__).parent))" 2>/dev/null)
         if [ -n "$base_dir" ]; then
             echo "$base_dir"
             return 0
@@ -71,7 +71,7 @@ try:
     import claude_mpm
     import os
     # Get the package directory
-    pkg_dir = os.path.dirname(claude_mpm.__file__)
+    pkg_dir = Path(claude_mpm.__file__).parent
     # Check if we're in a development install (src directory)
     if 'src' in pkg_dir:
         # Go up to find the project root
@@ -81,10 +81,10 @@ try:
             project_root = os.sep.join(parts[:src_idx])
             print(project_root)
         else:
-            print(os.path.dirname(os.path.dirname(pkg_dir)))
+            print(Path(os.path.dirname(pkg_dir).parent))
     else:
         # Installed package - just return the package location
-        print(os.path.dirname(pkg_dir))
+        print(Path(pkg_dir).parent)
 except Exception:
     pass
 " 2>/dev/null)
@@ -99,7 +99,7 @@ except Exception:
     for path_dir in $PATH; do
         if [ -f "$path_dir/claude-mpm" ]; then
             # Found claude-mpm executable, try to find its package
-            local pkg_dir=$(cd "$path_dir" && python3 -c "import claude_mpm; import os; print(os.path.dirname(os.path.dirname(claude_mpm.__file__)))" 2>/dev/null)
+            local pkg_dir=$(cd "$path_dir" && python3 -c "import claude_mpm; import os; print(Path(os.path.dirname(claude_mpm.__file__).parent))" 2>/dev/null)
             if [ -n "$pkg_dir" ]; then
                 echo "$pkg_dir"
                 return 0
@@ -339,8 +339,8 @@ main "$@"
 
         # Make sure it's executable
         if script_path.exists():
-            st = os.stat(script_path)
-            os.chmod(script_path, st.st_mode | stat.S_IEXEC)
+            st = Path(script_path).stat()
+            Path(script_path).chmod(st.st_mode | stat.S_IEXEC)
             self._hook_script_path = script_path
             return script_path
 
@@ -588,9 +588,9 @@ main "$@"
                 issues.append(f"Invalid Claude settings JSON: {e}")
 
         # Check if claude-mpm is accessible
-        try:
-            import claude_mpm
-        except ImportError:
+        import importlib.util
+
+        if importlib.util.find_spec("claude_mpm") is None:
             issues.append("claude-mpm package not found in Python environment")
 
         is_valid = len(issues) == 0

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -10,6 +10,7 @@ import os
 import re
 import sys
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Any, Optional
 
 # Debug mode
@@ -64,8 +65,8 @@ class ResponseTrackingManager:
             if config_file:
                 # Use specific config file with ConfigLoader
                 pattern = ConfigPattern(
-                    filenames=[os.path.basename(config_file)],
-                    search_paths=[os.path.dirname(config_file)],
+                    filenames=[Path(config_file).name],
+                    search_paths=[Path(config_file).parent],
                     env_prefix="CLAUDE_MPM_",
                 )
                 config = config_loader.load_config(

claude_mpm/hooks/claude_hooks/services/state_manager.py

@@ -12,6 +12,7 @@ import subprocess
 import time
 from collections import deque
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional
 
 # Import constants for configuration
@@ -176,7 +177,7 @@ class StateManagerService:
         """
         # Use current working directory if not specified
         if not working_dir:
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
 
         # Check cache first (cache for 30 seconds)
         current_time = datetime.now(timezone.utc).timestamp()
@@ -192,7 +193,7 @@ class StateManagerService:
         # Try to get git branch
         try:
             # Change to the working directory temporarily
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             os.chdir(working_dir)
 
             # Run git command to get current branch

claude_mpm/hooks/tool_call_interceptor.py

@@ -125,10 +125,13 @@ class ToolCallInterceptor:
                         f"[{result.get('hook_name', 'Unknown')}] {result.get('error')}"
                     )
 
-            if result.get("modified") and result.get("data"):
+            if (
+                result.get("modified")
+                and result.get("data")
+                and "parameters" in result.get("data", {})
+            ):
                 # Update parameters if modified
-                if "parameters" in result.get("data", {}):
-                    modified_params = result["data"]["parameters"]
+                modified_params = result["data"]["parameters"]
 
             if result.get("metadata"):
                 hook_metadata.update(result["metadata"])

claude_mpm/models/agent_session.py

@@ -531,6 +531,8 @@ class AgentSession:
 
         WHY: Enables analysis of historical sessions.
         """
-        with open(filepath, encoding="utf-8") as f:
+        with Path(filepath).open(
+            encoding="utf-8",
+        ) as f:
             data = json.load(f)
         return cls.from_dict(data)

claude_mpm/scripts/mcp_server.py

@@ -6,15 +6,13 @@ It handles proper Python path setup and error reporting to stderr.
 """
 
 import logging
-import os
 import sys
+from pathlib import Path
 
 # Since we're now in src/claude_mpm/scripts/, we need to go up 3 levels to reach the project root
 # Then down into src to add it to the path
-project_root = os.path.abspath(
-    os.path.join(os.path.dirname(__file__), "..", "..", "..")
-)
-sys.path.insert(0, os.path.join(project_root, "src"))
+project_root = Path(Path(Path(__file__).parent.resolve().joinpath(), "..", "..", ".."))
+sys.path.insert(0, Path(project_root) / "src")
 
 
 def setup_logging():

claude_mpm/services/agents/agent_builder.py

@@ -12,7 +12,7 @@ import json
 import re
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, ClassVar, Dict, List, Optional, Tuple
 
 from claude_mpm.core.exceptions import AgentDeploymentError
 from claude_mpm.core.logging_config import get_logger
@@ -22,13 +22,13 @@ class AgentBuilderService:
     """Service for building and managing agent configurations."""
 
     # Valid agent models
-    VALID_MODELS = ["sonnet", "opus", "haiku"]
+    VALID_MODELS: ClassVar[list[str]] = ["sonnet", "opus", "haiku"]
 
     # Valid tool choices
-    VALID_TOOL_CHOICES = ["auto", "required", "any", "none"]
+    VALID_TOOL_CHOICES: ClassVar[list[str]] = ["auto", "required", "any", "none"]
 
     # Agent categories
-    AGENT_CATEGORIES = [
+    AGENT_CATEGORIES: ClassVar[list[str]] = [
         "engineering",
         "qa",
         "documentation",

claude_mpm/services/agents/deployment/deployment_type_detector.py

@@ -63,13 +63,11 @@ class DeploymentTypeDetector:
         """
         # Check if we're in a project directory with .claude-mpm/agents
         project_agents_dir = working_directory / ".claude-mpm" / "agents"
-        if project_agents_dir.exists():
-            # Check if templates_dir points to project agents
-            if templates_dir and templates_dir.exists():
-                try:
-                    return project_agents_dir.resolve() == templates_dir.resolve()
-                except Exception:
-                    pass
+        if project_agents_dir.exists() and templates_dir and templates_dir.exists():
+            try:
+                return project_agents_dir.resolve() == templates_dir.resolve()
+            except Exception:
+                pass
         return False
 
     @staticmethod
@@ -86,13 +84,11 @@ class DeploymentTypeDetector:
             True if deploying user custom agents, False otherwise
         """
         user_agents_dir = Path.home() / ".claude-mpm" / "agents"
-        if user_agents_dir.exists():
-            # Check if templates_dir points to user agents
-            if templates_dir and templates_dir.exists():
-                try:
-                    return user_agents_dir.resolve() == templates_dir.resolve()
-                except Exception:
-                    pass
+        if user_agents_dir.exists() and templates_dir and templates_dir.exists():
+            try:
+                return user_agents_dir.resolve() == templates_dir.resolve()
+            except Exception:
+                pass
         return False
 
     @staticmethod

claude_mpm/services/agents/deployment/local_template_deployment.py

@@ -330,9 +330,12 @@ class LocalTemplateDeploymentService:
         for agent_id, template in templates.items():
             if agent_id in deployed:
                 # Check if needs update
-                if deployed[agent_id]["version"] != template.agent_version:
-                    if self.deploy_single_local_template(agent_id, force_rebuild=True):
-                        results["updated"].append(agent_id)
+                if deployed[agent_id][
+                    "version"
+                ] != template.agent_version and self.deploy_single_local_template(
+                    agent_id, force_rebuild=True
+                ):
+                    results["updated"].append(agent_id)
             # New agent to deploy
             elif self.deploy_single_local_template(agent_id):
                 results["added"].append(agent_id)

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -209,13 +209,15 @@ class MultiSourceAgentDeploymentService:
                                     f"User agent '{agent_name}' v{other_agent['version']} "
                                     f"overridden by higher {highest_version_agent['source']} version v{highest_version_agent['version']}"
                                 )
-                        elif version_comparison == 0:
+                        elif (
+                            version_comparison == 0
+                            and other_agent["source"] != highest_version_agent["source"]
+                        ):
                             # Log info when versions are equal but different sources
-                            if other_agent["source"] != highest_version_agent["source"]:
-                                self.logger.info(
-                                    f"Using {highest_version_agent['source']} source for '{agent_name}' "
-                                    f"(same version v{highest_version_agent['version']} as {other_agent['source']} source)"
-                                )
+                            self.logger.info(
+                                f"Using {highest_version_agent['source']} source for '{agent_name}' "
+                                f"(same version v{highest_version_agent['version']} as {other_agent['source']} source)"
+                            )
 
         return selected_agents
 
@@ -850,11 +852,13 @@ class MultiSourceAgentDeploymentService:
                 ):
                     # In development mode, unknown agents are likely system agents being tested
                     return "system"
-                if deployment_context == DeploymentContext.PIPX_INSTALL:
-                    # In pipx mode, unknown agents could be system agents
-                    # Check if agent follows system naming patterns
-                    if agent_name.count("-") <= 2 and len(agent_name) <= 20:
-                        return "system"
+                if (
+                    deployment_context == DeploymentContext.PIPX_INSTALL
+                    and agent_name.count("-") <= 2
+                    and len(agent_name) <= 20
+                ):
+                    # In pipx mode, check if agent follows system naming patterns
+                    return "system"
             except Exception:
                 pass
 

claude_mpm/services/agents/deployment/system_instructions_deployer.py

@@ -70,12 +70,15 @@ class SystemInstructionsDeployer:
                 target_file = claude_dir / target_name
 
                 # Check if update needed
-                if not force_rebuild and target_file.exists():
-                    # Compare modification times
-                    if target_file.stat().st_mtime >= source_path.stat().st_mtime:
-                        results["skipped"].append(target_name)
-                        self.logger.debug(f"Framework file {target_name} up to date")
-                        continue
+                if (
+                    not force_rebuild
+                    and target_file.exists()
+                    and target_file.stat().st_mtime >= source_path.stat().st_mtime
+                ):
+                    # File is up to date based on modification time
+                    results["skipped"].append(target_name)
+                    self.logger.debug(f"Framework file {target_name} up to date")
+                    continue
 
                 # Read and deploy framework file
                 file_content = source_path.read_text()

claude_mpm/services/agents/loading/agent_profile_loader.py

@@ -21,7 +21,6 @@ multi-file implementation for better maintainability.
 
 import asyncio
 import json
-import os
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from enum import Enum
@@ -113,7 +112,7 @@ class AgentProfileLoader(BaseService):
         super().__init__(name="agent_profile_loader", config=config)
 
         # Core configuration
-        self.working_directory = Path(os.getcwd())
+        self.working_directory = Path(Path.cwd())
         self.framework_path = self._detect_framework_path()
         self.user_home = Path.home()
 

claude_mpm/services/agents/memory/agent_memory_manager.py

@@ -22,8 +22,7 @@ following the naming convention: {agent_id}_memories.md
 """
 
 import logging
-import os
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, ClassVar, Dict, List, Optional, Tuple
 
 from claude_mpm.core.config import Config
 from claude_mpm.core.interfaces import MemoryServiceInterface
@@ -54,7 +53,7 @@ class AgentMemoryManager(MemoryServiceInterface):
 
     # Default limits - will be overridden by configuration
     # Updated to support 20k tokens (~80KB) for enhanced memory capacity
-    DEFAULT_MEMORY_LIMITS = {
+    DEFAULT_MEMORY_LIMITS: ClassVar[dict[str, int]] = {
         "max_file_size_kb": 80,  # Increased from 8KB to 80KB (20k tokens)
         "max_items": 100,  # Maximum total memory items
         "max_line_length": 120,
@@ -78,7 +77,7 @@ class AgentMemoryManager(MemoryServiceInterface):
         self.config = config or Config()
         self.project_root = get_path_manager().project_root
         # Use current working directory by default, not project root
-        self.working_directory = working_directory or Path(os.getcwd())
+        self.working_directory = working_directory or Path(Path.cwd())
 
         # Use only project memory directory
         self.project_memories_dir = self.working_directory / ".claude-mpm" / "memories"
@@ -387,31 +386,32 @@ class AgentMemoryManager(MemoryServiceInterface):
                         memory_items = data["Remember"]
 
                     # Process memory items if found and not null
-                    if memory_items is not None and memory_items != "null":
-                        # Skip if explicitly null or empty list
-                        if isinstance(memory_items, list) and len(memory_items) > 0:
-                            # Filter out empty strings and None values
-                            valid_items = []
-                            for item in memory_items:
-                                if item and isinstance(item, str) and item.strip():
-                                    valid_items.append(item.strip())
-
-                            # Only proceed if we have valid items
-                            if valid_items:
+                    if (
+                        memory_items is not None
+                        and memory_items != "null"
+                        and isinstance(memory_items, list)
+                        and len(memory_items) > 0
+                    ):
+                        # Filter out empty strings and None values
+                        valid_items = []
+                        for item in memory_items:
+                            if item and isinstance(item, str) and item.strip():
+                                valid_items.append(item.strip())
+
+                        # Only proceed if we have valid items
+                        if valid_items:
+                            self.logger.info(
+                                f"Found {len(valid_items)} memory items for {agent_id}: {valid_items[:2]}..."
+                            )
+                            success = self._add_learnings_to_memory(
+                                agent_id, valid_items
+                            )
+                            if success:
                                 self.logger.info(
-                                    f"Found {len(valid_items)} memory items for {agent_id}: {valid_items[:2]}..."
-                                )
-                                success = self._add_learnings_to_memory(
-                                    agent_id, valid_items
-                                )
-                                if success:
-                                    self.logger.info(
-                                        f"Successfully saved {len(valid_items)} memories for {agent_id} to project directory"
-                                    )
-                                    return True
-                                self.logger.error(
-                                    f"Failed to save memories for {agent_id}"
+                                    f"Successfully saved {len(valid_items)} memories for {agent_id} to project directory"
                                 )
+                                return True
+                            self.logger.error(f"Failed to save memories for {agent_id}")
 
                 except json.JSONDecodeError as je:
                     # Not valid JSON, continue to next match

claude_mpm/services/agents/memory/content_manager.py

@@ -363,10 +363,15 @@ class MemoryContentManager:
 
         # Additional check: if one string contains the other (substring match)
         # This catches cases where one item is a more detailed version of another
-        if len(str1_normalized) > 20 and len(str2_normalized) > 20:
-            if str1_normalized in str2_normalized or str2_normalized in str1_normalized:
-                # Boost similarity for substring matches
-                similarity = max(similarity, 0.85)
+        if (
+            len(str1_normalized) > 20
+            and len(str2_normalized) > 20
+            and (
+                str1_normalized in str2_normalized or str2_normalized in str1_normalized
+            )
+        ):
+            # Boost similarity for substring matches
+            similarity = max(similarity, 0.85)
 
         return similarity
 

claude_mpm/services/claude_session_logger.py

@@ -10,6 +10,8 @@ Now with optional async logging support for improved performance.
 Configuration via .claude-mpm/configuration.yaml.
 """
 
+# Try to import async logger for performance optimization
+import importlib.util
 import json
 import os
 from datetime import datetime, timezone
@@ -22,16 +24,11 @@ from claude_mpm.core.config import Config
 # Import centralized session manager
 from claude_mpm.services.session_manager import get_session_manager
 
-# Try to import async logger for performance optimization
-try:
-    from claude_mpm.services.async_session_logger import (
-        AsyncSessionLogger,
-        get_async_logger,
-        log_response_async,
-    )
+if importlib.util.find_spec("claude_mpm.services.async_session_logger"):
+    from claude_mpm.services.async_session_logger import get_async_logger
 
     ASYNC_AVAILABLE = True
-except ImportError:
+else:
     ASYNC_AVAILABLE = False
 
 from claude_mpm.core.logging_utils import get_logger

claude_mpm/services/cli/memory_crud_service.py

@@ -142,7 +142,7 @@ class MemoryCRUDService(IMemoryCRUDService):
             config_loader = ConfigLoader()
             config = config_loader.load_main_config()
             # Use CLAUDE_MPM_USER_PWD if available
-            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/services/cli/memory_output_formatter.py

@@ -90,7 +90,7 @@ class MemoryOutputFormatter(IMemoryOutputFormatter):
             "success": "✅" if not quiet else "[OK]",
             "error": "❌" if not quiet else "[ERROR]",
             "warning": "⚠️" if not quiet else "[WARN]",
-            "info": "ℹ️" if not quiet else "[INFO]",
+            "info": "[INFO]️" if not quiet else "[INFO]",
             "memory": "🧠" if not quiet else "[MEMORY]",
             "file": "📁" if not quiet else "[FILE]",
             "agent": "🤖" if not quiet else "[AGENT]",