py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/update/update_command.py

@@ -0,0 +1,270 @@
+"""
+Update command group for wl_cli.
+
+This module provides the 'wl update' command family.
+"""
+
+from typing import cast
+
+import click
+
+from wl_cli.commands.update.services.backup_manager import BackupManager
+from wl_cli.commands.update.services.component_manager import ComponentManager
+from wl_cli.commands.update.services.vendors_updater import VendorsUpdater
+from wl_cli.utils.logging import log_info_pair
+from wl_cli.utils.wl_dir_updater import check_and_update_wl_dir, compare_versions
+
+from ...utils.root import RootKind
+from ...utils.root_fallback import current_root
+
+
+@click.group(
+    name="update",
+    help="Update commands for wl_cli itself and vendor templates.",
+)
+def update_command():
+    """Update command group."""
+    pass
+
+
+@update_command.command()
+@click.argument("path", default=None, required=False)
+def self(path: str | None = None):
+    """Update wl_cli itself (alias for 'wl self update').
+
+    Args:
+        path: Optional path to local source or version specification.
+    """
+    from wl_cli.commands.self.self_command import (
+        self_command as original_self_command,
+    )
+
+    ctx = click.get_current_context()
+    args = ["update"]
+    if path:
+        args.append(path)
+
+    with cast("click.Context", ctx.parent):
+        original_self_command.main(args=args, standalone_mode=True)
+
+
+@update_command.command()
+@click.option(
+    "--check", is_flag=True, help="Check for updates without applying changes"
+)
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be updated without making changes"
+)
+@click.option("--force", is_flag=True, help="Force update even if already up to date")
+@click.option("--backup", is_flag=True, help="Create backup before updating")
+def vendor(
+    check: bool = False,
+    dry_run: bool = False,
+    force: bool = False,
+    backup: bool = False,
+):
+    """Update vendor templates and .wl directory.
+
+    Args:
+        check: Only check for updates without applying changes
+        dry_run: Show what would be updated without making changes
+        force: Force update even if already up to date
+        backup: Create backup before updating
+    """
+    import json
+
+    from wl_cli import __version__
+
+    log_info_pair("Checking vendor template updates...", "正在检查供应商模板更新...")
+
+    # Root-anchored (#125): was a bare ``Path(".wl")`` against the process CWD,
+    # so ``wl update vendor`` from a subdirectory read the subdirectory's ``.wl``
+    # and reported "no .wl directory"; it now reads the deploy root's. See
+    # docs/adr/0006-root-resolution-layering.md.
+    wl_dir = current_root(RootKind.DEPLOY).wl_dir()
+    if not wl_dir.exists():
+        log_info_pair(
+            "No .wl directory found. Run 'wl init' first.",
+            "未找到 .wl 目录，请先运行 'wl init'。",
+        )
+        return
+
+    if check or dry_run:
+        config_file = wl_dir / "config.json"
+        if config_file.exists():
+            try:
+                with open(config_file, encoding="utf-8") as f:
+                    config = json.load(f)
+                wl_dir_version = config.get("version", "unknown")
+                log_info_pair(
+                    f"Current .wl directory version: {wl_dir_version}",
+                    f"当前 .wl 目录版本：{wl_dir_version}",
+                )
+                log_info_pair(
+                    f"Current wl version: {__version__}", f"当前 wl 版本：{__version__}"
+                )
+            except Exception as e:
+                log_info_pair(
+                    f"Could not read version info: {e}", f"无法读取版本信息：{e}"
+                )
+        else:
+            log_info_pair(
+                "No config.json found. Would create/update .wl directory.",
+                "未找到 config.json，将创建/更新 .wl 目录。",
+            )
+
+        # Vendor freshness comes from the independent .wl/vendors.version stamp
+        # (#177): config.json.version is advanced by the self-sync on every
+        # command, so a verdict read from it said "already up to date" even when
+        # the vendor tree was missing -- the next real update would then copy
+        # files. Reuse the same dry-run check the copy path uses; it reports its
+        # own bilingual verdict.
+        VendorsUpdater(wl_dir).check()
+
+        if dry_run:
+            log_info_pair(
+                "Would update vendor templates and .wl directory",
+                "将更新供应商模板和 .wl 目录",
+            )
+    else:
+        if backup:
+            backup_manager = BackupManager(wl_dir)
+            backup_manager.create_backup()
+
+        check_and_update_wl_dir()
+
+        vendors_updater = VendorsUpdater(wl_dir)
+        # ``force`` used to be a dead flag: declared and documented, never read.
+        # Pass it through so ``wl update vendor --force`` re-copies even when
+        # the vendor stamp is current (#177).
+        vendors_updater.update(dry_run=False, force=force)
+
+
+@update_command.command()
+def status():
+    """Show current version and status."""
+    import json
+
+    from wl_cli import __version__
+
+    log_info_pair("Update Status:", "更新状态：")
+    log_info_pair(f"  wl_cli version: {__version__}", f"  wl_cli 版本：{__version__}")
+
+    # Root-anchored (#125): the deploy root's ``.wl``, not the process CWD's.
+    wl_dir = current_root(RootKind.DEPLOY).wl_dir()
+    if wl_dir.exists():
+        config_file = wl_dir / "config.json"
+        if config_file.exists():
+            try:
+                with open(config_file, encoding="utf-8") as f:
+                    config = json.load(f)
+                wl_dir_version = config.get("version", "unknown")
+                log_info_pair(
+                    f"  .wl directory version: {wl_dir_version}",
+                    f"  .wl 目录版本：{wl_dir_version}",
+                )
+
+                version_compare = compare_versions(wl_dir_version, __version__)
+                if version_compare < 0:
+                    log_info_pair(
+                        "  Status: Updates available!", "  状态：有可用更新！"
+                    )
+                elif version_compare == 0:
+                    log_info_pair("  Status: Up to date", "  状态：已是最新")
+                else:
+                    log_info_pair(
+                        "  Status: .wl directory is newer than installed version",
+                        "  状态：.wl 目录比安装的版本新",
+                    )
+            except Exception as e:
+                log_info_pair(
+                    f"  Could not read version info: {e}", f"  无法读取版本信息：{e}"
+                )
+        else:
+            log_info_pair(
+                "  No config.json found in .wl directory",
+                "  .wl 目录中未找到 config.json",
+            )
+    else:
+        log_info_pair("  No .wl directory found", "  未找到 .wl 目录")
+
+
+@update_command.command()
+def list():
+    """List all available update components."""
+    component_manager = ComponentManager()
+    components = component_manager.get_all_components()
+
+    log_info_pair("Available update components:", "可用更新组件：")
+
+    for comp_id, comp_info in components.items():
+        log_info_pair(
+            f"  - {comp_id}: {comp_info['description']}",
+            f"  - {comp_id}：{comp_info['description']}",
+        )
+
+
+@update_command.command()
+@click.argument("backup_id", default=None, required=False)
+def rollback(backup_id: str | None = None):
+    """Rollback to a previous backup (latest if no ID specified).
+
+    Args:
+        backup_id: Optional specific backup ID to rollback to.
+    """
+    backup_manager = BackupManager()
+    backup_manager.rollback_to_backup(backup_id)
+
+
+@update_command.command()
+def check():
+    """Check for available updates."""
+    import json
+
+    from wl_cli import __version__
+
+    log_info_pair("Checking for updates...", "检查更新...")
+
+    # Root-anchored (#125): the deploy root's ``.wl``, not the process CWD's.
+    wl_dir = current_root(RootKind.DEPLOY).wl_dir()
+    if not wl_dir.exists():
+        log_info_pair(
+            "No .wl directory found. Run 'wl init' first.",
+            "未找到 .wl 目录，请先运行 'wl init'。",
+        )
+        return
+
+    config_file = wl_dir / "config.json"
+    if config_file.exists():
+        try:
+            with open(config_file, encoding="utf-8") as f:
+                config = json.load(f)
+            wl_dir_version = config.get("version", "unknown")
+            log_info_pair(
+                f"Current .wl directory version: {wl_dir_version}",
+                f"当前 .wl 目录版本：{wl_dir_version}",
+            )
+            log_info_pair(
+                f"Current wl version: {__version__}", f"当前 wl 版本：{__version__}"
+            )
+
+            version_compare = compare_versions(wl_dir_version, __version__)
+            if version_compare < 0:
+                log_info_pair("✓ Updates available!", "✓ 有可用更新！")
+            elif version_compare == 0:
+                log_info_pair("✓ Already up to date!", "✓ 已是最新版本！")
+            else:
+                log_info_pair(
+                    "! .wl directory version is newer than wl version",
+                    "! .wl 目录比安装的版本新",
+                )
+        except Exception as e:
+            log_info_pair(f"Could not read version info: {e}", f"无法读取版本信息：{e}")
+    else:
+        log_info_pair(
+            "No config.json found. Will create/update .wl directory.",
+            "未找到 config.json，将创建/更新 .wl 目录。",
+        )
+
+    vendors_updater = VendorsUpdater()
+    vendors_updater.check()

wl_cli/commands/update/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utilities for update command.
+"""

wl_cli/commands/version/__init__.py

@@ -0,0 +1,9 @@
+"""
+Version command module.
+
+This module provides version management commands.
+"""
+
+from .version_command import VersionCommand, version_command
+
+__all__ = ["VersionCommand", "version_command"]

wl_cli/commands/version/version_command.py

@@ -0,0 +1,155 @@
+"""
+Version command implementation for WL Commands.
+
+Provides commands to manage project versions:
+- show: Display current version
+- sync: Sync VERSION file to __init__.py and Cargo.toml
+- bump: Increment version number
+"""
+
+from typing import Any
+
+import click
+
+from ...commands import Command
+from ...exceptions import CommandError
+from ...utils.logging import log_info
+from ...utils.version.version_service import VersionService
+from ...utils.version.version_updater import VersionUpdater
+
+
+class VersionCommand(Command):
+    """Version command - manage project versions"""
+
+    def __init__(self) -> None:
+        """Initialize version command"""
+        self.version_service = VersionService()
+        self.version_updater = VersionUpdater()
+
+    @property
+    def name(self) -> str:
+        """Get command name"""
+        return "version"
+
+    @property
+    def help(self) -> str:
+        """Get command help text"""
+        return "Manage project versions"
+
+    def execute(self, *_, **kwargs: Any) -> None:
+        """Execute the version command."""
+        subcommand = kwargs.get("subcommand")
+        if subcommand == "show":
+            self._handle_show(kwargs)
+        elif subcommand == "sync":
+            self._handle_sync(kwargs)
+        elif subcommand == "bump":
+            self._handle_bump(kwargs)
+        else:
+            raise CommandError("Please specify a subcommand: show, sync, or bump")
+
+    def _handle_show(self, kwargs: dict[str, Any]) -> None:
+        """Handle show subcommand."""
+        current_version = self.version_service.get_current_version()
+        click.echo(f"Current version: {current_version}")
+
+    def _handle_sync(self, kwargs: dict[str, Any]) -> None:
+        """Handle sync subcommand."""
+        # Read version from VERSION file
+        from pathlib import Path
+
+        version_file = Path("VERSION")
+        if not version_file.exists():
+            raise CommandError("VERSION file not found")
+
+        current_version = version_file.read_text(encoding="utf-8").strip()
+
+        log_info(f"Syncing version {current_version} to all files...")
+
+        # Update all files
+        self.version_updater._update_python_version(current_version)
+        self.version_updater._update_rust_version(current_version)
+
+        log_info("✓ Version synchronization complete")
+
+    def _handle_bump(self, kwargs: dict[str, Any]) -> None:
+        """Handle bump subcommand."""
+        part = kwargs.get("part", "patch")
+
+        # Get current version
+        current_version = self.version_service.get_current_version()
+        log_info(f"Current version: {current_version}")
+
+        # Split version into parts
+        try:
+            version_parts = list(map(int, current_version.split(".")))
+            # Ensure we have at least 3 parts
+            while len(version_parts) < 3:
+                version_parts.append(0)
+
+            # Increment the specified part
+            if part == "major":
+                version_parts[0] += 1
+                version_parts[1] = 0
+                version_parts[2] = 0
+            elif part == "minor":
+                version_parts[1] += 1
+                version_parts[2] = 0
+            else:  # patch
+                version_parts[2] += 1
+
+            # If there's a 4th part, reset it
+            if len(version_parts) > 3:
+                version_parts[3] = 0
+
+            new_version = ".".join(map(str, version_parts))
+
+            log_info(f"New version: {new_version}")
+
+            # Update all files
+            self.version_updater._update_version_file(new_version)
+            self.version_updater._update_python_version(new_version)
+            self.version_updater._update_rust_version(new_version)
+
+            log_info(f"✓ Version bumped from {current_version} to {new_version}")
+
+        except Exception as e:
+            raise CommandError(f"Failed to bump version: {e}")
+
+
+@click.group(name="version")
+def version_group():
+    """Manage project versions"""
+    pass
+
+
+@version_group.command(name="show")
+def version_show():
+    """Show current project version"""
+    cmd = VersionCommand()
+    cmd.execute(subcommand="show")
+
+
+@version_group.command(name="sync")
+def version_sync():
+    """Sync VERSION file to __init__.py and Cargo.toml"""
+    cmd = VersionCommand()
+    cmd.execute(subcommand="sync")
+
+
+@version_group.command(name="bump")
+@click.argument(
+    "part",
+    type=click.Choice(["major", "minor", "patch"]),
+    default="patch",
+    required=False,
+)
+def version_bump(part: str):
+    """Increment version number (major, minor, patch)"""
+    cmd = VersionCommand()
+    cmd.execute(subcommand="bump", part=part)
+
+
+def version_command():
+    """Version command Click group."""
+    return version_group