claude-mpm 4.5.0__py3-none-any.whl → 4.5.5__py3-none-any.whl

claude_mpm/services/unified/config_strategies/__init__.py

@@ -97,55 +97,55 @@ ConfigLoader = UnifiedConfigService
 
 # Export all public APIs
 __all__ = [
-    # Main service
-    "UnifiedConfigService",
-    "unified_config",
-    # Strategies
-    "FileLoaderStrategy",
-    "ValidationStrategy",
-    "ErrorHandlingStrategy",
-    "ContextStrategy",
+    "CompositeFileLoader",
+    "ConfigContext",
     # Core types
     "ConfigFormat",
-    "ConfigContext",
+    "ConfigLoader",
+    "ConfigManager",
     "ConfigMetadata",
-    "IConfigStrategy",
-    # File loading
-    "LoaderType",
-    "FileLoadContext",
-    "StructuredFileLoader",
+    "ConfigMigration",
+    # Schema
+    "ConfigSchema",
+    # Backward compatibility
+    "ConfigService",
+    "ContextLifecycle",
+    # Context management
+    "ContextScope",
+    "ContextStrategy",
     "EnvironmentFileLoader",
-    "ProgrammaticFileLoader",
-    "LegacyFileLoader",
-    "CompositeFileLoader",
-    # Validation
-    "ValidationRule",
-    "ValidationResult",
-    "ValidationType",
+    "ErrorCategory",
     # Error handling
     "ErrorContext",
     "ErrorHandlingResult",
-    "ErrorCategory",
+    "ErrorHandlingStrategy",
     "ErrorSeverity",
-    # Context management
-    "ContextScope",
-    "ContextLifecycle",
+    "FileLoadContext",
+    # Strategies
+    "FileLoaderStrategy",
     "HierarchicalContextManager",
-    "ScopedConfigManager",
-    # Schema
-    "ConfigSchema",
-    "SchemaProperty",
+    "IConfigStrategy",
+    "LegacyFileLoader",
+    # File loading
+    "LoaderType",
+    "ProgrammaticFileLoader",
     "SchemaBuilder",
-    "SchemaValidator",
+    "SchemaFormat",
+    "SchemaProperty",
     "SchemaRegistry",
-    "ConfigMigration",
-    "TypedConfig",
     "SchemaType",
-    "SchemaFormat",
-    # Backward compatibility
-    "ConfigService",
-    "ConfigManager",
-    "ConfigLoader",
+    "SchemaValidator",
+    "ScopedConfigManager",
+    "StructuredFileLoader",
+    "TypedConfig",
+    # Main service
+    "UnifiedConfigService",
+    "ValidationResult",
+    # Validation
+    "ValidationRule",
+    "ValidationStrategy",
+    "ValidationType",
+    "unified_config",
 ]
 
 

claude_mpm/services/unified/config_strategies/config_schema.py

@@ -165,9 +165,8 @@ class SchemaBuilder:
         prop = SchemaProperty(type=type, **kwargs)
         self.schema.properties[name] = prop
 
-        if kwargs.get("required", False):
-            if name not in self.schema.required:
-                self.schema.required.append(name)
+        if kwargs.get("required", False) and name not in self.schema.required:
+            self.schema.required.append(name)
 
         return self
 
@@ -387,9 +386,8 @@ class SchemaValidator:
             if not re.match(prop.pattern, value):
                 self.errors.append(f"{path}: does not match pattern {prop.pattern}")
 
-        if prop.format:
-            if not self._validate_format(value, prop.format):
-                self.errors.append(f"{path}: invalid format {prop.format.value}")
+        if prop.format and not self._validate_format(value, prop.format):
+            self.errors.append(f"{path}: invalid format {prop.format.value}")
 
     def _validate_array(self, value: List, prop: SchemaProperty, path: str):
         """Validate array constraints"""
@@ -432,24 +430,22 @@ class SchemaValidator:
                 if req not in value:
                     self.errors.append(f"{path}: required property '{req}' missing")
 
-        if not prop.additional_properties:
-            if prop.properties:
-                extra = set(value.keys()) - set(prop.properties.keys())
-                if extra:
-                    self.errors.append(
-                        f"{path}: additional properties not allowed: {extra}"
-                    )
+        if not prop.additional_properties and prop.properties:
+            extra = set(value.keys()) - set(prop.properties.keys())
+            if extra:
+                self.errors.append(
+                    f"{path}: additional properties not allowed: {extra}"
+                )
 
     def _validate_dependencies(self, config: Dict, dependencies: Dict):
         """Validate field dependencies"""
         for field, deps in dependencies.items():
-            if field in config:
-                if isinstance(deps, list):
-                    for dep in deps:
-                        if dep not in config:
-                            self.errors.append(
-                                f"Field '{field}' requires '{dep}' to be present"
-                            )
+            if field in config and isinstance(deps, list):
+                for dep in deps:
+                    if dep not in config:
+                        self.errors.append(
+                            f"Field '{field}' requires '{dep}' to be present"
+                        )
 
     def _validate_format(self, value: str, format: SchemaFormat) -> bool:
         """Validate string format"""
@@ -602,7 +598,7 @@ class ConfigMigration:
 
         # Build graph of migrations
         graph = {}
-        for from_v, to_v in self.migrations.keys():
+        for from_v, to_v in self.migrations:
             if from_v not in graph:
                 graph[from_v] = []
             graph[from_v].append(to_v)
@@ -620,7 +616,7 @@ class ConfigMigration:
             for next_v in graph.get(current, []):
                 if next_v not in visited:
                     visited.add(next_v)
-                    queue.append((next_v, path + [next_v]))
+                    queue.append((next_v, [*path, next_v]))
 
         return None
 

claude_mpm/services/unified/config_strategies/context_strategy.py

@@ -136,12 +136,11 @@ class HierarchicalContextManager(BaseContextManager):
             self.contexts[context_id] = metadata
 
             # Update hierarchy
-            if parent_id:
-                if parent_id in self.contexts:
-                    self.contexts[parent_id].children.append(context_id)
-                    if parent_id not in self.context_hierarchy:
-                        self.context_hierarchy[parent_id] = []
-                    self.context_hierarchy[parent_id].append(context_id)
+            if parent_id and parent_id in self.contexts:
+                self.contexts[parent_id].children.append(context_id)
+                if parent_id not in self.context_hierarchy:
+                    self.context_hierarchy[parent_id] = []
+                self.context_hierarchy[parent_id].append(context_id)
 
             # Initialize context config
             self.configs[context_id] = ContextConfig(context_id=context_id, data={})
@@ -511,7 +510,7 @@ class CachingContextManager:
         """Invalidate all cached values for context"""
         with self._lock:
             keys_to_remove = [
-                k for k in self.cache.keys() if k.startswith(f"{context_id}:")
+                k for k in self.cache if k.startswith(f"{context_id}:")
             ]
 
             for key in keys_to_remove:

claude_mpm/services/unified/config_strategies/error_handling_strategy.py

@@ -86,7 +86,7 @@ class BaseErrorHandler(ABC):
     def handle(self, context: ErrorContext) -> ErrorHandlingResult:
         """Handle the error"""
 
-    def log_error(self, context: ErrorContext, message: str = None):
+    def log_error(self, context: ErrorContext, message: Optional[str] = None):
         """Log error with appropriate level"""
         log_message = message or str(context.error)
 
@@ -309,8 +309,7 @@ class ParsingErrorHandler(BaseErrorHandler):
         # Remove single-line comments
         content = re.sub(r"//.*?$", "", content, flags=re.MULTILINE)
         # Remove multi-line comments
-        content = re.sub(r"/\*.*?\*/", "", content, flags=re.DOTALL)
-        return content
+        return re.sub(r"/\*.*?\*/", "", content, flags=re.DOTALL)
 
     def _fix_json_quotes(self, content: str) -> str:
         """Fix quote issues in JSON"""
@@ -319,24 +318,21 @@ class ParsingErrorHandler(BaseErrorHandler):
         # Replace single quotes with double quotes (careful with values)
         # This is a simple approach - more sophisticated parsing might be needed
         content = re.sub(r"'([^']*)':", r'"\1":', content)  # Keys
-        content = re.sub(r":\s*'([^']*)'", r': "\1"', content)  # Values
-        return content
+        return re.sub(r":\s*'([^']*)'", r': "\1"', content)  # Values
 
     def _fix_json_trailing_commas(self, content: str) -> str:
         """Remove trailing commas"""
         import re
 
         content = re.sub(r",\s*}", "}", content)
-        content = re.sub(r",\s*]", "]", content)
-        return content
+        return re.sub(r",\s*]", "]", content)
 
     def _fix_json_unquoted_keys(self, content: str) -> str:
         """Add quotes to unquoted keys"""
         import re
 
         # Match unquoted keys (word characters followed by colon)
-        content = re.sub(r"(\w+):", r'"\1":', content)
-        return content
+        return re.sub(r"(\w+):", r'"\1":', content)
 
     def _parse_lenient_json(
         self, content: str, result: ErrorHandlingResult
@@ -875,7 +871,7 @@ class ErrorHandlingStrategy(IConfigStrategy):
 
     def _categorize_error(self, error: Exception) -> ErrorCategory:
         """Categorize the error type"""
-        error_type = type(error)
+        type(error)
 
         # File I/O errors
         if isinstance(error, (FileNotFoundError, PermissionError, IOError, OSError)):

claude_mpm/services/unified/config_strategies/file_loader_strategy.py

@@ -198,8 +198,7 @@ class StructuredFileLoader(BaseFileLoader):
         # Remove single-line comments
         content = re.sub(r"//.*?$", "", content, flags=re.MULTILINE)
         # Remove multi-line comments
-        content = re.sub(r"/\*.*?\*/", "", content, flags=re.DOTALL)
-        return content
+        return re.sub(r"/\*.*?\*/", "", content, flags=re.DOTALL)
 
     def _recover_json(self, content: str) -> Dict[str, Any]:
         """Attempt to recover from malformed JSON"""
@@ -409,7 +408,7 @@ class EnvironmentFileLoader(BaseFileLoader):
             pass
 
         # JSON array or object
-        if value.startswith("[") or value.startswith("{"):
+        if value.startswith(("[", "{")):
             try:
                 return json.loads(value)
             except:
@@ -492,10 +491,7 @@ class ProgrammaticFileLoader(BaseFileLoader):
             config = module.CONFIG
         elif hasattr(module, "config"):
             # config dict or function
-            if callable(module.config):
-                config = module.config()
-            else:
-                config = module.config
+            config = module.config() if callable(module.config) else module.config
         elif hasattr(module, "get_config"):
             # get_config function
             config = module.get_config()
@@ -594,7 +590,7 @@ class LegacyFileLoader(BaseFileLoader):
             line = line.strip()
 
             # Skip comments and empty lines
-            if not line or line.startswith("#") or line.startswith("!"):
+            if not line or line.startswith(("#", "!")):
                 continue
 
             # Handle line continuation
@@ -765,7 +761,7 @@ class CompositeFileLoader(BaseFileLoader):
     def _load_single(self, context: FileLoadContext) -> Dict[str, Any]:
         """Load single configuration file"""
         # Find appropriate loader
-        for loader_type, loader in self.loaders.items():
+        for _loader_type, loader in self.loaders.items():
             if loader.supports(context.format):
                 return loader.load(context)
 

claude_mpm/services/unified/config_strategies/unified_config_service.py

@@ -273,7 +273,7 @@ class UnifiedConfigService:
         """Get configuration value by key with context awareness"""
         # Check specific context first
         if context:
-            for cache_key, config in self._contexts[context].items():
+            for _cache_key, config in self._contexts[context].items():
                 if key in config:
                     return config[key]
 
@@ -579,9 +579,7 @@ class UnifiedConfigService:
             return False
         if not self._validate_pattern(config, schema):
             return False
-        if not self._validate_enum(config, schema):
-            return False
-        return True
+        return self._validate_enum(config, schema)
 
     def _validate_dependency(self, config: Dict[str, Any], schema: Dict) -> bool:
         """Validate field dependencies"""

claude_mpm/services/unified/config_strategies/validation_strategy.py

@@ -73,7 +73,7 @@ class BaseValidator(ABC):
         """Perform validation"""
 
     def _create_result(
-        self, valid: bool, message: str = None, severity: str = "error"
+        self, valid: bool, message: Optional[str] = None, severity: str = "error"
     ) -> ValidationResult:
         """Create validation result"""
         result = ValidationResult(valid=valid)

claude_mpm/services/unified/deployment_strategies/__init__.py

@@ -46,22 +46,22 @@ from .utils import (
 from .vercel import VercelDeploymentStrategy
 
 __all__ = [
-    # Base classes
-    "DeploymentStrategy",
+    "AWSDeploymentStrategy",
     "DeploymentContext",
     "DeploymentResult",
+    # Base classes
+    "DeploymentStrategy",
+    "DockerDeploymentStrategy",
+    "GitDeploymentStrategy",
     # Strategy implementations
     "LocalDeploymentStrategy",
-    "VercelDeploymentStrategy",
     "RailwayDeploymentStrategy",
-    "AWSDeploymentStrategy",
-    "DockerDeploymentStrategy",
-    "GitDeploymentStrategy",
+    "VercelDeploymentStrategy",
+    "prepare_deployment_artifact",
+    "rollback_deployment",
     # Utilities
     "validate_deployment_config",
-    "prepare_deployment_artifact",
     "verify_deployment_health",
-    "rollback_deployment",
 ]
 
 # Strategy registry for automatic discovery

claude_mpm/services/unified/deployment_strategies/local.py

@@ -466,10 +466,7 @@ class LocalDeploymentStrategy(DeploymentStrategy):
         deployed = []
 
         for artifact in artifacts:
-            if target_path.is_dir():
-                dest = target_path / artifact.name
-            else:
-                dest = target_path
+            dest = target_path / artifact.name if target_path.is_dir() else target_path
 
             shutil.copy2(artifact, dest)
             deployed.append(dest)
@@ -556,7 +553,7 @@ class LocalDeploymentStrategy(DeploymentStrategy):
     ) -> bool:
         """Verify template deployment."""
         # Check that template variables were replaced
-        variables = context.config.get("variables", {})
+        context.config.get("variables", {})
 
         if deployed_path.is_file():
             content = deployed_path.read_text()

claude_mpm/services/unified/deployment_strategies/utils.py

@@ -76,9 +76,8 @@ def validate_deployment_config(config: Dict[str, Any]) -> List[str]:
             errors.append(f"Source does not exist: {source_path}")
 
     # Version format validation
-    if "version" in config:
-        if not validate_version_format(config["version"]):
-            errors.append(f"Invalid version format: {config['version']}")
+    if "version" in config and not validate_version_format(config["version"]):
+        errors.append(f"Invalid version format: {config['version']}")
 
     # Environment variables validation
     if "env" in config:
@@ -267,24 +266,21 @@ def verify_deployment_health(
 
     try:
         # Existence check
-        if "existence" in checks:
-            if "deployed_path" in deployment_info:
-                path = Path(deployment_info["deployed_path"])
-                health["checks"]["exists"] = path.exists()
+        if "existence" in checks and "deployed_path" in deployment_info:
+            path = Path(deployment_info["deployed_path"])
+            health["checks"]["exists"] = path.exists()
 
         # Accessibility check
-        if "accessibility" in checks:
-            if "deployment_url" in deployment_info:
-                health["checks"]["accessible"] = check_url_accessibility(
-                    deployment_info["deployment_url"]
-                )
+        if "accessibility" in checks and "deployment_url" in deployment_info:
+            health["checks"]["accessible"] = check_url_accessibility(
+                deployment_info["deployment_url"]
+            )
 
         # Integrity check
-        if "integrity" in checks:
-            if "checksum" in deployment_info:
-                health["checks"]["integrity"] = verify_checksum(
-                    deployment_info.get("deployed_path"), deployment_info["checksum"]
-                )
+        if "integrity" in checks and "checksum" in deployment_info:
+            health["checks"]["integrity"] = verify_checksum(
+                deployment_info.get("deployed_path"), deployment_info["checksum"]
+            )
 
         # Service-specific checks
         if deployment_type == "docker":

claude_mpm/services/unified/deployment_strategies/vercel.py

@@ -88,9 +88,8 @@ class VercelDeploymentStrategy(DeploymentStrategy):
         config = context.config
 
         # Check project name
-        if not config.get("project_name"):
-            if not vercel_json.exists():
-                errors.append("Project name required when vercel.json is missing")
+        if not config.get("project_name") and not vercel_json.exists():
+            errors.append("Project name required when vercel.json is missing")
 
         # Validate environment variables
         env_vars = config.get("env", {})
@@ -275,7 +274,7 @@ class VercelDeploymentStrategy(DeploymentStrategy):
                 if context.config.get("token"):
                     cmd.extend(["--token", context.config["token"]])
 
-                result = subprocess.run(
+                subprocess.run(
                     cmd,
                     capture_output=True,
                     text=True,
@@ -359,7 +358,7 @@ class VercelDeploymentStrategy(DeploymentStrategy):
     def _check_vercel_cli(self) -> bool:
         """Check if Vercel CLI is installed."""
         try:
-            result = subprocess.run(
+            subprocess.run(
                 ["vercel", "--version"],
                 capture_output=True,
                 text=True,
@@ -372,7 +371,7 @@ class VercelDeploymentStrategy(DeploymentStrategy):
     def _check_vercel_auth(self) -> bool:
         """Check if authenticated with Vercel."""
         try:
-            result = subprocess.run(
+            subprocess.run(
                 ["vercel", "whoami"],
                 capture_output=True,
                 text=True,

claude_mpm/services/unified/unified_analyzer.py

@@ -455,7 +455,7 @@ class UnifiedAnalyzer(IAnalyzerService, IUnifiedService):
             return options["type"]
 
         # Infer from target type
-        if isinstance(target, Path) or isinstance(target, str):
+        if isinstance(target, (Path, str)):
             path = Path(target)
             if path.is_file():
                 # Determine by file extension

claude_mpm/utils/common.py

@@ -339,12 +339,9 @@ def run_command_safe(
         CompletedProcess result
     """
     try:
-        if isinstance(command, str):
-            shell = True
-        else:
-            shell = False
+        shell = bool(isinstance(command, str))
 
-        result = subprocess.run(
+        return subprocess.run(
             command,
             shell=shell,
             cwd=cwd,
@@ -354,7 +351,6 @@ def run_command_safe(
             timeout=timeout,
             env=env,
         )
-        return result
     except subprocess.TimeoutExpired:
         logger.error(f"Command timed out: {command}")
         raise
@@ -515,7 +511,7 @@ def import_from_string(import_path: str, fallback: Any = None) -> Any:
 # ==============================================================================
 
 
-def deprecated(replacement: str = None):
+def deprecated(replacement: Optional[str] = None):
     """
     Decorator to mark functions as deprecated.
 

claude_mpm/utils/database_connector.py

@@ -58,26 +58,23 @@ class DatabaseConnector:
         # Check MySQL drivers
         for package_name, import_name in self.MYSQL_DRIVERS:
             driver = self._try_import(import_name)
-            if driver:
-                if "mysql" not in self.available_drivers:
-                    self.available_drivers["mysql"] = (package_name, driver)
-                    logger.info(f"MySQL driver available: {package_name}")
+            if driver and "mysql" not in self.available_drivers:
+                self.available_drivers["mysql"] = (package_name, driver)
+                logger.info(f"MySQL driver available: {package_name}")
 
         # Check PostgreSQL drivers
         for package_name, import_name in self.POSTGRESQL_DRIVERS:
             driver = self._try_import(import_name)
-            if driver:
-                if "postgresql" not in self.available_drivers:
-                    self.available_drivers["postgresql"] = (package_name, driver)
-                    logger.info(f"PostgreSQL driver available: {package_name}")
+            if driver and "postgresql" not in self.available_drivers:
+                self.available_drivers["postgresql"] = (package_name, driver)
+                logger.info(f"PostgreSQL driver available: {package_name}")
 
         # Check Oracle drivers
         for package_name, import_name in self.ORACLE_DRIVERS:
             driver = self._try_import(import_name)
-            if driver:
-                if "oracle" not in self.available_drivers:
-                    self.available_drivers["oracle"] = (package_name, driver)
-                    logger.info(f"Oracle driver available: {package_name}")
+            if driver and "oracle" not in self.available_drivers:
+                self.available_drivers["oracle"] = (package_name, driver)
+                logger.info(f"Oracle driver available: {package_name}")
 
     def _try_import(self, module_name: str) -> Optional[Any]:
         """

{claude_mpm-4.5.0.dist-info → claude_mpm-4.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.5.0
+Version: 4.5.5
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team
@@ -54,7 +54,7 @@ Requires-Dist: mcp>=0.1.0; extra == "mcp"
 Requires-Dist: mcp-vector-search>=0.1.0; extra == "mcp"
 Requires-Dist: mcp-browser>=0.1.0; extra == "mcp"
 Requires-Dist: mcp-ticketer>=0.1.0; extra == "mcp"
-Requires-Dist: kuzu-memory>=1.1.1; extra == "mcp"
+Requires-Dist: kuzu-memory>=1.1.5; extra == "mcp"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"