claude-mpm 0.3.0__py3-none-any.whl

claude_mpm/services/parent_directory_manager/backup_manager.py

@@ -0,0 +1,258 @@
+"""Backup management functionality for Claude PM framework."""
+
+from pathlib import Path
+from typing import Optional, Dict, Any
+import datetime
+import shutil
+import logging
+
+# Import needed for restore operation
+from .state_manager import ParentDirectoryOperation, ParentDirectoryAction
+from ...utils.path_operations import path_ops
+
+
+class BackupManager:
+    """Manages backup operations for files and framework templates."""
+    
+    def __init__(self, base_dir: Path, retention_days: int = 30, logger: Optional[logging.Logger] = None):
+        """Initialize BackupManager.
+        
+        Args:
+            base_dir: Base directory for the service (typically .claude-pm)
+            retention_days: Number of days to retain backups (default: 30)
+            logger: Logger instance for logging operations
+        """
+        self.base_dir = base_dir
+        self.retention_days = retention_days
+        self.logger = logger or logging.getLogger(__name__)
+        
+        # Ensure framework backup directory exists
+        self.framework_backups_dir = self.base_dir / "backups" / "framework"
+        path_ops.ensure_dir(self.framework_backups_dir)
+    
+    def create_backup(self, file_path: Path, backups_dir: Path) -> Optional[Path]:
+        """Create a timestamped backup of a file.
+        
+        Args:
+            file_path: Path to the file to backup
+            backups_dir: Directory to store the backup
+            
+        Returns:
+            Path to the created backup file, or None if backup failed
+        """
+        if not path_ops.validate_exists(file_path):
+            self.logger.warning(f"Cannot backup non-existent file: {file_path}")
+            return None
+            
+        try:
+            # Create backups directory if it doesn't exist
+            path_ops.ensure_dir(backups_dir)
+            
+            # Generate timestamp for backup filename
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
+            backup_filename = f"{file_path.stem}_{timestamp}.backup"
+            backup_path = backups_dir / backup_filename
+            
+            # Copy file to backup location
+            path_ops.safe_copy(file_path, backup_path)
+            self.logger.info(f"Created backup: {backup_path}")
+            
+            return backup_path
+            
+        except Exception as e:
+            self.logger.error(f"Failed to create backup of {file_path}: {e}")
+            return None
+    
+    async def backup_parent_directory(self, target_directory: Path, backups_dir: Path) -> Optional[Path]:
+        """
+        Create a backup of a parent directory's INSTRUCTIONS.md/CLAUDE.md file.
+
+        Args:
+            target_directory: Directory containing file to backup
+            backups_dir: Directory to store backups
+
+        Returns:
+            Path to backup file or None if failed
+        """
+        try:
+            # Check for INSTRUCTIONS.md first, then CLAUDE.md
+            target_file = target_directory / "INSTRUCTIONS.md"
+            if not path_ops.validate_exists(target_file):
+                target_file = target_directory / "CLAUDE.md"
+            
+            if not path_ops.validate_exists(target_file):
+                self.logger.warning(f"No INSTRUCTIONS.md or CLAUDE.md file to backup in {target_directory}")
+                return None
+
+            # Delegate to create_backup
+            return self.create_backup(target_file, backups_dir)
+
+        except Exception as e:
+            self.logger.error(f"Failed to backup parent directory {target_directory}: {e}")
+            return None
+    
+    def backup_framework_template(self, framework_template_path: Path) -> Optional[Path]:
+        """Create a backup of the framework template with rotation.
+        
+        Only keeps the 2 most recent backups to prevent accumulation.
+        
+        Args:
+            framework_template_path: Path to the framework template file
+            
+        Returns:
+            Path to the created backup, or None if backup failed
+        """
+        if not path_ops.validate_exists(framework_template_path):
+            self.logger.warning(f"Framework template not found: {framework_template_path}")
+            return None
+            
+        try:
+            # Create backup
+            backup_path = self.create_backup(framework_template_path, self.framework_backups_dir)
+            
+            if backup_path:
+                # Rotate backups to keep only 2 most recent
+                self._rotate_framework_backups()
+                
+            return backup_path
+            
+        except Exception as e:
+            self.logger.error(f"Failed to backup framework template: {e}")
+            return None
+    
+    def get_framework_backup_status(self) -> Dict[str, Any]:
+        """Get status information about framework backups.
+        
+        Returns:
+            Dictionary containing backup status information
+        """
+        try:
+            backup_files = list(self.framework_backups_dir.glob("framework_CLAUDE_md_*.backup"))
+            backup_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+            
+            status = {
+                "backup_dir": str(self.framework_backups_dir),
+                "backup_count": len(backup_files),
+                "backups": []
+            }
+            
+            for backup_file in backup_files:
+                try:
+                    stat = backup_file.stat()
+                    backup_info = {
+                        "filename": backup_file.name,
+                        "path": str(backup_file),
+                        "size": stat.st_size,
+                        "modified": datetime.datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                        "age_days": (datetime.datetime.now() - datetime.datetime.fromtimestamp(stat.st_mtime)).days
+                    }
+                    status["backups"].append(backup_info)
+                except Exception as e:
+                    self.logger.warning(f"Could not get info for backup {backup_file}: {e}")
+                    
+            return status
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get framework backup status: {e}")
+            return {
+                "backup_dir": str(self.framework_backups_dir),
+                "backup_count": 0,
+                "backups": [],
+                "error": str(e)
+            }
+    
+    def _rotate_framework_backups(self) -> None:
+        """Rotate framework backups to keep only the 2 most recent."""
+        try:
+            # Get all framework backup files
+            backup_files = list(self.framework_backups_dir.glob("framework_CLAUDE_md_*.backup"))
+            
+            if len(backup_files) <= 2:
+                return
+                
+            # Sort by modification time (newest first)
+            backup_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+            
+            # Remove all but the 2 most recent
+            for old_backup in backup_files[2:]:
+                try:
+                    old_backup.unlink()
+                    self.logger.info(f"Removed old framework backup: {old_backup.name}")
+                except Exception as e:
+                    self.logger.warning(f"Could not remove old backup {old_backup}: {e}")
+                    
+        except Exception as e:
+            self.logger.error(f"Failed to rotate framework backups: {e}")
+    
+    async def restore_from_backup(
+        self, 
+        target_directory: Path, 
+        backups_dir: Path,
+        backup_timestamp: Optional[str] = None
+    ) -> ParentDirectoryOperation:
+        """
+        Restore a parent directory from backup.
+
+        Args:
+            target_directory: Directory to restore
+            backups_dir: Directory containing backups
+            backup_timestamp: Specific backup to restore (latest if None)
+
+        Returns:
+            ParentDirectoryOperation result
+        """
+        try:
+            # Check for INSTRUCTIONS.md first, then CLAUDE.md
+            target_file = target_directory / "INSTRUCTIONS.md"
+            if not target_file.exists():
+                target_file = target_directory / "CLAUDE.md"
+
+            # Find backup files
+            backup_pattern = f"*{target_file.name}*"
+            backup_files = list(backups_dir.glob(backup_pattern))
+
+            if not backup_files:
+                raise ValueError(f"No backup files found for {target_file}")
+
+            # Select backup file
+            if backup_timestamp:
+                backup_file = None
+                for bf in backup_files:
+                    if backup_timestamp in bf.name:
+                        backup_file = bf
+                        break
+
+                if not backup_file:
+                    raise ValueError(f"No backup found for timestamp: {backup_timestamp}")
+            else:
+                # Use most recent backup
+                backup_file = max(backup_files, key=lambda f: f.stat().st_mtime)
+
+            # Create backup of current file if it exists
+            current_backup = None
+            if target_file.exists():
+                current_backup = self.create_backup(target_file, backups_dir)
+
+            # Restore from backup
+            shutil.copy2(backup_file, target_file)
+
+            # Create operation result
+            operation = ParentDirectoryOperation(
+                action=ParentDirectoryAction.RESTORE,
+                target_path=target_file,
+                success=True,
+                backup_path=current_backup,
+                changes_made=[f"Restored {target_file} from backup {backup_file}"],
+            )
+
+            self.logger.info(f"Successfully restored {target_file} from backup")
+            return operation
+
+        except Exception as e:
+            self.logger.error(f"Failed to restore parent directory {target_directory}: {e}")
+            return ParentDirectoryOperation(
+                action=ParentDirectoryAction.RESTORE,
+                target_path=target_file,
+                success=False,
+                error_message=str(e),
+            )

claude_mpm/services/parent_directory_manager/config_manager.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+Configuration Manager - Handles managed directories configuration
+================================================================================
+
+This module manages the loading, saving, and tracking of managed directory
+configurations for the parent directory manager.
+"""
+
+from pathlib import Path
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, field
+import logging
+
+from .operations import ParentDirectoryContext
+from ...utils.path_operations import path_ops
+from ...utils.config_manager import ConfigurationManager
+
+
+@dataclass
+class ParentDirectoryConfig:
+    """Configuration for parent directory management."""
+    target_directory: Path
+    context: ParentDirectoryContext
+    template_id: str
+    template_variables: Dict[str, Any] = field(default_factory=dict)
+    backup_enabled: bool = True
+    version_control: bool = True
+    conflict_resolution: str = "backup_and_replace"
+    deployment_metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class ConfigManager:
+    """Manages configuration for parent directories."""
+
+    def __init__(
+        self,
+        configs_dir: Path,
+        logger: Optional[logging.Logger] = None
+    ):
+        """
+        Initialize the Configuration Manager.
+
+        Args:
+            configs_dir: Directory for storing configurations
+            logger: Logger instance to use
+        """
+        self.configs_dir = configs_dir
+        self.logger = logger or logging.getLogger(__name__)
+        self.managed_directories_file = self.configs_dir / "managed_directories.json"
+        self.managed_directories: Dict[str, ParentDirectoryConfig] = {}
+        self.config_mgr = ConfigurationManager(cache_enabled=True)
+
+    async def load_managed_directories(self) -> None:
+        """Load existing managed directories configuration."""
+        try:
+            if path_ops.validate_exists(self.managed_directories_file):
+                data = self.config_mgr.load_json(self.managed_directories_file)
+
+                # Convert loaded data to ParentDirectoryConfig objects
+                for key, config_data in data.items():
+                    config = ParentDirectoryConfig(
+                        target_directory=Path(config_data["target_directory"]),
+                        context=ParentDirectoryContext(config_data["context"]),
+                        template_id=config_data["template_id"],
+                        template_variables=config_data.get("template_variables", {}),
+                        backup_enabled=config_data.get("backup_enabled", True),
+                        version_control=config_data.get("version_control", True),
+                        conflict_resolution=config_data.get(
+                            "conflict_resolution", "backup_and_replace"
+                        ),
+                        deployment_metadata=config_data.get("deployment_metadata", {}),
+                    )
+                    self.managed_directories[key] = config
+
+                self.logger.info(f"Loading managed directories...")
+
+        except Exception as e:
+            self.logger.error(f"Failed to load managed directories: {e}")
+
+    async def save_managed_directories(self) -> None:
+        """Save managed directories configuration."""
+        try:
+            # Convert ParentDirectoryConfig objects to serializable format
+            data = {}
+            for key, config in self.managed_directories.items():
+                data[key] = {
+                    "target_directory": str(config.target_directory),
+                    "context": config.context.value,
+                    "template_id": config.template_id,
+                    "template_variables": config.template_variables,
+                    "backup_enabled": config.backup_enabled,
+                    "version_control": config.version_control,
+                    "conflict_resolution": config.conflict_resolution,
+                    "deployment_metadata": config.deployment_metadata,
+                }
+
+            self.config_mgr.save_json(data, self.managed_directories_file)
+
+            self.logger.debug("Managed directories configuration saved")
+
+        except Exception as e:
+            self.logger.error(f"Failed to save managed directories: {e}")
+
+    def register_directory(
+        self,
+        directory_key: str,
+        config: ParentDirectoryConfig
+    ) -> None:
+        """
+        Register a directory configuration.
+
+        Args:
+            directory_key: Unique key for the directory
+            config: Configuration for the directory
+        """
+        self.managed_directories[directory_key] = config
+    
+    async def register_parent_directory(
+        self,
+        target_directory: Path,
+        context: ParentDirectoryContext,
+        template_id: str,
+        template_variables: Dict[str, Any] = None,
+        **kwargs
+    ) -> bool:
+        """
+        Register a parent directory for management with validation.
+
+        Args:
+            target_directory: Directory to manage
+            context: Context type for the directory
+            template_id: Template to use for management
+            template_variables: Variables for template rendering
+            **kwargs: Additional configuration options
+
+        Returns:
+            True if registration successful, False otherwise
+        """
+        try:
+            # Validate inputs
+            if not path_ops.validate_exists(target_directory):
+                raise ValueError(f"Target directory does not exist: {target_directory}")
+
+            if not path_ops.validate_is_dir(target_directory):
+                raise ValueError(f"Target path is not a directory: {target_directory}")
+
+            # Create configuration
+            config = ParentDirectoryConfig(
+                target_directory=target_directory,
+                context=context,
+                template_id=template_id,
+                template_variables=template_variables or {},
+                backup_enabled=kwargs.get("backup_enabled", True),
+                version_control=kwargs.get("version_control", True),
+                conflict_resolution=kwargs.get("conflict_resolution", "backup_and_replace"),
+                deployment_metadata=kwargs.get("deployment_metadata", {}),
+            )
+
+            # Register the directory
+            directory_key = str(target_directory)
+            self.register_directory(directory_key, config)
+
+            # Save configuration
+            await self.save_managed_directories()
+
+            self.logger.info(
+                f"Registered parent directory: {target_directory} with template {template_id}"
+            )
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to register parent directory {target_directory}: {e}")
+            return False
+
+    def get_directory_config(
+        self,
+        directory_key: str
+    ) -> Optional[ParentDirectoryConfig]:
+        """
+        Get configuration for a directory.
+
+        Args:
+            directory_key: Unique key for the directory
+
+        Returns:
+            Directory configuration or None if not found
+        """
+        return self.managed_directories.get(directory_key)
+
+    def is_directory_managed(self, directory_key: str) -> bool:
+        """
+        Check if a directory is managed.
+
+        Args:
+            directory_key: Unique key for the directory
+
+        Returns:
+            True if directory is managed, False otherwise
+        """
+        return directory_key in self.managed_directories
+
+    def get_all_managed_directories(self) -> Dict[str, ParentDirectoryConfig]:
+        """
+        Get all managed directory configurations.
+
+        Returns:
+            Dictionary of all managed directories
+        """
+        return self.managed_directories.copy()