py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/update/services/backup_manager.py

@@ -0,0 +1,207 @@
+"""
+Backup Manager - manages backup and rollback of .wl directory.
+"""
+
+from __future__ import annotations
+
+import shutil
+import time
+import uuid
+from typing import TYPE_CHECKING
+
+from wl_cli.utils.logging import log_info_pair
+
+from ....utils.root import RootKind
+from ....utils.root_fallback import current_root
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class BackupManager:
+    """Manage backup and rollback of .wl directory."""
+
+    MAX_BACKUPS = 5
+
+    def __init__(self, wl_dir: Path | None = None):
+        """Initialize BackupManager.
+
+        Args:
+            wl_dir: Path to .wl directory. Defaults to './.wl'.
+        """
+        # Root-anchored (#125): the deploy root's ``.wl``, not the process
+        # CWD's, so ``wl update rollback`` from a subdirectory finds the root's
+        # backups instead of none. The scratch snapshots below
+        # (``temp_backup / ".wl"``) are deliberately *not* root-derived: they are
+        # a matched write/restore pair, not a deployed config path.
+        self.wl_dir = wl_dir or current_root(RootKind.DEPLOY).wl_dir()
+        self.backup_dir = self.wl_dir / "backup"
+
+    def _ensure_backup_dir(self) -> None:
+        """Ensure backup directory exists."""
+        self.backup_dir.mkdir(parents=True, exist_ok=True)
+
+    def _generate_backup_id(self) -> str:
+        """Generate a unique backup ID based on timestamp and random UUID.
+
+        Returns:
+            Backup ID string.
+        """
+        import time as time_module
+
+        timestamp = time_module.strftime("%Y%m%d_%H%M%S")
+        micros = str(int(time_module.time() * 1_000_000))[-6:]
+        random_suffix = str(uuid.uuid4())[:4]
+        return f"backup_{timestamp}_{micros}_{random_suffix}"
+
+    def create_backup(self) -> str:
+        """Create a backup of the current .wl directory.
+
+        Returns:
+            Backup ID of the created backup.
+        """
+        backup_id = self._generate_backup_id()
+        backup_path = self.backup_dir / backup_id
+
+        log_info_pair(f"Creating backup: {backup_id}", f"正在创建备份：{backup_id}")
+
+        self._ensure_backup_dir()
+        backup_path.mkdir(parents=True, exist_ok=True)
+
+        if self.wl_dir.exists():
+            self._copy_directory_contents(self.wl_dir, backup_path)
+
+        self.cleanup_old_backups()
+
+        log_info_pair(f"✓ Backup created: {backup_id}", f"✓ 备份已创建：{backup_id}")
+
+        return backup_id
+
+    def _copy_directory_contents(self, source: Path, dest: Path) -> None:
+        """Copy contents from source directory to destination, skipping backup.
+
+        Args:
+            source: Source directory path
+            dest: Destination directory path
+        """
+        for item in source.iterdir():
+            if item.name == "backup":
+                continue
+            target = dest / item.name
+            dest.mkdir(parents=True, exist_ok=True)
+            if item.is_dir():
+                shutil.copytree(str(item), str(target), dirs_exist_ok=True)
+            else:
+                shutil.copy2(str(item), str(target))
+
+    def _clear_wl_directory(self) -> None:
+        """Clear contents of .wl directory, keeping backup folder."""
+        self.wl_dir.mkdir(parents=True, exist_ok=True)
+        for item in list(self.wl_dir.iterdir()):
+            if item.name == "backup":
+                continue
+            if item.is_dir():
+                shutil.rmtree(str(item))
+            else:
+                item.unlink()
+
+    def _restore_from_temp_backup(self, temp_backup: Path) -> None:
+        """Restore from temporary backup directory.
+
+        Args:
+            temp_backup: Temporary backup directory path
+        """
+        # `.wl` here is the scratch snapshot's inner directory name, matched
+        # between write and restore -- not a root-derived config path (#121).
+        temp_wl_dir = temp_backup / ".wl"
+        if temp_wl_dir.exists():
+            self._clear_wl_directory()
+            self._copy_directory_contents(temp_wl_dir, self.wl_dir)
+        shutil.rmtree(str(temp_backup))
+
+    def rollback_to_backup(self, backup_id: str | None = None) -> bool:
+        """Rollback to a specific backup or the latest one.
+
+        Args:
+            backup_id: Optional backup ID to rollback to. If None, uses latest.
+
+        Returns:
+            True if rollback successful, False otherwise.
+        """
+        if not backup_id:
+            backups = self.list_backups()
+            if not backups:
+                log_info_pair(
+                    "No backups available to rollback to", "没有可用的备份可回滚"
+                )
+                return False
+            backup_id = backups[-1]
+
+        backup_path = self.backup_dir / backup_id
+
+        if not backup_path.exists():
+            log_info_pair(f"Backup not found: {backup_id}", f"备份不存在：{backup_id}")
+            return False
+
+        log_info_pair(
+            f"Rolling back to backup: {backup_id}", f"正在回滚到备份：{backup_id}"
+        )
+
+        temp_backup = None
+        try:
+            if self.wl_dir.exists():
+                temp_backup = (
+                    self.wl_dir.parent / f".wl_rollback_temp_{int(time.time())}"
+                )
+                # Scratch snapshot layout name; matched by _restore_from_temp_backup.
+                temp_wl_dir = temp_backup / ".wl"
+                self._copy_directory_contents(self.wl_dir, temp_wl_dir)
+
+            self._clear_wl_directory()
+            self._copy_directory_contents(backup_path, self.wl_dir)
+
+            if temp_backup and temp_backup.exists():
+                shutil.rmtree(str(temp_backup))
+
+            log_info_pair(
+                f"✓ Rollback successful to: {backup_id}", f"✓ 成功回滚到：{backup_id}"
+            )
+            return True
+
+        except Exception as e:
+            if temp_backup and temp_backup.exists():
+                self._restore_from_temp_backup(temp_backup)
+
+            log_info_pair(f"Rollback failed: {e}", f"回滚失败：{e}")
+            return False
+
+    def list_backups(self) -> list[str]:
+        """List all available backups.
+
+        Returns:
+            List of backup IDs, sorted from oldest to newest.
+        """
+        if not self.backup_dir.exists():
+            return []
+
+        backups = []
+        for item in self.backup_dir.iterdir():
+            if item.is_dir() and item.name.startswith("backup_"):
+                backups.append(item.name)
+
+        backups.sort()
+        return backups
+
+    def cleanup_old_backups(self) -> None:
+        """Clean up old backups, keeping only the most recent MAX_BACKUPS."""
+        backups = self.list_backups()
+
+        if len(backups) > self.MAX_BACKUPS:
+            to_remove = backups[: len(backups) - self.MAX_BACKUPS]
+
+            for backup_id in to_remove:
+                backup_path = self.backup_dir / backup_id
+                log_info_pair(
+                    f"Removing old backup: {backup_id}", f"移除旧备份：{backup_id}"
+                )
+                shutil.rmtree(backup_path)

wl_cli/commands/update/services/component_manager.py

@@ -0,0 +1,83 @@
+"""
+Component manager for managing updatable components.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+class ComponentManager:
+    """Manage updatable components."""
+
+    def __init__(self):
+        """Initialize ComponentManager with default components."""
+        self._components: dict[str, dict] = {
+            "git_config": {
+                "description": "Git configuration files",
+                "source_path": "vendors/git/",
+            },
+            "editor_config": {
+                "description": "Editor configuration",
+                "source_path": "vendors/config/",
+            },
+        }
+
+    def get_all_components(self) -> dict[str, dict]:
+        """Get all updatable components.
+
+        Returns:
+            Dictionary of all components with their information.
+        """
+        return self._components.copy()
+
+    def get_component(self, component_id: str) -> dict | None:
+        """Get component information by ID.
+
+        Args:
+            component_id: ID of the component to get.
+
+        Returns:
+            Component information if found, None otherwise.
+        """
+        return self._components.get(component_id)
+
+    def component_exists(self, component_id: str) -> bool:
+        """Check if component exists.
+
+        Args:
+            component_id: ID of the component to check.
+
+        Returns:
+            True if component exists, False otherwise.
+        """
+        return component_id in self._components
+
+    def get_component_source_path(self, component_id: str) -> Path | None:
+        """Get component source path.
+
+        Args:
+            component_id: ID of the component.
+
+        Returns:
+            Source path as Path object if component exists, None otherwise.
+        """
+        component = self.get_component(component_id)
+        if component:
+            return Path(component["source_path"])
+        return None
+
+    def register_component(
+        self, component_id: str, description: str, source_path: str
+    ) -> None:
+        """Register a new component.
+
+        Args:
+            component_id: ID of the new component.
+            description: Description of the new component.
+            source_path: Source path of the new component.
+        """
+        self._components[component_id] = {
+            "description": description,
+            "source_path": source_path,
+        }

wl_cli/commands/update/services/conflict_resolver.py

@@ -0,0 +1,189 @@
+"""
+Conflict Resolver - detects and resolves file conflicts.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from wl_cli.commands.update.services.version_tracker import VersionTracker
+from wl_cli.utils.logging import log_info_pair
+
+from ....utils.root import RootKind
+from ....utils.root_fallback import current_root
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class ConflictResolution(Enum):
+    """Conflict resolution strategies."""
+
+    OVERWRITE = "overwrite"
+    KEEP = "keep"
+    SKIP = "skip"
+
+
+class ConflictResolver:
+    """Detect and resolve file conflicts."""
+
+    def __init__(self, wl_dir: Path | None = None):
+        """Initialize ConflictResolver.
+
+        Args:
+            wl_dir: Path to .wl directory. Defaults to './.wl'.
+        """
+        # Root-anchored (#125): the deploy root's ``.wl``, matching the update
+        # family this resolver serves. Was a bare ``Path(".wl")``, i.e. the
+        # process CWD's ``.wl`` (no production caller yet, but same ruling).
+        self.wl_dir = wl_dir or current_root(RootKind.DEPLOY).wl_dir()
+        self.version_tracker = VersionTracker(self.wl_dir)
+
+    def compute_file_hash(self, file_path: Path) -> str:
+        """Compute SHA-256 hash of a file.
+
+        Args:
+            file_path: Path to the file.
+
+        Returns:
+            SHA-256 hash of the file content.
+        """
+        if not file_path.exists():
+            return ""
+
+        hash_obj = hashlib.sha256()
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                hash_obj.update(chunk)
+        return hash_obj.hexdigest()
+
+    def detect_conflicts(
+        self, source_dir: Path, target_dir: Path
+    ) -> dict[str, ConflictResolution]:
+        """Detect conflicts between source and target files.
+
+        Args:
+            source_dir: Source directory path.
+            target_dir: Target directory path.
+
+        Returns:
+            Dictionary mapping file paths to conflict resolution status.
+        """
+        conflicts: dict[str, ConflictResolution] = {}
+
+        if not source_dir.exists() or not target_dir.exists():
+            return conflicts
+
+        for source_file in source_dir.rglob("*"):
+            if not source_file.is_file():
+                continue
+
+            relative_path = source_file.relative_to(source_dir)
+            target_file = target_dir / relative_path
+
+            if target_file.exists():
+                source_hash = self.compute_file_hash(source_file)
+                target_hash = self.compute_file_hash(target_file)
+
+                if source_hash != target_hash:
+                    file_path_str = str(relative_path)
+
+                    if self.version_tracker.is_custom_file(file_path_str):
+                        conflicts[file_path_str] = ConflictResolution.KEEP
+                    else:
+                        conflicts[file_path_str] = ConflictResolution.OVERWRITE
+
+        return conflicts
+
+    def resolve_conflict(
+        self,
+        file_path: str,
+        source_file: Path,
+        target_file: Path,
+        resolution: ConflictResolution,
+    ) -> bool:
+        """Resolve a file conflict using specified strategy.
+
+        Args:
+            file_path: Relative path to the file.
+            source_file: Source file path.
+            target_file: Target file path.
+            resolution: Conflict resolution strategy.
+
+        Returns:
+            True if conflict resolved successfully, False otherwise.
+        """
+        if resolution == ConflictResolution.OVERWRITE:
+            log_info_pair(f"Overwriting: {file_path}", f"正在覆盖：{file_path}")
+
+            target_file.parent.mkdir(parents=True, exist_ok=True)
+            import shutil
+
+            shutil.copy2(source_file, target_file)
+
+            if self.version_tracker.is_custom_file(file_path):
+                self.version_tracker.remove_custom_file(file_path)
+
+            return True
+
+        elif resolution == ConflictResolution.KEEP:
+            log_info_pair(
+                f"Keeping user modified: {file_path}", f"保留用户修改：{file_path}"
+            )
+
+            if not self.version_tracker.is_custom_file(file_path):
+                self.version_tracker.add_custom_file(file_path)
+
+            return True
+
+        elif resolution == ConflictResolution.SKIP:
+            log_info_pair(f"Skipping: {file_path}", f"跳过：{file_path}")
+            return True
+
+        return False
+
+    def identify_custom_files(self, source_dir: Path, target_dir: Path) -> list[str]:
+        """Identify files in target that have been modified by user.
+
+        Args:
+            source_dir: Source directory (original template).
+            target_dir: Target directory (user's copy).
+
+        Returns:
+            List of custom file paths.
+        """
+        custom_files: list[str] = []
+
+        if not source_dir.exists() or not target_dir.exists():
+            return custom_files
+
+        for target_file in target_dir.rglob("*"):
+            if not target_file.is_file():
+                continue
+
+            relative_path = target_file.relative_to(target_dir)
+            source_file = source_dir / relative_path
+
+            if source_file.exists():
+                source_hash = self.compute_file_hash(source_file)
+                target_hash = self.compute_file_hash(target_file)
+
+                if source_hash != target_hash:
+                    custom_files.append(str(relative_path))
+            else:
+                custom_files.append(str(relative_path))
+
+        return custom_files
+
+    def mark_as_custom(self, file_path: str) -> None:
+        """Mark a file as user-customized.
+
+        Args:
+            file_path: Path to the file.
+        """
+        self.version_tracker.add_custom_file(file_path)
+        log_info_pair(
+            f"Marked as custom: {file_path}", f"已标记为自定义文件：{file_path}"
+        )

wl_cli/commands/update/services/vendors_updater.py

@@ -0,0 +1,85 @@
+"""
+Vendors Updater - manages updating vendor templates from package.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wl_cli.utils.logging import log_info_pair
+from wl_cli.utils.wl_dir_updater import (
+    _get_package_vendors_path,
+    check_and_update_vendors,
+)
+
+from ....utils.root import RootKind
+from ....utils.root_fallback import current_root
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class VendorsUpdater:
+    """Manage updating vendor templates from package."""
+
+    def __init__(self, wl_dir: Path | None = None):
+        """Initialize VendorsUpdater.
+
+        Args:
+            wl_dir: Path to .wl directory. Defaults to './.wl'.
+        """
+        # Root-anchored (#125): the deploy root's ``.wl``, matching the update
+        # family. ``self.wl_dir`` is currently never read, so the value is inert
+        # -- fixed for consistency, not because a path was observed wrong.
+        self.wl_dir = wl_dir or current_root(RootKind.DEPLOY).wl_dir()
+        self.package_vendors_path = _get_package_vendors_path()
+
+    def update(
+        self,
+        dry_run: bool = False,
+        component_id: str | None = None,
+        force: bool = False,
+    ) -> dict:
+        """Update vendors directory.
+
+        Args:
+            dry_run: If True, only show what would be done.
+            component_id: Optional specific component to update.
+            force: Copy even when the vendor stamp is already current.
+
+        Returns:
+            Update result dictionary.
+        """
+        log_info_pair("Starting vendor update...", "开始更新供应商模板...")
+
+        result: dict = check_and_update_vendors(
+            dry_run=dry_run, component_id=component_id, force=force
+        )
+
+        if dry_run:
+            log_info_pair(
+                "Dry run completed. No changes made.", "干运行完成，未做任何更改。"
+            )
+        else:
+            if result.get("updated"):
+                log_info_pair("Vendors updated successfully!", "供应商模板更新成功！")
+            else:
+                log_info_pair(
+                    "Vendors are already up to date.", "供应商模板已是最新版本。"
+                )
+
+        return result
+
+    def check(self) -> dict:
+        """Check for vendor updates.
+
+        Returns:
+            Check result dictionary.
+        """
+        log_info_pair("Checking for vendor updates...", "检查供应商模板更新...")
+
+        result: dict = check_and_update_vendors(dry_run=True)
+
+        log_info_pair("Check completed.", "检查完成。")
+
+        return result

wl_cli/commands/update/services/version_tracker.py

@@ -0,0 +1,127 @@
+"""
+Version tracker for managing version information of vendor templates.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class VersionTracker:
+    """Manage version tracking for vendor templates."""
+
+    VERSION_FILE = ".version.json"
+
+    def __init__(self, wl_dir: Path):
+        """Initialize VersionTracker.
+
+        Args:
+            wl_dir: Path to .wl directory.
+        """
+        self.wl_dir = wl_dir
+        self.vendors_dir = wl_dir / "vendors"
+        self.version_file = self.vendors_dir / self.VERSION_FILE
+
+    def ensure_vendors_dir(self) -> None:
+        """Ensure vendors directory exists."""
+        self.vendors_dir.mkdir(parents=True, exist_ok=True)
+
+    def get_version_info(self) -> dict | None:
+        """Get current version information.
+
+        Returns:
+            Version information dict if file exists and valid, None otherwise.
+        """
+        if not self.version_file.exists():
+            return None
+
+        try:
+            with open(self.version_file, encoding="utf-8") as f:
+                data: dict = json.load(f)
+                return data
+        except (OSError, json.JSONDecodeError):
+            return None
+
+    def update_version_info(
+        self, version: str, source: str, custom_files: list[str] | None = None
+    ) -> None:
+        """Update version information.
+
+        Args:
+            version: Version string.
+            source: Source of the update.
+            custom_files: Optional list of custom files to track.
+        """
+        self.ensure_vendors_dir()
+
+        version_info = {
+            "version": version,
+            "last_updated": datetime.now().isoformat(),
+            "source": source,
+            "custom_files": custom_files or [],
+        }
+
+        with open(self.version_file, "w", encoding="utf-8") as f:
+            json.dump(version_info, f, indent=2, ensure_ascii=False)
+
+    def add_custom_file(self, file_path: str) -> None:
+        """Add custom file to tracking list.
+
+        Args:
+            file_path: Path to custom file.
+        """
+        version_info = self.get_version_info() or {}
+        custom_files = version_info.get("custom_files", [])
+
+        if file_path not in custom_files:
+            custom_files.append(file_path)
+            version_info["custom_files"] = custom_files
+
+            if "version" in version_info and "source" in version_info:
+                self.update_version_info(
+                    version_info["version"],
+                    version_info["source"],
+                    custom_files,
+                )
+
+    def remove_custom_file(self, file_path: str) -> None:
+        """Remove custom file from tracking list.
+
+        Args:
+            file_path: Path to custom file to remove.
+        """
+        version_info = self.get_version_info()
+        if not version_info:
+            return
+
+        custom_files = version_info.get("custom_files", [])
+        if file_path in custom_files:
+            custom_files.remove(file_path)
+            version_info["custom_files"] = custom_files
+
+            if "version" in version_info and "source" in version_info:
+                self.update_version_info(
+                    version_info["version"],
+                    version_info["source"],
+                    custom_files,
+                )
+
+    def is_custom_file(self, file_path: str) -> bool:
+        """Check if file is a custom file.
+
+        Args:
+            file_path: Path to check.
+
+        Returns:
+            True if file is in custom files list, False otherwise.
+        """
+        version_info = self.get_version_info()
+        if not version_info:
+            return False
+
+        return file_path in version_info.get("custom_files", [])