moai-adk 0.15.1__py3-none-any.whl → 0.25.4__py3-none-any.whl

moai_adk/core/migration/backup_manager.py

@@ -0,0 +1,208 @@
+"""
+Backup management module for MoAI-ADK migrations
+
+Creates and manages backups during migration processes
+to ensure data safety and enable rollback.
+"""
+
+import json
+import logging
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class BackupManager:
+    """Manages backup creation and restoration for migrations"""
+
+    def __init__(self, project_root: Path):
+        """
+        Initialize backup manager
+
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = Path(project_root)
+        self.backup_base_dir = self.project_root / ".moai" / "backups"
+        self.backup_base_dir.mkdir(parents=True, exist_ok=True)
+
+    def create_backup(self, description: str = "migration") -> Path:
+        """
+        Create a full backup of configuration files
+
+        Args:
+            description: Description of this backup
+
+        Returns:
+            Path to the backup directory
+        """
+        # Create timestamped backup directory
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_dir = self.backup_base_dir / f"{description}_{timestamp}"
+        backup_dir.mkdir(parents=True, exist_ok=True)
+
+        logger.info(f"Creating backup at {backup_dir}")
+
+        # Files to backup
+        backup_targets = [
+            self.project_root / ".moai" / "config.json",
+            self.project_root / ".moai" / "config" / "config.json",
+            self.project_root / ".claude" / "statusline-config.yaml",
+            self.project_root / ".moai" / "config" / "statusline-config.yaml",
+        ]
+
+        backed_up_files = []
+
+        for target in backup_targets:
+            if target.exists():
+                # Preserve relative path structure in backup
+                rel_path = target.relative_to(self.project_root)
+                backup_path = backup_dir / rel_path
+
+                # Create parent directories
+                backup_path.parent.mkdir(parents=True, exist_ok=True)
+
+                # Copy file
+                shutil.copy2(target, backup_path)
+                backed_up_files.append(str(rel_path))
+                logger.debug(f"Backed up: {rel_path}")
+
+        # Save backup metadata
+        metadata = {
+            "timestamp": timestamp,
+            "description": description,
+            "backed_up_files": backed_up_files,
+            "project_root": str(self.project_root),
+        }
+
+        metadata_path = backup_dir / "backup_metadata.json"
+        with open(metadata_path, "w") as f:
+            json.dump(metadata, f, indent=2)
+
+        logger.info(f"✅ Backup created successfully: {backup_dir}")
+        return backup_dir
+
+    def list_backups(self) -> List[Dict[str, str]]:
+        """
+        List all available backups
+
+        Returns:
+            List of backup information dictionaries
+        """
+        backups = []
+
+        if not self.backup_base_dir.exists():
+            return backups
+
+        for backup_dir in sorted(self.backup_base_dir.iterdir(), reverse=True):
+            if backup_dir.is_dir():
+                metadata_path = backup_dir / "backup_metadata.json"
+                if metadata_path.exists():
+                    try:
+                        with open(metadata_path, "r") as f:
+                            metadata = json.load(f)
+                            backups.append(
+                                {
+                                    "path": str(backup_dir),
+                                    "timestamp": metadata.get("timestamp", "unknown"),
+                                    "description": metadata.get(
+                                        "description", "unknown"
+                                    ),
+                                    "files": len(metadata.get("backed_up_files", [])),
+                                }
+                            )
+                    except Exception as e:
+                        logger.warning(f"Failed to read backup metadata: {e}")
+
+        return backups
+
+    def restore_backup(self, backup_path: Path) -> bool:
+        """
+        Restore files from a backup
+
+        Args:
+            backup_path: Path to the backup directory
+
+        Returns:
+            True if restore was successful, False otherwise
+        """
+        backup_path = Path(backup_path)
+
+        if not backup_path.exists():
+            logger.error(f"Backup directory not found: {backup_path}")
+            return False
+
+        metadata_path = backup_path / "backup_metadata.json"
+        if not metadata_path.exists():
+            logger.error(f"Backup metadata not found: {metadata_path}")
+            return False
+
+        try:
+            # Read metadata
+            with open(metadata_path, "r") as f:
+                metadata = json.load(f)
+
+            logger.info(f"Restoring backup from {backup_path}")
+
+            # Restore each file
+            for rel_path in metadata.get("backed_up_files", []):
+                backup_file = backup_path / rel_path
+                target_file = self.project_root / rel_path
+
+                if backup_file.exists():
+                    # Create parent directories
+                    target_file.parent.mkdir(parents=True, exist_ok=True)
+
+                    # Restore file
+                    shutil.copy2(backup_file, target_file)
+                    logger.debug(f"Restored: {rel_path}")
+
+            logger.info("✅ Backup restored successfully")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to restore backup: {e}")
+            return False
+
+    def cleanup_old_backups(self, keep_count: int = 5) -> int:
+        """
+        Clean up old backups, keeping only the most recent ones
+
+        Args:
+            keep_count: Number of recent backups to keep
+
+        Returns:
+            Number of backups deleted
+        """
+        backups = self.list_backups()
+
+        if len(backups) <= keep_count:
+            return 0
+
+        deleted_count = 0
+        for backup_info in backups[keep_count:]:
+            backup_path = Path(backup_info["path"])
+            try:
+                shutil.rmtree(backup_path)
+                deleted_count += 1
+                logger.debug(f"Deleted old backup: {backup_path}")
+            except Exception as e:
+                logger.warning(f"Failed to delete backup {backup_path}: {e}")
+
+        logger.info(f"Cleaned up {deleted_count} old backups")
+        return deleted_count
+
+    def get_latest_backup(self) -> Optional[Path]:
+        """
+        Get the most recent backup
+
+        Returns:
+            Path to the latest backup directory, or None if no backups exist
+        """
+        backups = self.list_backups()
+        if backups:
+            return Path(backups[0]["path"])
+        return None

moai_adk/core/migration/file_migrator.py

@@ -0,0 +1,218 @@
+"""
+File migration module for MoAI-ADK version upgrades
+
+Handles the actual file movement and directory creation
+during migration processes.
+"""
+
+import logging
+import shutil
+from pathlib import Path
+from typing import Dict, List
+
+logger = logging.getLogger(__name__)
+
+
+class FileMigrator:
+    """Handles file operations during migrations"""
+
+    def __init__(self, project_root: Path):
+        """
+        Initialize file migrator
+
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = Path(project_root)
+        self.moved_files: List[Dict[str, str]] = []
+        self.created_dirs: List[str] = []
+
+    def create_directory(self, directory: Path) -> bool:
+        """
+        Create a directory if it doesn't exist
+
+        Args:
+            directory: Directory path to create
+
+        Returns:
+            True if directory was created or already exists
+        """
+        try:
+            directory = Path(directory)
+            directory.mkdir(parents=True, exist_ok=True)
+            self.created_dirs.append(str(directory))
+            logger.debug(f"Created directory: {directory}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to create directory {directory}: {e}")
+            return False
+
+    def move_file(
+        self, source: Path, destination: Path, copy_instead: bool = True
+    ) -> bool:
+        """
+        Move a file from source to destination
+
+        Args:
+            source: Source file path
+            destination: Destination file path
+            copy_instead: If True, copy instead of move (safer)
+
+        Returns:
+            True if operation was successful
+        """
+        source = Path(source)
+        destination = Path(destination)
+
+        if not source.exists():
+            logger.warning(f"Source file not found: {source}")
+            return False
+
+        if destination.exists():
+            logger.info(f"Destination already exists, skipping: {destination}")
+            return True
+
+        try:
+            # Ensure destination directory exists
+            destination.parent.mkdir(parents=True, exist_ok=True)
+
+            # Copy or move file
+            if copy_instead:
+                shutil.copy2(source, destination)
+                logger.debug(f"Copied: {source} → {destination}")
+            else:
+                shutil.move(str(source), str(destination))
+                logger.debug(f"Moved: {source} → {destination}")
+
+            # Record operation
+            self.moved_files.append({"from": str(source), "to": str(destination)})
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to move file {source} to {destination}: {e}")
+            return False
+
+    def delete_file(self, file_path: Path, safe: bool = True) -> bool:
+        """
+        Delete a file
+
+        Args:
+            file_path: Path to the file to delete
+            safe: If True, only delete if it's a known safe file
+
+        Returns:
+            True if deletion was successful
+        """
+        file_path = Path(file_path)
+
+        if not file_path.exists():
+            logger.debug(f"File already deleted: {file_path}")
+            return True
+
+        # Safety check for safe mode
+        if safe:
+            safe_patterns = [
+                ".moai/config.json",
+                ".claude/statusline-config.yaml",
+            ]
+            is_safe = any(
+                str(file_path.relative_to(self.project_root)).endswith(pattern)
+                for pattern in safe_patterns
+            )
+            if not is_safe:
+                logger.warning(f"Refusing to delete non-safe file: {file_path}")
+                return False
+
+        try:
+            file_path.unlink()
+            logger.debug(f"Deleted: {file_path}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to delete file {file_path}: {e}")
+            return False
+
+    def execute_migration_plan(self, plan: Dict[str, List]) -> Dict[str, any]:
+        """
+        Execute a migration plan
+
+        Args:
+            plan: Migration plan dictionary with 'create', 'move', 'cleanup' keys
+
+        Returns:
+            Dictionary with execution results
+        """
+        results = {
+            "success": True,
+            "created_dirs": 0,
+            "moved_files": 0,
+            "cleaned_files": 0,
+            "errors": [],
+        }
+
+        # Create directories
+        for directory in plan.get("create", []):
+            dir_path = self.project_root / directory
+            if self.create_directory(dir_path):
+                results["created_dirs"] += 1
+            else:
+                results["errors"].append(f"Failed to create directory: {directory}")
+                results["success"] = False
+
+        # Move files
+        for move_op in plan.get("move", []):
+            source = self.project_root / move_op["from"]
+            dest = self.project_root / move_op["to"]
+
+            if self.move_file(source, dest, copy_instead=True):
+                results["moved_files"] += 1
+                logger.info(
+                    f"✅ {move_op['description']}: {move_op['from']} → {move_op['to']}"
+                )
+            else:
+                results["errors"].append(
+                    f"Failed to move: {move_op['from']} → {move_op['to']}"
+                )
+                results["success"] = False
+
+        return results
+
+    def cleanup_old_files(self, cleanup_list: List[str], dry_run: bool = False) -> int:
+        """
+        Clean up old files after successful migration
+
+        Args:
+            cleanup_list: List of file paths to clean up
+            dry_run: If True, only show what would be deleted
+
+        Returns:
+            Number of files cleaned up
+        """
+        cleaned = 0
+
+        for file_path in cleanup_list:
+            full_path = self.project_root / file_path
+
+            if dry_run:
+                if full_path.exists():
+                    logger.info(f"Would delete: {file_path}")
+                    cleaned += 1
+            else:
+                if self.delete_file(full_path, safe=True):
+                    logger.info(f"🗑️  Cleaned up: {file_path}")
+                    cleaned += 1
+
+        return cleaned
+
+    def get_migration_summary(self) -> Dict[str, any]:
+        """
+        Get summary of migration operations performed
+
+        Returns:
+            Dictionary with migration summary
+        """
+        return {
+            "moved_files": len(self.moved_files),
+            "created_directories": len(self.created_dirs),
+            "operations": self.moved_files,
+        }

moai_adk/core/migration/version_detector.py

@@ -0,0 +1,143 @@
+"""
+Version detection module for MoAI-ADK projects
+
+Detects the current version of a project and determines
+which migrations are needed.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class VersionDetector:
+    """Detects project version and migration requirements"""
+
+    def __init__(self, project_root: Path):
+        """
+        Initialize version detector
+
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = Path(project_root)
+        self.old_config = self.project_root / ".moai" / "config.json"
+        self.new_config = self.project_root / ".moai" / "config" / "config.json"
+        self.old_statusline = self.project_root / ".claude" / "statusline-config.yaml"
+        self.new_statusline = (
+            self.project_root / ".moai" / "config" / "statusline-config.yaml"
+        )
+
+    def detect_version(self) -> str:
+        """
+        Detect current project version based on file structure
+
+        Returns:
+            Version string (e.g., "0.23.0", "0.24.0+", "unknown")
+        """
+        # Check if already migrated to v0.24.0+
+        if self.new_config.exists():
+            return "0.24.0+"
+
+        # Check if v0.23.0 or earlier
+        if self.old_config.exists():
+            try:
+                with open(self.old_config, "r") as f:
+                    config_data = json.load(f)
+                    # Try to get version from config
+                    if "moai_version" in config_data:
+                        return config_data["moai_version"]
+                    return "0.23.0"
+            except Exception as e:
+                logger.warning(f"Failed to read old config: {e}")
+                return "0.23.0"
+
+        return "unknown"
+
+    def needs_migration(self) -> bool:
+        """
+        Check if project needs migration
+
+        Returns:
+            True if migration is needed, False otherwise
+        """
+        version = self.detect_version()
+        if version == "unknown":
+            logger.info("Unknown version, assuming no migration needed")
+            return False
+
+        if version == "0.24.0+":
+            logger.info("Project already on v0.24.0+")
+            return False
+
+        # Version 0.23.0 or earlier needs migration
+        return True
+
+    def get_migration_plan(self) -> Dict[str, List[Dict[str, str]]]:
+        """
+        Get detailed migration plan
+
+        Returns:
+            Dictionary with migration actions:
+            {
+                "move": [{"from": "...", "to": "..."}],
+                "create": ["directory1", "directory2"],
+                "cleanup": ["old_file1", "old_file2"]
+            }
+        """
+        plan = {"move": [], "create": [], "cleanup": []}
+
+        if not self.needs_migration():
+            return plan
+
+        # Create config directory
+        plan["create"].append(str(self.project_root / ".moai" / "config"))
+
+        # Move config.json
+        if self.old_config.exists() and not self.new_config.exists():
+            plan["move"].append(
+                {
+                    "from": str(self.old_config.relative_to(self.project_root)),
+                    "to": str(self.new_config.relative_to(self.project_root)),
+                    "description": "Main configuration file",
+                }
+            )
+
+        # Move statusline-config.yaml
+        if self.old_statusline.exists() and not self.new_statusline.exists():
+            plan["move"].append(
+                {
+                    "from": str(self.old_statusline.relative_to(self.project_root)),
+                    "to": str(self.new_statusline.relative_to(self.project_root)),
+                    "description": "Statusline configuration",
+                }
+            )
+
+        # Cleanup old files (after successful migration)
+        if self.old_config.exists():
+            plan["cleanup"].append(str(self.old_config.relative_to(self.project_root)))
+        if self.old_statusline.exists():
+            plan["cleanup"].append(
+                str(self.old_statusline.relative_to(self.project_root))
+            )
+
+        return plan
+
+    def get_version_info(self) -> Dict[str, Optional[str]]:
+        """
+        Get detailed version information
+
+        Returns:
+            Dictionary with version details
+        """
+        return {
+            "detected_version": self.detect_version(),
+            "needs_migration": self.needs_migration(),
+            "has_old_config": self.old_config.exists(),
+            "has_new_config": self.new_config.exists(),
+            "has_old_statusline": self.old_statusline.exists(),
+            "has_new_statusline": self.new_statusline.exists(),
+        }