claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/services/agents/deployment/pipeline/steps/agent_processing_step.py

@@ -3,13 +3,14 @@
 import time
 from pathlib import Path
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.services.agents.deployment.processors import (
     AgentDeploymentContext,
     AgentDeploymentResult,
     AgentProcessor,
 )
 
-from .base_step import BaseDeploymentStep, StepResult, StepStatus
+from .base_step import BaseDeploymentStep, StepResult
 
 
 class AgentProcessingStep(BaseDeploymentStep):
@@ -37,7 +38,7 @@ class AgentProcessingStep(BaseDeploymentStep):
             if not context.template_files:
                 self.logger.warning("No template files to process")
                 return StepResult(
-                    status=StepStatus.SKIPPED,
+                    status=OperationResult.SKIPPED,
                     message="No template files found to process",
                     execution_time=time.time() - start_time,
                 )
@@ -103,13 +104,13 @@ class AgentProcessingStep(BaseDeploymentStep):
 
             # Determine step status
             if failed_count == 0:
-                status = StepStatus.SUCCESS
+                status = OperationResult.SUCCESS
                 message = f"Successfully processed {processed_count} agents in {execution_time:.3f}s"
             elif processed_count > 0:
-                status = StepStatus.WARNING
+                status = OperationResult.WARNING
                 message = f"Processed {processed_count} agents with {failed_count} failures in {execution_time:.3f}s"
             else:
-                status = StepStatus.FAILURE
+                status = OperationResult.FAILED
                 message = f"Failed to process any agents ({failed_count} failures) in {execution_time:.3f}s"
 
             self.logger.info(message)
@@ -127,7 +128,7 @@ class AgentProcessingStep(BaseDeploymentStep):
             context.add_error(error_msg)
 
             return StepResult(
-                status=StepStatus.FAILURE,
+                status=OperationResult.FAILED,
                 message=error_msg,
                 error=e,
                 execution_time=execution_time,
@@ -229,7 +230,7 @@ class AgentProcessingStep(BaseDeploymentStep):
                 cwd = Path.cwd()
                 if str(cwd) in template_str:
                     return "project"
-            except:
+            except Exception:
                 pass
 
         # Check if it's a user agent

claude_mpm/services/agents/deployment/pipeline/steps/base_step.py

@@ -2,26 +2,17 @@
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from enum import Enum
 from typing import Optional
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.logger import get_logger
 
 
-class StepStatus(Enum):
-    """Status of a pipeline step execution."""
-
-    SUCCESS = "success"
-    FAILURE = "failure"
-    SKIPPED = "skipped"
-    WARNING = "warning"
-
-
 @dataclass
 class StepResult:
     """Result of executing a pipeline step."""
 
-    status: StepStatus
+    status: OperationResult
     message: Optional[str] = None
     error: Optional[Exception] = None
     execution_time: Optional[float] = None
@@ -29,22 +20,22 @@ class StepResult:
     @property
     def is_success(self) -> bool:
         """Check if the step was successful."""
-        return self.status == StepStatus.SUCCESS
+        return self.status == OperationResult.SUCCESS
 
     @property
     def is_failure(self) -> bool:
         """Check if the step failed."""
-        return self.status == StepStatus.FAILURE
+        return self.status == OperationResult.FAILED
 
     @property
     def is_skipped(self) -> bool:
         """Check if the step was skipped."""
-        return self.status == StepStatus.SKIPPED
+        return self.status == OperationResult.SKIPPED
 
     @property
     def is_warning(self) -> bool:
         """Check if the step completed with warnings."""
-        return self.status == StepStatus.WARNING
+        return self.status == OperationResult.WARNING
 
 
 class BaseDeploymentStep(ABC):
@@ -67,7 +58,7 @@ class BaseDeploymentStep(ABC):
         self.logger = get_logger(f"{__name__}.{self.__class__.__name__}")
 
     @abstractmethod
-    def execute(self, context) -> StepResult:
+    def execute(self, context) -> "StepResult":
         """Execute this deployment step.
 
         Args:

claude_mpm/services/agents/deployment/pipeline/steps/configuration_step.py

@@ -3,8 +3,9 @@
 import time
 
 from claude_mpm.core.config import Config
+from claude_mpm.core.enums import OperationResult
 
-from .base_step import BaseDeploymentStep, StepResult, StepStatus
+from .base_step import BaseDeploymentStep, StepResult
 
 
 class ConfigurationLoadStep(BaseDeploymentStep):
@@ -54,7 +55,7 @@ class ConfigurationLoadStep(BaseDeploymentStep):
             context.step_timings[self.name] = execution_time
 
             return StepResult(
-                status=StepStatus.SUCCESS,
+                status=OperationResult.SUCCESS,
                 message=f"Configuration loaded successfully in {execution_time:.3f}s",
                 execution_time=execution_time,
             )
@@ -68,7 +69,7 @@ class ConfigurationLoadStep(BaseDeploymentStep):
             context.add_error(error_msg)
 
             return StepResult(
-                status=StepStatus.FAILURE,
+                status=OperationResult.FAILED,
                 message=error_msg,
                 error=e,
                 execution_time=execution_time,

claude_mpm/services/agents/deployment/pipeline/steps/target_directory_step.py

@@ -3,7 +3,9 @@
 import time
 from pathlib import Path
 
-from .base_step import BaseDeploymentStep, StepResult, StepStatus
+from claude_mpm.core.enums import OperationResult
+
+from .base_step import BaseDeploymentStep, StepResult
 
 
 class TargetDirectorySetupStep(BaseDeploymentStep):
@@ -48,10 +50,10 @@ class TargetDirectorySetupStep(BaseDeploymentStep):
             try:
                 test_file.write_text("test")
                 test_file.unlink()
-            except Exception:
+            except Exception as e:
                 raise PermissionError(
                     f"Target directory is not writable: {context.actual_target_dir}"
-                )
+                ) from e
 
             self.logger.info(f"Target directory set up: {context.actual_target_dir}")
 
@@ -59,7 +61,7 @@ class TargetDirectorySetupStep(BaseDeploymentStep):
             context.step_timings[self.name] = execution_time
 
             return StepResult(
-                status=StepStatus.SUCCESS,
+                status=OperationResult.SUCCESS,
                 message=f"Target directory set up at {context.actual_target_dir} in {execution_time:.3f}s",
                 execution_time=execution_time,
             )
@@ -73,7 +75,7 @@ class TargetDirectorySetupStep(BaseDeploymentStep):
             context.add_error(error_msg)
 
             return StepResult(
-                status=StepStatus.FAILURE,
+                status=OperationResult.FAILED,
                 message=error_msg,
                 error=e,
                 execution_time=execution_time,

claude_mpm/services/agents/deployment/pipeline/steps/validation_step.py

@@ -2,9 +2,10 @@
 
 import time
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.services.agents.deployment.validation import DeploymentValidator
 
-from .base_step import BaseDeploymentStep, StepResult, StepStatus
+from .base_step import BaseDeploymentStep, StepResult
 
 
 class ValidationStep(BaseDeploymentStep):
@@ -49,13 +50,13 @@ class ValidationStep(BaseDeploymentStep):
 
             # Determine step status
             if not validation_result.is_valid:
-                status = StepStatus.FAILURE
+                status = OperationResult.FAILED
                 message = f"Validation failed with {validation_result.error_count} errors in {execution_time:.3f}s"
             elif validation_result.has_warnings:
-                status = StepStatus.WARNING
+                status = OperationResult.WARNING
                 message = f"Validation completed with {validation_result.warning_count} warnings in {execution_time:.3f}s"
             else:
-                status = StepStatus.SUCCESS
+                status = OperationResult.SUCCESS
                 message = f"Validation passed successfully in {execution_time:.3f}s"
 
             self.logger.info(message)
@@ -73,7 +74,7 @@ class ValidationStep(BaseDeploymentStep):
             context.add_error(error_msg)
 
             return StepResult(
-                status=StepStatus.FAILURE,
+                status=OperationResult.FAILED,
                 message=error_msg,
                 error=e,
                 execution_time=execution_time,

claude_mpm/services/agents/deployment/refactored_agent_deployment_service.py

@@ -3,6 +3,7 @@
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
+from claude_mpm.core.enums import OperationResult
 from claude_mpm.core.interfaces import AgentDeploymentInterface
 from claude_mpm.core.logger import get_logger
 
@@ -116,8 +117,10 @@ class RefactoredAgentDeploymentService(AgentDeploymentInterface):
             )
 
             # Ensure success field is present
-            if "success" not in results:
-                results["success"] = not bool(results.get("errors", []))
+            if OperationResult.SUCCESS.value not in results:
+                results[OperationResult.SUCCESS.value] = not bool(
+                    results.get("errors", [])
+                )
 
             self.logger.info(f"Deployment completed: {results.get('success', False)}")
             return results
@@ -125,7 +128,7 @@ class RefactoredAgentDeploymentService(AgentDeploymentInterface):
         except Exception as e:
             self.logger.error(f"Deployment failed: {e}", exc_info=True)
             return {
-                "success": False,
+                OperationResult.SUCCESS.value: False,
                 "error": str(e),
                 "deployed": [],
                 "updated": [],
@@ -235,7 +238,7 @@ class RefactoredAgentDeploymentService(AgentDeploymentInterface):
             # Build status information
             return {
                 "service_version": "refactored-1.0.0",
-                "status": "ready",
+                "status": OperationResult.SUCCESS,
                 "templates_dir": str(self.templates_dir),
                 "base_agent_path": str(self.base_agent_path),
                 "working_directory": str(self.working_directory),
@@ -255,7 +258,7 @@ class RefactoredAgentDeploymentService(AgentDeploymentInterface):
             self.logger.error(f"Failed to get deployment status: {e}", exc_info=True)
             return {
                 "service_version": "refactored-1.0.0",
-                "status": "error",
+                "status": OperationResult.ERROR,
                 "error": str(e),
             }
 
@@ -301,7 +304,7 @@ class RefactoredAgentDeploymentService(AgentDeploymentInterface):
         except Exception as e:
             self.logger.error(f"Async deployment failed: {e}", exc_info=True)
             return {
-                "success": False,
+                OperationResult.SUCCESS.value: False,
                 "error": str(e),
                 "deployed": [],
                 "updated": [],

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/deployment/validation/__init__.py

@@ -5,10 +5,12 @@ including template validation, agent file validation, and
 deployment environment validation.
 """
 
+from claude_mpm.core.enums import ValidationSeverity
+
 from .agent_validator import AgentValidator
 from .deployment_validator import DeploymentValidator
 from .template_validator import TemplateValidator
-from .validation_result import ValidationResult, ValidationSeverity
+from .validation_result import ValidationResult
 
 __all__ = [
     "AgentValidator",

claude_mpm/services/agents/deployment/validation/template_validator.py

@@ -31,7 +31,7 @@ class TemplateValidator:
             "agent_type": str,
             "metadata": dict,
             "capabilities": dict,
-            "instructions": dict,
+            "instructions": str,
         }
 
         # Required metadata fields
@@ -45,13 +45,10 @@ class TemplateValidator:
         # Required capabilities fields
         self.required_capabilities_fields = {
             "model": str,
-            "tools": list,
+            "resource_tier": str,
         }
 
-        # Required instructions fields
-        self.required_instructions_fields = {
-            "system_prompt": str,
-        }
+        # Instructions is now a string field, not a dictionary
 
     def validate_template_file(self, template_file: Path) -> ValidationResult:
         """Validate a template file.
@@ -90,9 +87,11 @@ class TemplateValidator:
             if "capabilities" in template_data:
                 self._validate_capabilities(template_data["capabilities"], result)
 
-            # Validate instructions
+            # Validate instructions (now a string field)
             if "instructions" in template_data:
-                self._validate_instructions(template_data["instructions"], result)
+                self._validate_instructions_string(
+                    template_data["instructions"], result
+                )
 
             # Validate agent ID format
             if "agent_id" in template_data:
@@ -191,10 +190,19 @@ class TemplateValidator:
 
         if "tags" in metadata:
             tags = metadata["tags"]
-            if not isinstance(tags, list):
-                result.add_error("Tags should be a list", field_name="metadata.tags")
-            elif len(tags) == 0:
-                result.add_warning("No tags specified", field_name="metadata.tags")
+            if isinstance(tags, str):
+                # Convert comma-separated string to list for validation
+                tag_list = [tag.strip() for tag in tags.split(",") if tag.strip()]
+                if len(tag_list) == 0:
+                    result.add_warning("No tags specified", field_name="metadata.tags")
+            elif isinstance(tags, list):
+                if len(tags) == 0:
+                    result.add_warning("No tags specified", field_name="metadata.tags")
+            else:
+                result.add_error(
+                    "Tags should be a list or comma-separated string",
+                    field_name="metadata.tags",
+                )
 
     def _validate_capabilities(
         self, capabilities: Dict[str, Any], result: ValidationResult
@@ -230,7 +238,7 @@ class TemplateValidator:
                     suggestion=f"Use one of: {', '.join(valid_models)}",
                 )
 
-        # Validate tools
+        # Validate tools (optional field but validate if present)
         if "tools" in capabilities:
             tools = capabilities["tools"]
             if not isinstance(tools, list):
@@ -242,43 +250,55 @@ class TemplateValidator:
                     "No tools specified", field_name="capabilities.tools"
                 )
 
-    def _validate_instructions(
-        self, instructions: Dict[str, Any], result: ValidationResult
+        # Validate resource_tier
+        if "resource_tier" in capabilities:
+            resource_tier = capabilities["resource_tier"]
+            valid_tiers = ["basic", "standard", "intensive", "lightweight", "high"]
+            if resource_tier not in valid_tiers:
+                result.add_warning(
+                    f"Unknown resource tier '{resource_tier}'",
+                    field_name="capabilities.resource_tier",
+                    suggestion=f"Use one of: {', '.join(valid_tiers)}",
+                )
+
+    def _validate_instructions_string(
+        self, instructions: str, result: ValidationResult
     ) -> None:
-        """Validate instructions section.
+        """Validate instructions string.
 
         Args:
-            instructions: Instructions dictionary
+            instructions: Instructions string
             result: ValidationResult to update
         """
-        for field, expected_type in self.required_instructions_fields.items():
-            if field not in instructions:
-                result.add_error(
-                    f"Missing required instructions field: {field}",
-                    field_name=f"instructions.{field}",
-                )
-            else:
-                value = instructions[field]
-                if not isinstance(value, expected_type):
-                    result.add_error(
-                        f"Instructions field '{field}' should be {expected_type.__name__}, got {type(value).__name__}",
-                        field_name=f"instructions.{field}",
-                    )
+        # Check if instructions is actually a string
+        if not isinstance(instructions, str):
+            result.add_error(
+                f"Instructions should be a string, got {type(instructions).__name__}",
+                field_name="instructions",
+            )
+            return
 
-        # Validate system prompt
-        if "system_prompt" in instructions:
-            system_prompt = instructions["system_prompt"]
-            if not system_prompt or not system_prompt.strip():
-                result.add_error(
-                    "System prompt cannot be empty",
-                    field_name="instructions.system_prompt",
-                )
-            elif len(system_prompt) < 20:
-                result.add_warning(
-                    "System prompt is very short",
-                    field_name="instructions.system_prompt",
-                    suggestion="Provide more detailed instructions",
-                )
+        # Check if instructions is not empty
+        if not instructions or not instructions.strip():
+            result.add_error(
+                "Instructions cannot be empty",
+                field_name="instructions",
+            )
+        elif len(instructions) < 20:
+            result.add_warning(
+                "Instructions are very short",
+                field_name="instructions",
+                suggestion="Provide more detailed instructions",
+            )
+
+        # Check for file references that might be invalid
+        if instructions.startswith("file:"):
+            file_ref = instructions[5:]  # Remove "file:" prefix
+            result.add_warning(
+                f"Instructions reference external file: {file_ref}",
+                field_name="instructions",
+                suggestion="Consider embedding instructions directly or ensure the referenced file exists",
+            )
 
     def _validate_agent_id(self, agent_id: str, result: ValidationResult) -> None:
         """Validate agent ID format.

claude_mpm/services/agents/deployment/validation/validation_result.py

@@ -1,17 +1,9 @@
 """Validation result classes for deployment validation."""
 
 from dataclasses import dataclass, field
-from enum import Enum
 from typing import Any, Dict, List, Optional
 
-
-class ValidationSeverity(Enum):
-    """Severity levels for validation issues."""
-
-    INFO = "info"
-    WARNING = "warning"
-    ERROR = "error"
-    CRITICAL = "critical"
+from claude_mpm.core.enums import ValidationSeverity
 
 
 @dataclass

claude_mpm/services/agents/loading/agent_profile_loader.py

@@ -21,10 +21,8 @@ multi-file implementation for better maintainability.
 
 import asyncio
 import json
-import logging
-import os
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
@@ -33,11 +31,12 @@ import yaml
 
 from claude_mpm.core.base_service import BaseService
 from claude_mpm.core.config import Config
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_paths import get_path_manager
 from claude_mpm.services.agents.registry import AgentRegistry
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 # ============================================================================
 # Data Models
@@ -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()
 
@@ -227,7 +226,9 @@ class AgentProfileLoader(BaseService):
         # Check cache first
         if use_cache and agent_name in self.profile_cache:
             profile = self.profile_cache[agent_name]
-            if (datetime.now() - profile.loaded_at).seconds < self.cache_ttl:
+            if (
+                datetime.now(timezone.utc) - profile.loaded_at
+            ).seconds < self.cache_ttl:
                 self.load_metrics[f"{agent_name}_cache_hit"] = (
                     asyncio.get_event_loop().time() - start_time
                 )
@@ -322,7 +323,7 @@ class AgentProfileLoader(BaseService):
                 try:
                     data = yaml.safe_load(content)
                     instructions = data.get("instructions", "")
-                except:
+                except Exception:
                     data = json.loads(content)
                     instructions = data.get("instructions", "")
 
@@ -455,7 +456,7 @@ class AgentProfileLoader(BaseService):
 
         if prompt_file.exists():
             try:
-                with open(prompt_file) as f:
+                with prompt_file.open() as f:
                     data = json.load(f)
                     for prompt_data in data:
                         prompt = ImprovedPrompt(
@@ -498,7 +499,7 @@ class AgentProfileLoader(BaseService):
 
             # Save to file
             prompt_file = self.improved_prompts_path / f"{agent_name}_prompts.json"
-            with open(prompt_file, "w") as f:
+            with prompt_file.open("w") as f:
                 json.dump(
                     [
                         {

claude_mpm/services/agents/loading/base_agent_manager.py

@@ -7,18 +7,27 @@ Specialized manager for base_agent.md with structured update capabilities.
 Enforces template structure and provides section-specific update methods.
 """
 
-import logging
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
+# Lazy import for base_agent_loader to reduce initialization overhead
+# base_agent_loader adds ~500ms to import time
+# from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.services.memory.cache.shared_prompt_cache import SharedPromptCache
 from claude_mpm.services.shared import ConfigServiceBase
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
+
+
+def _get_clear_base_agent_cache():
+    """Lazy loader for clear_base_agent_cache function."""
+    from claude_mpm.agents.base_agent_loader import clear_base_agent_cache
+
+    return clear_base_agent_cache
 
 
 class BaseAgentSection(str, Enum):
@@ -134,7 +143,8 @@ class BaseAgentManager(ConfigServiceBase):
         content = self._structure_to_markdown(current)
         self.base_agent_path.write_text(content, encoding="utf-8")
 
-        # Clear caches
+        # Clear caches (lazy load to avoid import overhead)
+        clear_base_agent_cache = _get_clear_base_agent_cache()
         clear_base_agent_cache()
         self.cache.invalidate("base_agent:instructions")
 
@@ -358,7 +368,7 @@ class BaseAgentManager(ConfigServiceBase):
 
     def _create_backup(self) -> Path:
         """Create a timestamped backup of base_agent.md."""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
         backup_path = self.base_agent_path.parent / f"base_agent_{timestamp}.backup"
 
         if self.base_agent_path.exists():

claude_mpm/services/agents/loading/framework_agent_loader.py

@@ -12,7 +12,6 @@ This service integrates with the main agent_loader.py to provide
 markdown-based agent profiles alongside JSON-based templates.
 """
 
-import logging
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -20,9 +19,10 @@ from claude_mpm.agents.agent_loader import (
     AgentTier,
     list_agents_by_tier,
 )
+from claude_mpm.core.logging_utils import get_logger
 from claude_mpm.core.unified_paths import get_path_manager
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class FrameworkAgentLoader: