claude-mpm 3.1.1__py3-none-any.whl → 3.1.3__py3-none-any.whl

claude_mpm/services/agent_lifecycle_manager.py

@@ -27,95 +27,46 @@ Created for ISS-0118: Agent Registry and Hierarchical Discovery System
 import asyncio
 import logging
 import time
-from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from enum import Enum
 from pathlib import Path
 from typing import Dict, List, Optional, Set, Any, Tuple, Union
 
 from claude_mpm.services.shared_prompt_cache import SharedPromptCache
-from claude_mpm.services.agent_registry import AgentRegistry, AgentMetadata
-from claude_mpm.services.agent_modification_tracker import (
-    AgentModificationTracker, 
-    AgentModification, 
-    ModificationType, 
+from claude_mpm.services.agent_registry import AgentRegistry
+from claude_mpm.services.agent_modification_tracker import AgentModificationTracker
+from claude_mpm.services.agent_persistence_service import AgentPersistenceService
+from claude_mpm.services.agent_management_service import AgentManager
+from claude_mpm.models.agent_definition import AgentDefinition, AgentType
+from claude_mpm.models.lifecycle import (
+    LifecycleOperation,
+    LifecycleState,
+    AgentLifecycleRecord,
+    LifecycleOperationResult
+)
+from claude_mpm.models.modification import (
+    AgentModification,
+    ModificationType,
     ModificationTier
 )
-from claude_mpm.services.agent_persistence_service import (
-    AgentPersistenceService,
-    PersistenceRecord,
+from claude_mpm.models.persistence import (
     PersistenceStrategy,
+    PersistenceRecord,
     PersistenceOperation
 )
+from claude_mpm.models.registry import AgentRegistryMetadata
 from claude_mpm.core.base_service import BaseService
 from claude_mpm.utils.path_operations import path_ops
 from claude_mpm.utils.config_manager import ConfigurationManager
 
-
-class LifecycleOperation(Enum):
-    """Agent lifecycle operations."""
-    CREATE = "create"
-    UPDATE = "update"
-    DELETE = "delete"
-    RESTORE = "restore"
-    MIGRATE = "migrate"
-    REPLICATE = "replicate"
-    VALIDATE = "validate"
-
-
-class LifecycleState(Enum):
-    """Agent lifecycle states."""
-    ACTIVE = "active"
-    MODIFIED = "modified"
-    DELETED = "deleted"
-    CONFLICTED = "conflicted"
-    MIGRATING = "migrating"
-    VALIDATING = "validating"
-
-
-@dataclass
-class AgentLifecycleRecord:
-    """Complete lifecycle record for an agent."""
-    
-    agent_name: str
-    current_state: LifecycleState
-    tier: ModificationTier
-    file_path: str
-    created_at: float
-    last_modified: float
-    version: str
-    modifications: List[str] = field(default_factory=list)  # Modification IDs
-    persistence_operations: List[str] = field(default_factory=list)  # Operation IDs
-    backup_paths: List[str] = field(default_factory=list)
-    validation_status: str = "valid"
-    validation_errors: List[str] = field(default_factory=list)
-    metadata: Dict[str, Any] = field(default_factory=dict)
-    
-    @property
-    def age_days(self) -> float:
-        """Get age in days."""
-        return (time.time() - self.created_at) / (24 * 3600)
-    
-    @property
-    def last_modified_datetime(self) -> datetime:
-        """Get last modified as datetime."""
-        return datetime.fromtimestamp(self.last_modified)
-
-
-@dataclass
-class LifecycleOperationResult:
-    """Result of a lifecycle operation."""
-    
-    operation: LifecycleOperation
-    agent_name: str
-    success: bool
-    duration_ms: float
-    error_message: Optional[str] = None
-    modification_id: Optional[str] = None
-    persistence_id: Optional[str] = None
-    cache_invalidated: bool = False
-    registry_updated: bool = False
-    metadata: Dict[str, Any] = field(default_factory=dict)
+# Backward compatibility imports
+# These allow existing code to import from this module
+__all__ = [
+    'LifecycleOperation',
+    'LifecycleState', 
+    'AgentLifecycleRecord',
+    'LifecycleOperationResult',
+    'AgentLifecycleManager'
+]
 
 
 class AgentLifecycleManager(BaseService):
@@ -149,6 +100,7 @@ class AgentLifecycleManager(BaseService):
         self.agent_registry: Optional[AgentRegistry] = None
         self.modification_tracker: Optional[AgentModificationTracker] = None
         self.persistence_service: Optional[AgentPersistenceService] = None
+        self.agent_manager: Optional[AgentManager] = None
         
         # Lifecycle tracking
         self.agent_records: Dict[str, AgentLifecycleRecord] = {}
@@ -246,6 +198,9 @@ class AgentLifecycleManager(BaseService):
             self.persistence_service = AgentPersistenceService()
             await self.persistence_service.start()
             
+            # Initialize AgentManager
+            self.agent_manager = AgentManager()
+            
             self.logger.info("Core services initialized successfully")
             
         except Exception as e:
@@ -319,9 +274,9 @@ class AgentLifecycleManager(BaseService):
             if not self.agent_registry:
                 return
             
-            # Discover all agents via registry
-            await self.agent_registry.discover_agents()
-            all_agents = await self.agent_registry.list_agents()
+            # Discover all agents via registry (sync methods)
+            self.agent_registry.discover_agents()
+            all_agents = self.agent_registry.list_agents()
             
             # Update lifecycle records with registry data
             for agent_metadata in all_agents:
@@ -391,8 +346,32 @@ class AgentLifecycleManager(BaseService):
                         error_message="Agent already exists"
                     )
                 
-                # Determine file path
-                file_path = await self._determine_agent_file_path(agent_name, tier)
+                # Create agent definition
+                agent_def = await self._create_agent_definition(
+                    agent_name, agent_content, tier, agent_type, **kwargs
+                )
+                
+                # Determine location based on tier
+                location = "project" if tier == ModificationTier.PROJECT else "framework"
+                
+                # Create agent using AgentManager (sync call in executor)
+                try:
+                    if self.agent_manager:
+                        file_path = await self._run_sync_in_executor(
+                            self.agent_manager.create_agent,
+                            agent_name, agent_def, location
+                        )
+                    else:
+                        # Fallback to direct file creation if AgentManager not available
+                        file_path = await self._determine_agent_file_path(agent_name, tier)
+                        path_ops.ensure_dir(file_path.parent)
+                        path_ops.safe_write(file_path, agent_content)
+                except Exception as e:
+                    self.logger.error(f"AgentManager failed to create agent: {e}")
+                    # Fallback to direct file creation
+                    file_path = await self._determine_agent_file_path(agent_name, tier)
+                    path_ops.ensure_dir(file_path.parent)
+                    path_ops.safe_write(file_path, agent_content)
                 
                 # Track modification
                 modification = await self.modification_tracker.track_modification(
@@ -404,13 +383,18 @@ class AgentLifecycleManager(BaseService):
                     **kwargs
                 )
                 
-                # Persist agent
-                persistence_record = await self.persistence_service.persist_agent(
+                # Note: We don't use persistence_service for the actual write anymore
+                # since AgentManager handles that. We create a synthetic record for compatibility.
+                persistence_record = PersistenceRecord(
+                    operation_id=f"create_{agent_name}_{time.time()}",
+                    operation_type=PersistenceOperation.CREATE,
                     agent_name=agent_name,
-                    agent_content=agent_content,
                     source_tier=tier,
                     target_tier=tier,
-                    strategy=self.default_persistence_strategy
+                    strategy=self.default_persistence_strategy,
+                    success=True,
+                    timestamp=time.time(),
+                    file_path=str(file_path)
                 )
                 
                 # Create lifecycle record
@@ -512,6 +496,48 @@ class AgentLifecycleManager(BaseService):
                 
                 record = self.agent_records[agent_name]
                 
+                # Update agent using AgentManager
+                try:
+                    if self.agent_manager:
+                        # Read current agent to get full definition
+                        current_def = await self._run_sync_in_executor(
+                            self.agent_manager.read_agent, agent_name
+                        )
+                        
+                        if current_def:
+                            # Update raw content
+                            current_def.raw_content = agent_content
+                            
+                            # Apply any metadata updates from kwargs
+                            if 'model_preference' in kwargs:
+                                current_def.metadata.model_preference = kwargs['model_preference']
+                            if 'tags' in kwargs:
+                                current_def.metadata.tags = kwargs['tags']
+                            if 'specializations' in kwargs:
+                                current_def.metadata.specializations = kwargs['specializations']
+                            
+                            # Update via AgentManager
+                            updated_def = await self._run_sync_in_executor(
+                                self.agent_manager.update_agent,
+                                agent_name, {"raw_content": agent_content}, True
+                            )
+                            
+                            if not updated_def:
+                                raise Exception("AgentManager update failed")
+                        else:
+                            raise Exception("Could not read current agent definition")
+                    else:
+                        # Fallback to direct file update
+                        file_path = Path(record.file_path)
+                        if path_ops.validate_exists(file_path):
+                            path_ops.safe_write(file_path, agent_content)
+                except Exception as e:
+                    self.logger.error(f"AgentManager failed to update agent: {e}")
+                    # Fallback to direct file update
+                    file_path = Path(record.file_path)
+                    if path_ops.validate_exists(file_path):
+                        path_ops.safe_write(file_path, agent_content)
+                
                 # Track modification
                 modification = await self.modification_tracker.track_modification(
                     agent_name=agent_name,
@@ -521,12 +547,17 @@ class AgentLifecycleManager(BaseService):
                     **kwargs
                 )
                 
-                # Persist agent
-                persistence_record = await self.persistence_service.persist_agent(
+                # Create synthetic persistence record for compatibility
+                persistence_record = PersistenceRecord(
+                    operation_id=f"update_{agent_name}_{time.time()}",
+                    operation_type=PersistenceOperation.UPDATE,
                     agent_name=agent_name,
-                    agent_content=agent_content,
                     source_tier=record.tier,
-                    strategy=self.default_persistence_strategy
+                    target_tier=record.tier,
+                    strategy=self.default_persistence_strategy,
+                    success=True,
+                    timestamp=time.time(),
+                    file_path=record.file_path
                 )
                 
                 # Update lifecycle record
@@ -631,10 +662,28 @@ class AgentLifecycleManager(BaseService):
                     **kwargs
                 )
                 
-                # Delete file
-                file_path = Path(record.file_path)
-                if path_ops.validate_exists(file_path):
-                    path_ops.safe_delete(file_path)
+                # Delete agent using AgentManager
+                deletion_success = False
+                try:
+                    if self.agent_manager:
+                        deletion_success = await self._run_sync_in_executor(
+                            self.agent_manager.delete_agent, agent_name
+                        )
+                        if not deletion_success:
+                            raise Exception("AgentManager delete failed")
+                    else:
+                        # Fallback to direct file deletion
+                        file_path = Path(record.file_path)
+                        if path_ops.validate_exists(file_path):
+                            path_ops.safe_delete(file_path)
+                            deletion_success = True
+                except Exception as e:
+                    self.logger.error(f"AgentManager failed to delete agent: {e}")
+                    # Fallback to direct file deletion
+                    file_path = Path(record.file_path)
+                    if path_ops.validate_exists(file_path):
+                        path_ops.safe_delete(file_path)
+                        deletion_success = True
                 
                 # Update lifecycle record
                 record.current_state = LifecycleState.DELETED
@@ -749,8 +798,8 @@ class AgentLifecycleManager(BaseService):
             return False
         
         try:
-            # Refresh specific agent in registry
-            await self.agent_registry.refresh_agent(agent_name)
+            # Refresh registry (discover_agents is synchronous)
+            self.agent_registry.discover_agents()
             return True
             
         except Exception as e:
@@ -950,6 +999,69 @@ class AgentLifecycleManager(BaseService):
         
         return stats
     
+    async def _create_agent_definition(self, agent_name: str, agent_content: str, 
+                                      tier: ModificationTier, agent_type: str, **kwargs) -> AgentDefinition:
+        """
+        Create an AgentDefinition from lifecycle parameters.
+        
+        WHY: This method bridges the gap between the lifecycle manager's parameters
+        and the AgentManager's expected AgentDefinition model.
+        
+        DESIGN DECISION: Creating a minimal AgentDefinition here because:
+        - The full markdown parsing happens in AgentManager
+        - We only need to provide the essential metadata
+        - This keeps the lifecycle manager focused on orchestration
+        """
+        # Map tier to AgentType
+        type_map = {
+            ModificationTier.USER: AgentType.CUSTOM,
+            ModificationTier.PROJECT: AgentType.PROJECT,
+            ModificationTier.SYSTEM: AgentType.SYSTEM
+        }
+        
+        # Create metadata
+        from claude_mpm.models.agent_definition import AgentMetadata, AgentPermissions
+        metadata = AgentMetadata(
+            type=type_map.get(tier, AgentType.CUSTOM),
+            model_preference=kwargs.get('model_preference', 'claude-3-sonnet'),
+            version="1.0.0",
+            author=kwargs.get('author', 'claude-mpm'),
+            tags=kwargs.get('tags', []),
+            specializations=kwargs.get('specializations', [])
+        )
+        
+        # Create minimal definition
+        definition = AgentDefinition(
+            name=agent_name,
+            title=agent_name.replace('-', ' ').title(),
+            file_path="",  # Will be set by AgentManager
+            metadata=metadata,
+            primary_role=kwargs.get('primary_role', f"{agent_name} agent"),
+            when_to_use={"select": [], "do_not_select": []},
+            capabilities=[],
+            authority=AgentPermissions(),
+            workflows=[],
+            escalation_triggers=[],
+            kpis=[],
+            dependencies=[],
+            tools_commands="",
+            raw_content=agent_content
+        )
+        
+        return definition
+    
+    async def _run_sync_in_executor(self, func, *args, **kwargs):
+        """
+        Run a synchronous function in an executor to avoid blocking.
+        
+        WHY: AgentManager has synchronous methods but AgentLifecycleManager is async.
+        This allows us to call sync methods without blocking the event loop.
+        
+        PERFORMANCE: Uses the default executor which manages a thread pool efficiently.
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, func, *args, **kwargs)
+    
     async def restore_agent(self, agent_name: str, backup_path: Optional[str] = None) -> LifecycleOperationResult:
         """Restore agent from backup."""
         start_time = time.time()

claude_mpm/services/agent_modification_tracker.py

@@ -28,9 +28,8 @@ import os
 import shutil
 import time
 import uuid
-from dataclasses import dataclass, field, asdict
+from dataclasses import asdict
 from datetime import datetime
-from enum import Enum
 from pathlib import Path
 from typing import Dict, List, Optional, Any, Callable, Tuple, Set
 
@@ -40,105 +39,25 @@ from watchdog.events import FileSystemEventHandler, FileSystemEvent
 from claude_mpm.core.base_service import BaseService
 from claude_mpm.services.shared_prompt_cache import SharedPromptCache
 from claude_mpm.services.agent_registry import AgentRegistry
+from claude_mpm.models.modification import (
+    ModificationType,
+    ModificationTier,
+    AgentModification,
+    ModificationHistory
+)
 from claude_mpm.utils.path_operations import path_ops
 from claude_mpm.utils.config_manager import ConfigurationManager
 
-
-# ============================================================================
-# Data Models
-# ============================================================================
-
-class ModificationType(Enum):
-    """Types of agent modifications."""
-    CREATE = "create"
-    MODIFY = "modify"
-    DELETE = "delete"
-    MOVE = "move"
-    RESTORE = "restore"
-
-
-class ModificationTier(Enum):
-    """Agent hierarchy tiers for modification tracking."""
-    PROJECT = "project"
-    USER = "user"
-    SYSTEM = "system"
-
-
-@dataclass
-class AgentModification:
-    """Agent modification record with comprehensive metadata."""
-    
-    modification_id: str
-    agent_name: str
-    modification_type: ModificationType
-    tier: ModificationTier
-    file_path: str
-    timestamp: float
-    user_id: Optional[str] = None
-    modification_details: Dict[str, Any] = field(default_factory=dict)
-    file_hash_before: Optional[str] = None
-    file_hash_after: Optional[str] = None
-    file_size_before: Optional[int] = None
-    file_size_after: Optional[int] = None
-    backup_path: Optional[str] = None
-    validation_status: str = "pending"
-    validation_errors: List[str] = field(default_factory=list)
-    related_modifications: List[str] = field(default_factory=list)
-    metadata: Dict[str, Any] = field(default_factory=dict)
-    
-    @property
-    def modification_datetime(self) -> datetime:
-        """Get modification timestamp as datetime."""
-        return datetime.fromtimestamp(self.timestamp)
-    
-    @property
-    def age_seconds(self) -> float:
-        """Get age of modification in seconds."""
-        return time.time() - self.timestamp
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for serialization."""
-        data = asdict(self)
-        data['modification_type'] = self.modification_type.value
-        data['tier'] = self.tier.value
-        return data
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> 'AgentModification':
-        """Create from dictionary."""
-        data['modification_type'] = ModificationType(data['modification_type'])
-        data['tier'] = ModificationTier(data['tier'])
-        return cls(**data)
-
-
-@dataclass
-class ModificationHistory:
-    """Complete modification history for an agent."""
-    
-    agent_name: str
-    modifications: List[AgentModification] = field(default_factory=list)
-    current_version: Optional[str] = None
-    total_modifications: int = 0
-    first_seen: Optional[float] = None
-    last_modified: Optional[float] = None
-    
-    def add_modification(self, modification: AgentModification) -> None:
-        """Add a modification to history."""
-        self.modifications.append(modification)
-        self.total_modifications += 1
-        self.last_modified = modification.timestamp
-        
-        if self.first_seen is None:
-            self.first_seen = modification.timestamp
-    
-    def get_recent_modifications(self, hours: int = 24) -> List[AgentModification]:
-        """Get modifications within specified hours."""
-        cutoff = time.time() - (hours * 3600)
-        return [mod for mod in self.modifications if mod.timestamp >= cutoff]
-    
-    def get_modifications_by_type(self, mod_type: ModificationType) -> List[AgentModification]:
-        """Get modifications by type."""
-        return [mod for mod in self.modifications if mod.modification_type == mod_type]
+# Backward compatibility exports
+# These allow existing code to import models from this module
+__all__ = [
+    'ModificationType',
+    'ModificationTier',
+    'AgentModification', 
+    'ModificationHistory',
+    'AgentModificationTracker',
+    'AgentFileSystemHandler'
+]
 
 
 # ============================================================================
@@ -341,6 +260,14 @@ class AgentModificationTracker(BaseService):
             backup_path = await self._create_backup(file_path, modification_id)
         
         # Create modification record
+        # Only include valid AgentModification fields from file_metadata
+        valid_metadata_fields = {'file_hash_after', 'file_size_after'}
+        filtered_metadata = {k: v for k, v in file_metadata.items() if k in valid_metadata_fields}
+        
+        # Add other metadata to the metadata field
+        extra_metadata = {k: v for k, v in file_metadata.items() if k not in valid_metadata_fields}
+        extra_metadata.update(kwargs)
+        
         modification = AgentModification(
             modification_id=modification_id,
             agent_name=agent_name,
@@ -349,8 +276,8 @@ class AgentModificationTracker(BaseService):
             file_path=file_path,
             timestamp=time.time(),
             backup_path=backup_path,
-            **file_metadata,
-            **kwargs
+            metadata=extra_metadata,
+            **filtered_metadata
         )
         
         # Validate modification if enabled

claude_mpm/services/agent_persistence_service.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+Agent Persistence Service (Stub)
+================================
+
+WHY: This is a stub implementation to support the AgentLifecycleManager integration.
+The actual persistence is now handled by AgentManager, but we maintain this interface
+for backward compatibility.
+
+DESIGN DECISION: Creating a minimal stub because:
+- AgentManager handles the actual file persistence
+- This maintains the existing API contract
+- Allows for future extension if needed
+"""
+
+from typing import Optional, Any
+import time
+
+from claude_mpm.models.persistence import (
+    PersistenceStrategy,
+    PersistenceOperation,
+    PersistenceRecord
+)
+
+# Backward compatibility exports
+__all__ = [
+    'PersistenceStrategy',
+    'PersistenceOperation',
+    'PersistenceRecord',
+    'AgentPersistenceService'
+]
+
+
+class AgentPersistenceService:
+    """
+    Stub implementation for agent persistence service.
+    
+    WHY: Maintains compatibility with AgentLifecycleManager while
+    actual persistence is delegated to AgentManager.
+    """
+    
+    def __init__(self):
+        """Initialize the persistence service."""
+        pass
+    
+    async def start(self) -> None:
+        """Start the persistence service."""
+        # No-op for stub
+        pass
+    
+    async def stop(self) -> None:
+        """Stop the persistence service."""
+        # No-op for stub
+        pass
+    
+    async def persist_agent(self, agent_name: str, agent_content: str,
+                           source_tier: Any, target_tier: Optional[Any] = None,
+                           strategy: Optional[PersistenceStrategy] = None) -> PersistenceRecord:
+        """
+        Create a persistence record (actual persistence handled by AgentManager).
+        
+        WHY: This method exists for API compatibility but doesn't perform
+        actual file operations since AgentManager handles that.
+        """
+        return PersistenceRecord(
+            operation_id=f"persist_{agent_name}_{time.time()}",
+            operation_type=PersistenceOperation.UPDATE,
+            agent_name=agent_name,
+            source_tier=source_tier,
+            target_tier=target_tier or source_tier,
+            strategy=strategy or PersistenceStrategy.USER_OVERRIDE,
+            success=True,
+            timestamp=time.time()
+        )