py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/lfs/initializer.py

@@ -0,0 +1,531 @@
+"""LFS Lock workflow initialization (moved from initenv/services)."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from ...utils.platform_adapter import PlatformAdapter
+from ...utils.root import Root, RootKind
+from ...utils.root_fallback import current_root
+
+
+def lfs_lock_init_failure_message(project_root: Path | str) -> str:
+    """Return the bilingual error text for a missing ``.wl`` directory.
+
+    ``LfsLockInitializer.initialize()`` reports a project that was never
+    initialized by returning False; every caller must surface that as a failed
+    command instead of printing success (#194).
+    """
+    return (
+        "LFS lock workflow was not initialized: no .wl directory at "
+        f"{project_root}. Run 'wl init env' first.\n"
+        f"LFS 锁工作流未初始化：{project_root} 下没有 .wl 目录，请先运行 "
+        "'wl init env'。"
+    )
+
+
+class LfsLockInitializer:
+    """Coordinates the deployment of LFS lock workflow configuration."""
+
+    def __init__(self, project_root: Path | None = None) -> None:
+        # Root-anchored (#125): the *project* root the CWD belongs to, not the
+        # CWD itself, so ``wl init lfs`` from a subdirectory writes the lock
+        # config into the root's ``.wl`` (see ``initialize``) instead of
+        # silently no-op'ing because the subdirectory has no ``.wl``.
+        self.project_root = project_root or current_root(RootKind.PROJECT).path
+        self._wl_python_cache: str | None = None
+
+    def _wl_dir(self) -> Path:
+        """Return the root-anchored ``.wl`` directory of this project (#125)."""
+        return Root(self.project_root, RootKind.PROJECT).wl_dir()
+
+    def wl_dir_ready(self) -> bool:
+        """Return True when the project has a ``.wl`` directory.
+
+        Side-effect free, so callers can probe the precondition *before*
+        anything that mutates the repository runs (installing hooks,
+        rewriting config, deploying ``work.bat``). ``initialize()`` re-checks
+        because the directory could disappear between the probe and the
+        write (#198).
+        """
+        return self._wl_dir().is_dir()
+
+    def _run_uv_install(self, python_path: str, package_spec: str) -> bool:
+        """Try to install a package using uv pip install --python."""
+        uv_cmd = shutil.which("uv") or "uv"
+        try:
+            result = subprocess.run(
+                [uv_cmd, "pip", "install", "--python", python_path, package_spec],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            return result.returncode == 0
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ):
+            return False
+
+    def _run_pip_install(self, python_path: str, package_spec: str) -> bool:
+        """Try to install a package using python -m pip install."""
+        try:
+            result = subprocess.run(
+                [python_path, "-m", "pip", "install", package_spec],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            return result.returncode == 0
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ):
+            return False
+
+    def _check_watchdog_installed(self) -> bool:
+        """检查 watchdog 是否已安装。
+
+        Returns:
+            True if watchdog is installed, False otherwise.
+        """
+        try:
+            import watchdog  # noqa: F401  # availability probe (optional LFS extra)
+
+            return True
+        except ImportError:
+            return False
+
+    def _check_watchdog_in_wl_python(self) -> bool:
+        """检查 wl.exe 的 Python 环境中是否安装了 watchdog。
+
+        Returns:
+            True if watchdog is installed in wl's Python, False otherwise.
+        """
+        wl_python = self._find_wl_python_path()
+        if not wl_python:
+            return False
+
+        try:
+            result = subprocess.run(
+                [wl_python, "-c", "import watchdog"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            return result.returncode == 0
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ):
+            return False
+
+    def _get_python_executable(self) -> str:
+        """获取可用的 Python 可执行文件路径。
+
+        优先使用系统 Python，避免使用 wl.exe 绑定的 uv 环境。
+        总是返回一个路径（最后回退到 sys.executable）。
+        """
+        # 尝试常见的 Python 命令
+        python_commands = ["python", "python3", "py"]
+
+        for cmd in python_commands:
+            python_path = shutil.which(cmd)
+            if python_path:
+                return python_path
+
+        # 如果都找不到，返回 sys.executable 作为最后手段
+        return sys.executable
+
+    def _find_wl_python_path(self) -> str | None:
+        """查找 wl.exe 使用的 Python 解释器路径。
+
+        Returns:
+            Python 解释器路径，如果找不到则返回 None。
+        """
+        if self._wl_python_cache is not None:
+            return self._wl_python_cache
+
+        # 方法1：从 uv tools 目录查找
+        result = self._find_wl_python_from_uv_tools()
+        if result:
+            self._wl_python_cache = result
+            return result
+
+        # 方法2：从 wl.exe 位置查找
+        result = self._find_wl_python_from_wl_exe()
+        self._wl_python_cache = result
+        return result
+
+    def _find_wl_python_from_uv_tools(self) -> str | None:
+        """从 uv tools 目录查找 Python 解释器。"""
+        if PlatformAdapter.is_windows():
+            uv_tools_base = Path.home() / "AppData" / "Roaming" / "uv" / "tools"
+        else:
+            uv_tools_base = Path.home() / ".local" / "share" / "uv" / "tools"
+
+        if uv_tools_base.exists():
+            wl_cli_dir = uv_tools_base / "py-wlcli"
+            if wl_cli_dir.exists():
+                scripts_dir = wl_cli_dir / "Scripts"
+
+                # 尝试在 Scripts 目录中查找
+                python_in_scripts = scripts_dir / "python.exe"
+                if python_in_scripts.exists():
+                    return str(python_in_scripts)
+
+                # 直接在 wl-cli 目录中查找
+                python_in_tools = wl_cli_dir / "python.exe"
+                if python_in_tools.exists():
+                    return str(python_in_tools)
+
+                # 查找 python3.exe
+                python3_in_scripts = scripts_dir / "python3.exe"
+                if python3_in_scripts.exists():
+                    return str(python3_in_scripts)
+
+        return None
+
+    def _find_wl_python_from_wl_exe(self) -> str | None:
+        """从 wl.exe 位置查找 Python 解释器。"""
+        for cmd_name in ["wl", "wl.exe"]:
+            try:
+                result = subprocess.run(
+                    ["where" if PlatformAdapter.is_windows() else "which", cmd_name],
+                    capture_output=True,
+                    text=True,
+                    shell=False,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    wl_path = Path(result.stdout.strip().split("\n")[0].strip())
+                    if wl_path.exists():
+                        return self._search_python_around_wl_path(wl_path)
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                continue
+
+        return None
+
+    def _search_python_around_wl_path(self, wl_path: Path) -> str | None:
+        """在 wl.exe 路径周围搜索 Python 解释器。"""
+        # wl.exe 在 Scripts 目录中
+        scripts_dir = wl_path.parent
+        python_in_scripts = scripts_dir / "python.exe"
+        if python_in_scripts.exists():
+            return str(python_in_scripts)
+
+        # 向上查找
+        tools_dir = scripts_dir.parent
+        python_in_tools = tools_dir / "python.exe"
+        if python_in_tools.exists():
+            return str(python_in_tools)
+
+        # 在父目录中查找 Scripts
+        return self._search_parent_dirs_for_python(tools_dir)
+
+    def _search_parent_dirs_for_python(self, start_dir: Path) -> str | None:
+        """在父目录中搜索 Python 解释器。"""
+        for parent in start_dir.parents:
+            python_candidates = [
+                parent / "python.exe",
+                parent / "Scripts" / "python.exe",
+                parent / "bin" / "python",
+                parent / "bin" / "python.exe",
+            ]
+            for python_candidate in python_candidates:
+                if python_candidate.exists():
+                    return str(python_candidate)
+        return None
+
+    def _find_wl_python_version(self) -> str | None:
+        """查找 wl.exe 的 Python 版本。
+
+        Returns:
+            Python 版本字符串，如 "3.11", "3.12" 等，如果找不到则返回 None。
+        """
+        wl_python = self._find_wl_python_path()
+        if not wl_python:
+            return None
+
+        try:
+            result = subprocess.run(
+                [wl_python, "--version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                # 输出格式: "Python 3.11.x"
+                version_str = result.stdout.strip()
+                if "Python" in version_str:
+                    parts = version_str.split()
+                    if len(parts) >= 2:
+                        return parts[1]  # 返回 "3.11.x"
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ):
+            pass
+
+        return None
+
+    def _install_watchdog(self) -> bool:
+        import click
+
+        click.echo("Installing watchdog for LFS watch functionality...")
+        click.echo("正在安装 watchdog 以支持 LFS watch 功能...")
+
+        wl_python = self._find_wl_python_path()
+        if wl_python:
+            if self._run_uv_install(wl_python, "watchdog"):
+                click.echo(f"✓ watchdog installed via uv for {wl_python}")
+                click.echo("✓ watchdog 安装成功（通过 uv）")
+                return True
+            if self._run_pip_install(wl_python, "watchdog"):
+                click.echo(f"✓ watchdog installed via pip for {wl_python}")
+                click.echo("✓ watchdog 安装成功（通过 pip）")
+                return True
+
+        system_python = self._get_python_executable()
+        if self._run_pip_install(system_python, "watchdog"):
+            click.echo("✓ watchdog installed via system pip")
+            click.echo("✓ watchdog 安装成功")
+            return True
+
+        click.echo("Failed to install watchdog automatically.", err=True)
+        click.echo("无法自动安装 watchdog。", err=True)
+        return False
+
+    def _check_pyyaml_installed(self) -> bool:
+        """检查 wl.exe 的 Python 环境中是否安装了 PyYAML。
+
+        Returns:
+            True if PyYAML is installed in wl's Python, False otherwise.
+        """
+        wl_python = self._find_wl_python_path()
+        if not wl_python:
+            return False
+
+        try:
+            result = subprocess.run(
+                [wl_python, "-c", "import yaml"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            return result.returncode == 0
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ):
+            return False
+
+    def _install_pyyaml(self) -> bool:
+        import click
+
+        click.echo("Installing PyYAML for LFS lock configuration...")
+        click.echo("正在安装 PyYAML 以支持 LFS lock 配置...")
+
+        wl_python = self._find_wl_python_path()
+        if wl_python:
+            if self._run_uv_install(wl_python, "pyyaml>=6.0.0"):
+                click.echo(f"✓ PyYAML installed via uv for {wl_python}")
+                click.echo("✓ PyYAML 安装成功（通过 uv）")
+                return True
+            if self._run_pip_install(wl_python, "pyyaml>=6.0.0"):
+                click.echo(f"✓ PyYAML installed via pip for {wl_python}")
+                click.echo("✓ PyYAML 安装成功（通过 pip）")
+                return True
+
+        system_python = self._get_python_executable()
+        if self._run_pip_install(system_python, "pyyaml>=6.0.0"):
+            click.echo("✓ PyYAML installed via system pip")
+            click.echo("✓ PyYAML 安装成功")
+            return True
+
+        click.echo("Failed to install PyYAML automatically.", err=True)
+        click.echo("无法自动安装 PyYAML。", err=True)
+        return False
+
+    def _check_and_install_pyyaml(self) -> bool:
+        """检查并安装 PyYAML，如果未安装则提示用户。
+
+        Returns:
+            True if PyYAML is installed (either was already or just installed),
+            False if PyYAML could not be installed.
+        """
+        import click
+
+        # 检查 wl.exe 的 Python 中是否有 PyYAML
+        wl_has_pyyaml = self._check_pyyaml_installed()
+
+        if wl_has_pyyaml:
+            click.echo("✓ PyYAML is already installed")
+            click.echo("✓ PyYAML 已安装")
+            return True
+
+        click.echo("")
+        click.echo("=" * 50)
+        click.echo("WARNING: PyYAML is not installed in wl's Python!", err=True)
+        click.echo("警告: wl 的 Python 环境中未安装 PyYAML!", err=True)
+        click.echo("")
+        click.echo("PyYAML is required for loading LFS lock configuration.")
+        click.echo("Without PyYAML, only default configuration will be available.")
+        click.echo("")
+        click.echo("PyYAML 是加载 LFS lock 配置文件的必要依赖。")
+        click.echo("没有 PyYAML，只能使用默认配置。")
+        click.echo("=" * 50)
+
+        # 尝试自动安装
+        if self._install_pyyaml():
+            if self._check_pyyaml_installed():
+                return True
+
+        click.echo("")
+        click.echo("Please install PyYAML manually by running:")
+        click.echo("请手动安装 PyYAML，运行以下命令:")
+        click.echo("")
+        click.echo("  uv pip install --python <wl-python-path> pyyaml>=6.0.0")
+        click.echo("")
+        wl_python = self._find_wl_python_path()
+        if wl_python:
+            click.echo(
+                f'  Example: uv pip install --python "{wl_python}" pyyaml>=6.0.0'
+            )
+        click.echo("")
+
+        return False
+
+    def _check_and_install_watchdog(self) -> bool:
+        """检查并安装 watchdog，如果未安装则提示用户。
+
+        Returns:
+            True if watchdog is installed (either was already or just installed),
+            False if watchdog could not be installed.
+        """
+        import click
+
+        # 检查用户系统的 Python 中是否有 watchdog
+        system_has_watchdog = self._check_watchdog_installed()
+
+        # 检查 wl.exe 的 Python 中是否有 watchdog
+        wl_has_watchdog = self._check_watchdog_in_wl_python()
+
+        if system_has_watchdog and wl_has_watchdog:
+            click.echo("✓ watchdog is already installed")
+            click.echo("✓ watchdog 已安装")
+            return True
+
+        if not wl_has_watchdog:
+            click.echo("")
+            click.echo("=" * 50)
+            click.echo("WARNING: watchdog is not installed in wl's Python!", err=True)
+            click.echo("警告: wl 的 Python 环境中未安装 watchdog!", err=True)
+            click.echo("")
+            click.echo("watchdog is required for 'wl lfs watch' functionality.")
+            click.echo("The work.bat script needs watchdog to monitor file changes.")
+            click.echo("")
+            click.echo("watchdog 是 'wl lfs watch' 功能的必要依赖。")
+            click.echo("work.bat 脚本需要 watchdog 来监控文件变化。")
+            click.echo("")
+
+            # 尝试自动安装
+            if self._install_watchdog():
+                # 再次检查是否安装成功
+                if self._check_watchdog_in_wl_python():
+                    return True
+
+            click.echo("")
+            click.echo("Please install watchdog manually by running:")
+            click.echo("请手动安装 watchdog，运行以下命令:")
+            click.echo("")
+            click.echo("  uv pip install --python <wl-python-path> watchdog")
+            click.echo("")
+            wl_python = self._find_wl_python_path()
+            if wl_python:
+                click.echo(f'  Example: uv pip install --python "{wl_python}" watchdog')
+            click.echo("")
+            click.echo("=" * 50)
+            return False
+
+        click.echo("✓ watchdog is already installed")
+        click.echo("✓ watchdog 已安装")
+        return True
+
+    def _deploy_work_bat(self) -> None:
+        """Copy work.bat template to project root on Windows platforms."""
+        if not PlatformAdapter.is_windows():
+            return
+
+        import importlib.resources
+
+        bat_path = self.project_root / "work.bat"
+        try:
+            template = importlib.resources.files("wl_cli.vendors.hooks.win").joinpath(
+                "work.bat"
+            )
+            shutil.copy(str(template), str(bat_path))
+            import click
+
+            click.echo(f"  work.bat created at {bat_path}")
+            click.echo("  Double-click work.bat to start an LFS work session.")
+        except Exception as e:
+            import click
+
+            click.echo(f"  Warning: could not create work.bat: {e}", err=True)
+
+    def initialize(self) -> bool:
+        """Write .wl/lfs-lock.yml if it does not exist, or upgrade from v1.
+
+        Returns:
+            True when the lock workflow config is in place, False when the
+            project has no ``.wl`` directory yet (the project was never
+            initialized). Callers must treat False as a failure and tell the
+            user to run ``wl init env`` first — never as a silent skip (#194).
+        """
+        wl_dir = self._wl_dir()
+        if not self.wl_dir_ready():
+            return False
+
+        # 检查并安装必要依赖
+        self._check_and_install_watchdog()
+        self._check_and_install_pyyaml()
+
+        config_path = wl_dir / "lfs-lock.yml"
+        if config_path.exists():
+            existing = config_path.read_text()
+            if "auto_lock:" in existing:
+                # Deploy work.bat even when config already exists
+                self._deploy_work_bat()
+                return True
+            # v1 config detected — upgrade to v2
+
+        content = (
+            "# Git LFS file lock workflow configuration\n"
+            "# See: wl lfs --help\n"
+            "\n"
+            "lock:\n"
+            "  mode: strict          # strict | warn | off\n"
+            "\n"
+            "auto_lock:\n"
+            "  fallback: true        # pre-push auto-lock when watch not running\n"
+            "  skip_locked_by_others: true\n"
+            "\n"
+            "auto_unlock:\n"
+            "  on_push: true         # auto-unlock after push detection\n"
+            "  retry_count: 3\n"
+            "  retry_delay: 2\n"
+            "\n"
+            "checks:\n"
+            "  pre_push: true\n"
+        )
+        config_path.write_text(content)
+        self._deploy_work_bat()
+        return True

wl_cli/commands/lfs/manager.py

@@ -0,0 +1,95 @@
+"""LFS lock manager — wraps git lfs lock/unlock/locks and git check-attr."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+
+
+class LfsLockManager:
+    """Manages git LFS file locks by wrapping native git lfs commands."""
+
+    def __init__(self, cwd: str | None = None) -> None:
+        self.cwd = cwd
+
+    def _run_git(self, args: list[str], **kwargs) -> subprocess.CompletedProcess:
+        return subprocess.run(
+            ["git", *args],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            cwd=self.cwd,
+            **kwargs,
+        )
+
+    def get_lfs_files(self, changed_files: frozenset[str]) -> frozenset[str]:
+        """Filter a set of file paths to only those tracked by Git LFS."""
+        return frozenset(f for f in changed_files if self.is_file_lfs_tracked(f))
+
+    def is_file_lfs_tracked(self, file_path: str) -> bool:
+        """Check if a file matches an LFS filter in .gitattributes."""
+        result = self._run_git(["check-attr", "filter", "--", file_path])
+        if result.returncode != 0:
+            return False
+        return "filter: lfs" in result.stdout
+
+    def lock(self, file_path: str) -> tuple[bool, str]:
+        """Lock an LFS file.
+
+        Returns:
+            tuple of (success: bool, error_reason: str).
+            error_reason is empty string on success.
+        """
+        result = self._run_git(["lfs", "lock", file_path])
+        if result.returncode == 0:
+            return True, ""
+
+        # 解析错误原因
+        stderr = (result.stderr or "").lower()
+        if "already locked" in stderr:
+            # 提取锁定者信息
+            if "by" in stderr:
+                locked_by = stderr.split("by")[-1].strip()
+                if locked_by:
+                    return False, f"already locked by {locked_by}"
+            return False, "already locked"
+        elif "not found" in stderr or "does not exist" in stderr:
+            return False, "file not found"
+        elif "not tracked" in stderr or "not an lfs object" in stderr:
+            return False, "not tracked by LFS"
+        elif "authentication" in stderr or "login" in stderr:
+            return False, "authentication required"
+        elif "network" in stderr or "connection" in stderr or "timeout" in stderr:
+            return False, "network error"
+        else:
+            return False, "unknown error"
+
+    def unlock(self, file_path: str, force: bool = False) -> bool:
+        """Unlock an LFS file. Use force=True for admin force-unlock."""
+        cmd = ["lfs", "unlock"]
+        if force:
+            cmd.append("--force")
+        cmd.append(file_path)
+        result = self._run_git(cmd)
+        return result.returncode == 0
+
+    def get_locks(self, timeout: int | None = None) -> list[dict]:
+        """Return all current LFS locks as a list of dicts."""
+        result = self._run_git(["lfs", "locks", "--json"], timeout=timeout)
+        if result.returncode != 0 or not result.stdout.strip():
+            return []
+        return [json.loads(line) for line in result.stdout.splitlines() if line]
+
+    def lock_files(self, files: list[str]) -> dict[str, tuple[bool, str]]:
+        """Lock multiple LFS files. Returns {file_path: (success, reason)} for each."""
+        results: dict[str, tuple[bool, str]] = {}
+        for file_path in files:
+            results[file_path] = self.lock(file_path)
+        return results
+
+    def unlock_files(self, files: list[str]) -> dict[str, bool]:
+        """Unlock multiple LFS files. Returns {file_path: success} for each."""
+        results: dict[str, bool] = {}
+        for file_path in files:
+            results[file_path] = self.unlock(file_path)
+        return results