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

claude_mpm/cli/utils.py

@@ -7,6 +7,7 @@ for common CLI operations.
 """
 
 import sys
+from pathlib import Path
 from typing import Optional
 
 from ..core.logger import get_logger
@@ -37,13 +38,11 @@ def get_user_input(input_arg: Optional[str], logger) -> str:
         if input_path.exists():
             logger.info(f"Reading input from file: {input_path}")
             return input_path.read_text()
-        else:
-            logger.info("Using command line input")
-            return input_arg
-    else:
-        # Read from stdin
-        logger.info("Reading input from stdin")
-        return sys.stdin.read()
+        logger.info("Using command line input")
+        return input_arg
+    # Read from stdin
+    logger.info("Reading input from stdin")
+    return sys.stdin.read()
 
 
 def get_agent_versions_display() -> Optional[str]:
@@ -115,7 +114,7 @@ def get_agent_versions_display() -> Optional[str]:
             output_lines.append(
                 f"\n  ⚠️  {len(verification['agents_needing_migration'])} agent(s) need migration to semantic versioning"
             )
-            output_lines.append(f"     Run 'claude-mpm agents deploy' to update")
+            output_lines.append("     Run 'claude-mpm agents deploy' to update")
 
         output_lines.append("-" * 40)
         return "\n".join(output_lines)
@@ -132,16 +131,17 @@ def list_agent_versions_at_startup() -> None:
 
     WHY: Users want to see what agents are available when they start a session.
     This provides immediate feedback about the deployed agent environment.
-    
+
     DESIGN DECISION: We suppress INFO logging during this call to avoid duplicate
     initialization messages since the deployment service will be initialized again
     later in the ClaudeRunner.
     """
     # Temporarily suppress INFO level logging to avoid duplicate initialization messages
     import logging
+
     original_level = logging.getLogger("claude_mpm").level
     logging.getLogger("claude_mpm").setLevel(logging.WARNING)
-    
+
     try:
         agent_versions = get_agent_versions_display()
         if agent_versions:
@@ -166,7 +166,6 @@ def setup_logging(args) -> object:
         Logger instance
     """
     from ..constants import LogLevel
-    from ..core.logger import get_logger
     from ..core.logger import setup_logging as core_setup_logging
 
     # Set default logging level if not specified

claude_mpm/cli_module/__init__.py

@@ -9,7 +9,7 @@ from .commands import CommandDefinition, CommandRegistry, register_standard_comm
 
 __all__ = [
     "ArgumentRegistry",
-    "CommandRegistry",
     "CommandDefinition",
+    "CommandRegistry",
     "register_standard_commands",
 ]

claude_mpm/cli_module/args.py

@@ -2,7 +2,7 @@
 
 import argparse
 from pathlib import Path
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Dict, Optional
 
 
 class ArgumentRegistry:

claude_mpm/cli_module/migration_example.py

@@ -6,6 +6,7 @@ from 16 to under 10 by using ArgumentRegistry and CommandRegistry.
 
 import argparse
 import sys
+from typing import Optional
 
 from claude_mpm._version import __version__
 from claude_mpm.cli import ArgumentRegistry, CommandRegistry, register_standard_commands
@@ -115,11 +116,10 @@ def _initialize_hook_service(args):
             logger.info(f"Hook service started on port {hook_manager.port}")
             print(f"Hook service started on port {hook_manager.port}")
             return hook_manager
-        else:
-            logger = get_logger("cli")
-            logger.warning("Failed to start hook service, continuing without hooks")
-            print("Failed to start hook service, continuing without hooks")
-            return None
+        logger = get_logger("cli")
+        logger.warning("Failed to start hook service, continuing without hooks")
+        print("Failed to start hook service, continuing without hooks")
+        return None
 
     except Exception as e:
         get_logger("cli").warning(

claude_mpm/config/__init__.py

@@ -27,19 +27,19 @@ from .paths import (
 
 __all__.extend(
     [
-        "paths",
+        "AgentConfig",
         "ClaudeMPMPaths",
-        "get_project_root",
-        "get_src_dir",
-        "get_claude_mpm_dir",
+        "ensure_src_in_path",
+        "get_agent_config",
         "get_agents_dir",
-        "get_services_dir",
+        "get_claude_mpm_dir",
         "get_config_dir",
+        "get_project_root",
+        "get_services_dir",
+        "get_src_dir",
         "get_version",
-        "ensure_src_in_path",
-        "AgentConfig",
-        "get_agent_config",
-        "set_agent_config",
+        "paths",
         "reset_agent_config",
+        "set_agent_config",
     ]
 )

claude_mpm/config/agent_config.py

@@ -14,7 +14,6 @@ This module handles:
 UPDATED: Migrated to use shared ConfigLoader pattern (TSK-0141)
 """
 
-import json
 import logging
 import os
 from dataclasses import dataclass, field
@@ -22,8 +21,8 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern
+from claude_mpm.core.unified_paths import get_path_manager
 
 logger = logging.getLogger(__name__)
 
@@ -170,11 +169,13 @@ class AgentConfig:
                     "enable_caching": True,
                     "validate_on_load": True,
                     "strict_validation": False,
-                    "precedence_mode": "override"
-                }
+                    "precedence_mode": "override",
+                },
             )
 
-            loaded_config = config_loader.load_config(pattern, cache_key=f"agent_{config_file}")
+            loaded_config = config_loader.load_config(
+                pattern, cache_key=f"agent_{config_file}"
+            )
             data = loaded_config.to_dict()
 
             config = cls()
@@ -343,15 +344,15 @@ class AgentConfig:
     def to_dict(self) -> Dict[str, Any]:
         """Convert configuration to dictionary for serialization."""
         return {
-            "project_agents_dir": str(self.project_agents_dir)
-            if self.project_agents_dir
-            else None,
-            "user_agents_dir": str(self.user_agents_dir)
-            if self.user_agents_dir
-            else None,
-            "system_agents_dir": str(self.system_agents_dir)
-            if self.system_agents_dir
-            else None,
+            "project_agents_dir": (
+                str(self.project_agents_dir) if self.project_agents_dir else None
+            ),
+            "user_agents_dir": (
+                str(self.user_agents_dir) if self.user_agents_dir else None
+            ),
+            "system_agents_dir": (
+                str(self.system_agents_dir) if self.system_agents_dir else None
+            ),
             "additional_paths": [str(p) for p in self.additional_paths],
             "precedence_mode": self.precedence_mode.value,
             "enable_project_agents": self.enable_project_agents,

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 Any, Dict, Optional
+from typing import Dict, Optional
 
 
 class ExperimentalFeatures:
@@ -64,7 +64,7 @@ class ExperimentalFeatures:
         """
         if self._config_file and self._config_file.exists():
             try:
-                with open(self._config_file, "r") as f:
+                with open(self._config_file) as f:
                     config = json.load(f)
                     experimental = config.get("experimental_features", {})
                     self._features.update(experimental)
@@ -125,7 +125,7 @@ class ExperimentalFeatures:
         accepted_file = Path.home() / ".claude-mpm" / ".experimental_accepted"
         if accepted_file.exists():
             try:
-                with open(accepted_file, "r") as f:
+                with open(accepted_file) as f:
                     accepted = json.load(f)
                     if feature in accepted.get("features", []):
                         return False
@@ -148,7 +148,7 @@ class ExperimentalFeatures:
 
         try:
             if accepted_file.exists():
-                with open(accepted_file, "r") as f:
+                with open(accepted_file) as f:
                     data = json.load(f)
             else:
                 data = {"features": [], "timestamp": {}}

claude_mpm/config/paths.py

@@ -9,7 +9,6 @@ without fragile parent.parent.parent patterns.
 """
 
 import logging
-import sys
 from pathlib import Path
 from typing import Optional, Union
 

claude_mpm/config/socketio_config.py

@@ -180,7 +180,7 @@ class ConfigManager:
         # Default to development
         return "development"
 
-    def get_config(self, environment: str = None) -> SocketIOConfig:
+    def get_config(self, environment: Optional[str] = None) -> SocketIOConfig:
         """Get configuration for the specified environment."""
         if environment is None:
             environment = self.detect_environment()
@@ -220,14 +220,14 @@ class ConfigManager:
         for config_path in self.config_search_paths:
             if config_path.exists():
                 try:
-                    with open(config_path, "r") as f:
+                    with open(config_path) as f:
                         return json.load(f)
                 except Exception as e:
                     print(f"Warning: Failed to load config from {config_path}: {e}")
 
         return None
 
-    def save_config(self, config: SocketIOConfig, path: str = None) -> bool:
+    def save_config(self, config: SocketIOConfig, path: Optional[str] = None) -> bool:
         """Save configuration to file."""
         import json
 
@@ -250,7 +250,7 @@ class ConfigManager:
 _config_manager = ConfigManager()
 
 
-def get_config(environment: str = None) -> SocketIOConfig:
+def get_config(environment: Optional[str] = None) -> SocketIOConfig:
     """Get Socket.IO configuration for the current or specified environment."""
     return _config_manager.get_config(environment)
 
@@ -266,5 +266,4 @@ def get_discovery_hosts(config: SocketIOConfig) -> List[str]:
     if config.host == "0.0.0.0":
         # If server binds to all interfaces, try localhost and 127.0.0.1 for discovery
         return ["localhost", "127.0.0.1"]
-    else:
-        return [config.host, "localhost", "127.0.0.1"]
+    return [config.host, "localhost", "127.0.0.1"]

claude_mpm/constants.py

@@ -4,7 +4,6 @@ Build number tracking is now enabled for all builds.
 """
 
 from enum import Enum
-from pathlib import Path
 
 
 class CLIPrefix(str, Enum):
@@ -20,7 +19,7 @@ class CLIPrefix(str, Enum):
         """Wrap a flag with the prefix."""
         if flag.startswith("--"):
             return f"--mpm:{flag[2:]}"
-        elif flag.startswith("-"):
+        if flag.startswith("-"):
             return f"-mpm:{flag[1:]}"
         return self.value + flag
 

claude_mpm/core/__init__.py

@@ -17,19 +17,19 @@ from .mixins import LoggerMixin
 from .service_registry import ServiceRegistry, get_service_registry, initialize_services
 
 __all__ = [
+    "AgentServiceFactory",
     "ClaudeRunner",
-    "LoggerMixin",
     "Config",
+    "ConfigurationFactory",
     "DIContainer",
-    "ServiceLifetime",
-    "get_container",
-    "ServiceRegistry",
-    "get_service_registry",
-    "initialize_services",
     "InjectableService",
+    "LoggerMixin",
     "ServiceFactory",
-    "AgentServiceFactory",
+    "ServiceLifetime",
+    "ServiceRegistry",
     "SessionManagerFactory",
-    "ConfigurationFactory",
+    "get_container",
     "get_factory_registry",
+    "get_service_registry",
+    "initialize_services",
 ]

claude_mpm/core/agent_name_normalizer.py

@@ -1,7 +1,7 @@
 """Agent name normalization utilities for consistent naming across the system."""
 
 import logging
-from typing import Dict, Optional
+from typing import Optional
 
 logger = logging.getLogger(__name__)
 

claude_mpm/core/agent_registry.py

@@ -11,8 +11,8 @@ This module provides:
 - Legacy function names for backwards compatibility
 """
 
-import os
-import sys
+import contextlib
+import warnings
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
@@ -20,13 +20,16 @@ from typing import Any, Dict, List, Optional, Set
 
 # Import from the unified agent registry system
 from .unified_agent_registry import AgentMetadata as UnifiedAgentMetadata
-from .unified_agent_registry import AgentTier, AgentType
+from .unified_agent_registry import (
+    AgentTier,
+    AgentType,
+)
 from .unified_agent_registry import discover_agents as unified_discover_agents
 from .unified_agent_registry import get_agent as unified_get_agent
-from .unified_agent_registry import get_agent_names as unified_get_agent_names
-from .unified_agent_registry import get_agent_registry
+from .unified_agent_registry import (
+    get_agent_registry,
+)
 from .unified_agent_registry import get_core_agents as unified_get_core_agents
-from .unified_agent_registry import get_project_agents as unified_get_project_agents
 from .unified_agent_registry import get_registry_stats as unified_get_registry_stats
 from .unified_agent_registry import (
     get_specialized_agents as unified_get_specialized_agents,
@@ -118,10 +121,9 @@ class SimpleAgentRegistry:
             or ".claude/agents" in str(agent_path)
         ):
             return "project"
-        elif "user" in str(agent_path) or str(Path.home()) in str(agent_path):
+        if "user" in str(agent_path) or str(Path.home()) in str(agent_path):
             return "user"
-        else:
-            return "system"
+        return "system"
 
     def _extract_specializations(self, agent_id: str) -> List[str]:
         """Extract specializations based on agent type (compatibility method)."""
@@ -236,7 +238,7 @@ class SimpleAgentRegistry:
     @property
     def specialized_agent_types(self) -> Set[str]:
         """Get specialized agent types beyond core (compatibility property)."""
-        all_types = set(metadata["type"] for metadata in self.agents.values())
+        all_types = {metadata["type"] for metadata in self.agents.values()}
         return all_types - self.core_agent_types
 
 
@@ -268,7 +270,6 @@ class AgentRegistryAdapter:
     def _initialize_registry(self):
         """Initialize the agent registry (compatibility method)."""
         # Registry is already initialized in __init__
-        pass
 
     def list_agents(self, **kwargs) -> Dict[str, Any]:
         """List available agents (compatibility method)."""
@@ -465,16 +466,12 @@ def list_agents(
     unified_agent_type = None
 
     if tier:
-        try:
+        with contextlib.suppress(ValueError):
             unified_tier = AgentTier(tier)
-        except ValueError:
-            pass
 
     if agent_type:
-        try:
+        with contextlib.suppress(ValueError):
             unified_agent_type = AgentType(agent_type)
-        except ValueError:
-            pass
 
     unified_agents = unified_list_agents(
         tier=unified_tier, agent_type=unified_agent_type
@@ -510,18 +507,18 @@ def get_registry_stats() -> Dict[str, Any]:
 
 # Export all public symbols
 __all__ = [
+    "AgentMetadata",
     "AgentRegistry",
     "AgentRegistryAdapter",
-    "AgentMetadata",
     "SimpleAgentRegistry",
     "create_agent_registry",
     "discover_agents",
-    "get_core_agent_types",
-    "get_specialized_agent_types",
-    "list_agents_all",
-    "list_agents",
-    "listAgents",  # Deprecated
     "discover_agents_sync",
     "get_agent",
+    "get_core_agent_types",
     "get_registry_stats",
+    "get_specialized_agent_types",
+    "listAgents",  # Deprecated
+    "list_agents",
+    "list_agents_all",
 ]

claude_mpm/core/agent_session_manager.py

@@ -5,7 +5,7 @@ import uuid
 from collections import defaultdict
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Dict, Optional, Tuple
+from typing import Dict, Optional
 
 from ..core.logger import get_logger
 
@@ -117,7 +117,7 @@ class AgentSessionManager:
             success: Whether task completed successfully
         """
         # Find which agent this session belongs to
-        for agent_type, sessions in self.agent_sessions.items():
+        for _agent_type, sessions in self.agent_sessions.items():
             if session_id in sessions:
                 sessions[session_id]["tasks_completed"].append(
                     {
@@ -219,7 +219,7 @@ class AgentSessionManager:
         session_file = self.session_dir / "agent_sessions.json"
         if session_file.exists():
             try:
-                with open(session_file, "r") as f:
+                with open(session_file) as f:
                     data = json.load(f)
                     self.agent_sessions = defaultdict(
                         dict, data.get("agent_sessions", {})

claude_mpm/core/base_service.py

@@ -28,10 +28,9 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Type, Union
+from typing import Any, Dict, List, Optional
 
 from .config import Config
-from .logger import setup_logging
 from .mixins import LoggerMixin
 
 
@@ -158,13 +157,11 @@ class BaseService(LoggerMixin, ABC):
             self._init_enhanced_features()
 
         # Check for quiet mode
-        default_log_level = "INFO"
         if os.getenv("CLAUDE_PM_QUIET_MODE") == "true":
-            default_log_level = "WARNING"
             self.logger.setLevel(logging.WARNING)
 
         # Only log if not in quiet mode
-        if not os.environ.get("CLAUDE_PM_QUIET_MODE", "").lower() == "true":
+        if os.environ.get("CLAUDE_PM_QUIET_MODE", "").lower() != "true":
             self.logger.debug(f"Initialized {self.name} service")
 
     def _init_enhanced_features(self):
@@ -239,7 +236,7 @@ class BaseService(LoggerMixin, ABC):
             self.logger.error(f"Failed to start service {self.name}: {e}")
             self._health = ServiceHealth(
                 status="unhealthy",
-                message=f"Startup failed: {str(e)}",
+                message=f"Startup failed: {e!s}",
                 timestamp=datetime.now().isoformat(),
                 checks={"startup": False},
             )
@@ -406,7 +403,7 @@ class BaseService(LoggerMixin, ABC):
             self.logger.error(f"Health check failed for {self.name}: {e}")
             self._health = ServiceHealth(
                 status="unhealthy",
-                message=f"Health check error: {str(e)}",
+                message=f"Health check error: {e!s}",
                 timestamp=datetime.now().isoformat(),
                 checks={"health_check_error": True},
             )
@@ -624,10 +621,9 @@ class BaseService(LoggerMixin, ABC):
         if (
             self._circuit_breaker.failure_count
             >= self._circuit_breaker.failure_threshold
-        ):
-            if self._circuit_breaker.state != "open":
-                self._circuit_breaker.state = "open"
-                self.logger.warning(f"Circuit breaker opened for service {self.name}")
+        ) and self._circuit_breaker.state != "open":
+            self._circuit_breaker.state = "open"
+            self.logger.warning(f"Circuit breaker opened for service {self.name}")
 
     def _record_circuit_success(self) -> None:
         """Record circuit breaker success."""
@@ -706,7 +702,6 @@ class BaseService(LoggerMixin, ABC):
     async def _initialize_dependencies(self) -> None:
         """Initialize service dependencies (enhanced feature)."""
         # Override in subclasses for specific dependency setup
-        pass
 
     async def _register_with_health_monitor(self) -> None:
         """Register service with health monitor (enhanced feature)."""
@@ -729,12 +724,10 @@ class BaseService(LoggerMixin, ABC):
     @abstractmethod
     async def _initialize(self) -> None:
         """Initialize the service. Must be implemented by subclasses."""
-        pass
 
     @abstractmethod
     async def _cleanup(self) -> None:
         """Cleanup service resources. Must be implemented by subclasses."""
-        pass
 
     async def _health_check(self) -> Dict[str, bool]:
         """
@@ -816,7 +809,6 @@ class BaseService(LoggerMixin, ABC):
         - Store aggregated data, not raw events
         - Consider metric cardinality
         """
-        pass
 
     # Utility methods
 

claude_mpm/core/cache.py

@@ -14,15 +14,13 @@ WHY file system caching:
 """
 
 import asyncio
-import hashlib
 import json
 import pickle
 import threading
-import time
 from collections import OrderedDict
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
-from typing import Any, Callable, Dict, Optional, Tuple, TypeVar, Union
+from datetime import datetime
+from typing import Any, Callable, Dict, Optional, TypeVar, Union
 
 from ..core.logger import get_logger
 
@@ -127,7 +125,7 @@ class FileSystemCache:
         """Estimate memory size of a value in bytes."""
         if isinstance(value, (str, bytes)):
             return len(value)
-        elif isinstance(value, (list, dict)):
+        if isinstance(value, (list, dict)):
             # Rough estimate using JSON serialization
             try:
                 return len(json.dumps(value))
@@ -353,7 +351,7 @@ class FileSystemCache:
 
         with self._lock:
             matching_keys = [
-                key for key in self._cache.keys() if fnmatch.fnmatch(key, pattern)
+                key for key in self._cache if fnmatch.fnmatch(key, pattern)
             ]
 
             count = 0